Index: clang/.clang-format
===================================================================
--- clang/.clang-format
+++ clang/.clang-format
@@ -1 +1,3 @@
 BasedOnStyle: LLVM
+QualifierAlignment: Custom
+QualifierOrder: [ inline, static, type, const, volatile, restrict ]
Index: clang/docs/ClangFormatStyleOptions.rst
===================================================================
--- clang/docs/ClangFormatStyleOptions.rst
+++ clang/docs/ClangFormatStyleOptions.rst
@@ -3225,6 +3225,73 @@
 
 
 
+**QualifierAlignment** (``QualifierAlignmentStyle``)
+  Different ways to arrange const/volatile qualifiers.
+
+  Possible values:
+
+  * ``QAS_Leave`` (in configuration: ``Leave``)
+    Don't change specifiers/qualifier to either Left or Right alignment
+
+    .. code-block:: c++
+
+       int const a;
+       const int *a;
+
+  * ``QAS_Left`` (in configuration: ``Left``)
+    Change specifiers/qualifiers to be Left aligned.
+
+    .. code-block:: c++
+
+       const int a;
+       const int *a;
+
+  * ``QAS_Right`` (in configuration: ``Right``)
+    Change specifiers/qualifiers to be Right aligned.
+
+    .. code-block:: c++
+
+       int const a;
+       int const *a;
+
+  * ``QAS_Custom`` (in configuration: ``Custom``)
+    Change specifiers/qualifiers to be aligned based on QualfierOrder.
+    With:
+
+    .. code-block:: yaml
+
+      QualifierOrder: ['inline', 'static' , '<type>', 'const']
+
+
+    .. code-block:: c++
+
+
+       int const a;
+       int const *a;
+
+
+
+**QualifierOrder** (``std::vector<std::string>``)
+  The Order in which the qualifiers appear.
+  Order is a an array can contain any of the following
+
+    * const
+    * inline
+    * static
+    * constexpr
+    * volatile
+    * restrict
+    * type
+
+  Note: it MUST contain 'type'.
+  Items to the left of type will be aligned in the order supplied.
+  Items to the right of type will be aligned  in the order supplied.
+
+
+  .. code-block:: yaml
+
+    QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ]
+
 **RawStringFormats** (``std::vector<RawStringFormat>``)
   Defines hints for detecting supported languages code blocks in raw
   strings.
Index: clang/docs/ReleaseNotes.rst
===================================================================
--- clang/docs/ReleaseNotes.rst
+++ clang/docs/ReleaseNotes.rst
@@ -188,6 +188,16 @@
 - Option ``AllowShortEnumsOnASingleLine: false`` has been improved, it now
   correctly places the opening brace according to ``BraceWrapping.AfterEnum``.
 
+- Option ``QualifierAligment`` has been added in order to auto-arrange the
+  positioning of specifiers/qualifiers
+  `const` `volatile` `static` `inline` `constexpr` `restrict`
+  in variable and parameter declarations to be either ``Right`` aligned
+  or ``Left`` aligned or ``Custom`` using ``QualifierOrder``.
+
+- Option ``QualifierOrder`` has been added to allow the order
+  `const` `volatile` `static` `inline` `constexpr` `restrict`
+  to be controlled relative to the `<type>`.
+
 libclang
 --------
 
Index: clang/include/clang/Format/Format.h
===================================================================
--- clang/include/clang/Format/Format.h
+++ clang/include/clang/Format/Format.h
@@ -40,7 +40,11 @@
   Success = 0,
   Error,
   Unsuitable,
-  BinPackTrailingCommaConflict
+  BinPackTrailingCommaConflict,
+  InvalidQualifierSpecified,
+  DuplicateQualifierSpecified,
+  MissingQualifierType,
+  MissingQualifierOrder
 };
 class ParseErrorCategory final : public std::error_category {
 public:
@@ -1819,6 +1823,63 @@
   /// \endcode
   std::string CommentPragmas;
 
+  /// Different const/volatile qualifier alignment styles.
+  enum QualifierAlignmentStyle {
+    /// Don't change specifiers/qualifier to either Left or Right alignment
+    /// \code
+    ///    int const a;
+    ///    const int *a;
+    /// \endcode
+    QAS_Leave,
+    /// Change specifiers/qualifiers to be Left aligned.
+    /// \code
+    ///    const int a;
+    ///    const int *a;
+    /// \endcode
+    QAS_Left,
+    /// Change specifiers/qualifiers to be Right aligned.
+    /// \code
+    ///    int const a;
+    ///    int const *a;
+    /// \endcode
+    QAS_Right,
+    /// Change specifiers/qualifiers to be aligned based on QualfierOrder.
+    /// With:
+    /// \code{.yaml}
+    ///   QualifierOrder: ['inline', 'static' , '<type>', 'const']
+    /// \endcode
+    ///
+    /// \code
+    ///
+    ///    int const a;
+    ///    int const *a;
+    /// \endcode
+    QAS_Custom
+  };
+
+  /// Different ways to arrange const/volatile qualifiers.
+  QualifierAlignmentStyle QualifierAlignment;
+
+  /// The Order in which the qualifiers appear.
+  /// Order is a an array can contain any of the following
+  ///
+  ///   * const
+  ///   * inline
+  ///   * static
+  ///   * constexpr
+  ///   * volatile
+  ///   * restrict
+  ///   * type
+  ///
+  /// Note: it MUST contain 'type'.
+  /// Items to the left of type will be aligned in the order supplied.
+  /// Items to the right of type will be aligned  in the order supplied.
+  ///
+  /// \code{.yaml}
+  ///   QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ]
+  /// \endcode
+  std::vector<std::string> QualifierOrder;
+
   /// Different ways to break inheritance list.
   enum BreakInheritanceListStyle : unsigned char {
     /// Break inheritance list before the colon and after the commas.
@@ -3496,6 +3557,8 @@
            PenaltyBreakTemplateDeclaration ==
                R.PenaltyBreakTemplateDeclaration &&
            PointerAlignment == R.PointerAlignment &&
+           QualifierAlignment == R.QualifierAlignment &&
+           QualifierOrder == R.QualifierOrder &&
            RawStringFormats == R.RawStringFormats &&
            ReferenceAlignment == R.ReferenceAlignment &&
            ShortNamespaceLines == R.ShortNamespaceLines &&
Index: clang/lib/AST/APValue.cpp
===================================================================
--- clang/lib/AST/APValue.cpp
+++ clang/lib/AST/APValue.cpp
@@ -24,11 +24,11 @@
 
 /// The identity of a type_info object depends on the canonical unqualified
 /// type only.
-TypeInfoLValue::TypeInfoLValue(const Type *T)
+TypeInfoLValue::TypeInfoLValue(Type const *T)
     : T(T->getCanonicalTypeUnqualified().getTypePtr()) {}
 
 void TypeInfoLValue::print(llvm::raw_ostream &Out,
-                           const PrintingPolicy &Policy) const {
+                           PrintingPolicy const &Policy) const {
   Out << "typeid(";
   QualType(getType(), 0).print(Out, Policy);
   Out << ")";
@@ -39,9 +39,9 @@
         alignof(Type),
     "Type is insufficiently aligned");
 
-APValue::LValueBase::LValueBase(const ValueDecl *P, unsigned I, unsigned V)
+APValue::LValueBase::LValueBase(ValueDecl const *P, unsigned I, unsigned V)
     : Ptr(P ? cast<ValueDecl>(P->getCanonicalDecl()) : nullptr), Local{I, V} {}
-APValue::LValueBase::LValueBase(const Expr *P, unsigned I, unsigned V)
+APValue::LValueBase::LValueBase(Expr const *P, unsigned I, unsigned V)
     : Ptr(P), Local{I, V} {}
 
 APValue::LValueBase APValue::LValueBase::getDynamicAlloc(DynamicAllocLValue LV,
@@ -61,8 +61,9 @@
 }
 
 QualType APValue::LValueBase::getType() const {
-  if (!*this) return QualType();
-  if (const ValueDecl *D = dyn_cast<const ValueDecl*>()) {
+  if (!*this)
+    return QualType();
+  if (ValueDecl const *D = dyn_cast<ValueDecl const *>()) {
     // FIXME: It's unclear where we're supposed to take the type from, and
     // this actually matters for arrays of unknown bound. Eg:
     //
@@ -85,17 +86,17 @@
   if (is<DynamicAllocLValue>())
     return getDynamicAllocType();
 
-  const Expr *Base = get<const Expr*>();
+  Expr const *Base = get<Expr const *>();
 
   // For a materialized temporary, the type of the temporary we materialized
   // may not be the type of the expression.
-  if (const MaterializeTemporaryExpr *MTE =
+  if (MaterializeTemporaryExpr const *MTE =
           clang::dyn_cast<MaterializeTemporaryExpr>(Base)) {
-    SmallVector<const Expr *, 2> CommaLHSs;
+    SmallVector<Expr const *, 2> CommaLHSs;
     SmallVector<SubobjectAdjustment, 2> Adjustments;
-    const Expr *Temp = MTE->getSubExpr();
-    const Expr *Inner = Temp->skipRValueSubobjectAdjustments(CommaLHSs,
-                                                             Adjustments);
+    Expr const *Temp = MTE->getSubExpr();
+    Expr const *Inner =
+        Temp->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
     // Keep any cv-qualifiers from the reference if we generated a temporary
     // for it directly. Otherwise use the type after adjustment.
     if (!Adjustments.empty())
@@ -133,8 +134,8 @@
 }
 
 namespace clang {
-bool operator==(const APValue::LValueBase &LHS,
-                const APValue::LValueBase &RHS) {
+bool operator==(APValue::LValueBase const &LHS,
+                APValue::LValueBase const &RHS) {
   if (LHS.Ptr != RHS.Ptr)
     return false;
   if (LHS.is<TypeInfoLValue>() || LHS.is<DynamicAllocLValue>())
@@ -142,10 +143,10 @@
   return LHS.Local.CallIndex == RHS.Local.CallIndex &&
          LHS.Local.Version == RHS.Local.Version;
 }
-}
+} // namespace clang
 
 APValue::LValuePathEntry::LValuePathEntry(BaseOrMemberType BaseOrMember) {
-  if (const Decl *D = BaseOrMember.getPointer())
+  if (Decl const *D = BaseOrMember.getPointer())
     BaseOrMember.setPointer(D->getCanonicalDecl());
   Value = reinterpret_cast<uintptr_t>(BaseOrMember.getOpaqueValue());
 }
@@ -156,70 +157,66 @@
 
 APValue::LValuePathSerializationHelper::LValuePathSerializationHelper(
     ArrayRef<LValuePathEntry> Path, QualType ElemTy)
-    : ElemTy((const void *)ElemTy.getTypePtrOrNull()), Path(Path) {}
+    : ElemTy((void const *)ElemTy.getTypePtrOrNull()), Path(Path) {}
 
 QualType APValue::LValuePathSerializationHelper::getType() {
   return QualType::getFromOpaquePtr(ElemTy);
 }
 
 namespace {
-  struct LVBase {
-    APValue::LValueBase Base;
-    CharUnits Offset;
-    unsigned PathLength;
-    bool IsNullPtr : 1;
-    bool IsOnePastTheEnd : 1;
-  };
-}
+struct LVBase {
+  APValue::LValueBase Base;
+  CharUnits Offset;
+  unsigned PathLength;
+  bool IsNullPtr : 1;
+  bool IsOnePastTheEnd : 1;
+};
+} // namespace
 
 void *APValue::LValueBase::getOpaqueValue() const {
   return Ptr.getOpaqueValue();
 }
 
-bool APValue::LValueBase::isNull() const {
-  return Ptr.isNull();
-}
+bool APValue::LValueBase::isNull() const { return Ptr.isNull(); }
 
-APValue::LValueBase::operator bool () const {
-  return static_cast<bool>(Ptr);
-}
+APValue::LValueBase::operator bool() const { return static_cast<bool>(Ptr); }
 
 clang::APValue::LValueBase
 llvm::DenseMapInfo<clang::APValue::LValueBase>::getEmptyKey() {
   clang::APValue::LValueBase B;
-  B.Ptr = DenseMapInfo<const ValueDecl*>::getEmptyKey();
+  B.Ptr = DenseMapInfo<ValueDecl const *>::getEmptyKey();
   return B;
 }
 
 clang::APValue::LValueBase
 llvm::DenseMapInfo<clang::APValue::LValueBase>::getTombstoneKey() {
   clang::APValue::LValueBase B;
-  B.Ptr = DenseMapInfo<const ValueDecl*>::getTombstoneKey();
+  B.Ptr = DenseMapInfo<ValueDecl const *>::getTombstoneKey();
   return B;
 }
 
 namespace clang {
-llvm::hash_code hash_value(const APValue::LValueBase &Base) {
+llvm::hash_code hash_value(APValue::LValueBase const &Base) {
   if (Base.is<TypeInfoLValue>() || Base.is<DynamicAllocLValue>())
     return llvm::hash_value(Base.getOpaqueValue());
   return llvm::hash_combine(Base.getOpaqueValue(), Base.getCallIndex(),
                             Base.getVersion());
 }
-}
+} // namespace clang
 
 unsigned llvm::DenseMapInfo<clang::APValue::LValueBase>::getHashValue(
-    const clang::APValue::LValueBase &Base) {
+    clang::APValue::LValueBase const &Base) {
   return hash_value(Base);
 }
 
 bool llvm::DenseMapInfo<clang::APValue::LValueBase>::isEqual(
-    const clang::APValue::LValueBase &LHS,
-    const clang::APValue::LValueBase &RHS) {
+    clang::APValue::LValueBase const &LHS,
+    clang::APValue::LValueBase const &RHS) {
   return LHS == RHS;
 }
 
 struct APValue::LV : LVBase {
-  static const unsigned InlinePathSpace =
+  static unsigned const InlinePathSpace =
       (DataSize - sizeof(LVBase)) / sizeof(LValuePathEntry);
 
   /// Path - The sequence of base classes, fields and array indices to follow to
@@ -237,7 +234,7 @@
     if (Length == PathLength)
       return;
     if (hasPathPtr())
-      delete [] PathPtr;
+      delete[] PathPtr;
     PathLength = Length;
     if (hasPathPtr())
       PathPtr = new LValuePathEntry[Length];
@@ -247,22 +244,22 @@
   bool hasPathPtr() const { return hasPath() && PathLength > InlinePathSpace; }
 
   LValuePathEntry *getPath() { return hasPathPtr() ? PathPtr : Path; }
-  const LValuePathEntry *getPath() const {
+  LValuePathEntry const *getPath() const {
     return hasPathPtr() ? PathPtr : Path;
   }
 };
 
 namespace {
-  struct MemberPointerBase {
-    llvm::PointerIntPair<const ValueDecl*, 1, bool> MemberAndIsDerivedMember;
-    unsigned PathLength;
-  };
-}
+struct MemberPointerBase {
+  llvm::PointerIntPair<ValueDecl const *, 1, bool> MemberAndIsDerivedMember;
+  unsigned PathLength;
+};
+} // namespace
 
 struct APValue::MemberPointerData : MemberPointerBase {
-  static const unsigned InlinePathSpace =
-      (DataSize - sizeof(MemberPointerBase)) / sizeof(const CXXRecordDecl*);
-  typedef const CXXRecordDecl *PathElem;
+  static unsigned const InlinePathSpace =
+      (DataSize - sizeof(MemberPointerBase)) / sizeof(CXXRecordDecl const *);
+  typedef CXXRecordDecl const *PathElem;
   union {
     PathElem Path[InlinePathSpace];
     PathElem *PathPtr;
@@ -275,7 +272,7 @@
     if (Length == PathLength)
       return;
     if (hasPathPtr())
-      delete [] PathPtr;
+      delete[] PathPtr;
     PathLength = Length;
     if (hasPathPtr())
       PathPtr = new PathElem[Length];
@@ -284,31 +281,25 @@
   bool hasPathPtr() const { return PathLength > InlinePathSpace; }
 
   PathElem *getPath() { return hasPathPtr() ? PathPtr : Path; }
-  const PathElem *getPath() const {
-    return hasPathPtr() ? PathPtr : Path;
-  }
+  PathElem const *getPath() const { return hasPathPtr() ? PathPtr : Path; }
 };
 
 // FIXME: Reduce the malloc traffic here.
 
-APValue::Arr::Arr(unsigned NumElts, unsigned Size) :
-  Elts(new APValue[NumElts + (NumElts != Size ? 1 : 0)]),
-  NumElts(NumElts), ArrSize(Size) {}
-APValue::Arr::~Arr() { delete [] Elts; }
+APValue::Arr::Arr(unsigned NumElts, unsigned Size)
+    : Elts(new APValue[NumElts + (NumElts != Size ? 1 : 0)]), NumElts(NumElts),
+      ArrSize(Size) {}
+APValue::Arr::~Arr() { delete[] Elts; }
 
-APValue::StructData::StructData(unsigned NumBases, unsigned NumFields) :
-  Elts(new APValue[NumBases+NumFields]),
-  NumBases(NumBases), NumFields(NumFields) {}
-APValue::StructData::~StructData() {
-  delete [] Elts;
-}
+APValue::StructData::StructData(unsigned NumBases, unsigned NumFields)
+    : Elts(new APValue[NumBases + NumFields]), NumBases(NumBases),
+      NumFields(NumFields) {}
+APValue::StructData::~StructData() { delete[] Elts; }
 
 APValue::UnionData::UnionData() : Field(nullptr), Value(new APValue) {}
-APValue::UnionData::~UnionData () {
-  delete Value;
-}
+APValue::UnionData::~UnionData() { delete Value; }
 
-APValue::APValue(const APValue &RHS) : Kind(None) {
+APValue::APValue(APValue const &RHS) : Kind(None) {
   switch (RHS.getKind()) {
   case None:
   case Indeterminate:
@@ -329,7 +320,7 @@
   }
   case Vector:
     MakeVector();
-    setVector(((const Vec *)(const char *)&RHS.Data)->Elts,
+    setVector(((Vec const *)(char const *)&RHS.Data)->Elts,
               RHS.getVectorLength());
     break;
   case ComplexInt:
@@ -383,7 +374,7 @@
   RHS.Kind = None;
 }
 
-APValue &APValue::operator=(const APValue &RHS) {
+APValue &APValue::operator=(APValue const &RHS) {
   if (this != &RHS)
     *this = APValue(RHS);
   return *this;
@@ -458,7 +449,7 @@
   case LValue:
     return reinterpret_cast<const LV *>(&Data)->hasPathPtr();
   case MemberPointer:
-    return reinterpret_cast<const MemberPointerData *>(&Data)->hasPathPtr();
+    return reinterpret_cast<MemberPointerData const *>(&Data)->hasPathPtr();
   }
   llvm_unreachable("Unknown APValue kind!");
 }
@@ -469,7 +460,7 @@
 }
 
 /// Profile the value of an APInt, excluding its bit-width.
-static void profileIntValue(llvm::FoldingSetNodeID &ID, const llvm::APInt &V) {
+static void profileIntValue(llvm::FoldingSetNodeID &ID, llvm::APInt const &V) {
   for (unsigned I = 0, N = V.getBitWidth(); I < N; I += 32)
     ID.AddInteger((uint32_t)V.extractBitsAsZExtValue(std::min(32u, N - I), I));
 }
@@ -609,7 +600,7 @@
   case MemberPointer:
     ID.AddPointer(getMemberPointerDecl());
     ID.AddInteger(isMemberPointerToDerivedMember());
-    for (const CXXRecordDecl *D : getMemberPointerPath())
+    for (CXXRecordDecl const *D : getMemberPointerPath())
       ID.AddPointer(D);
     return;
   }
@@ -617,7 +608,7 @@
   llvm_unreachable("Unknown APValue kind!");
 }
 
-static double GetApproxValue(const llvm::APFloat &F) {
+static double GetApproxValue(llvm::APFloat const &F) {
   llvm::APFloat V = F;
   bool ignored;
   V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
@@ -625,13 +616,13 @@
   return V.convertToDouble();
 }
 
-void APValue::printPretty(raw_ostream &Out, const ASTContext &Ctx,
+void APValue::printPretty(raw_ostream &Out, ASTContext const &Ctx,
                           QualType Ty) const {
   printPretty(Out, Ctx.getPrintingPolicy(), Ty, &Ctx);
 }
 
-void APValue::printPretty(raw_ostream &Out, const PrintingPolicy &Policy,
-                          QualType Ty, const ASTContext *Ctx) const {
+void APValue::printPretty(raw_ostream &Out, PrintingPolicy const &Policy,
+                          QualType Ty, ASTContext const *Ctx) const {
   // There are no objects of type 'void', but values of this type can be
   // returned from functions.
   if (Ty->isVoidType()) {
@@ -678,8 +669,8 @@
     return;
   case APValue::LValue: {
     bool IsReference = Ty->isReferenceType();
-    QualType InnerTy
-      = IsReference ? Ty.getNonReferenceType() : Ty->getPointeeType();
+    QualType InnerTy =
+        IsReference ? Ty.getNonReferenceType() : Ty->getPointeeType();
     if (InnerTy.isNull())
       InnerTy = Ty;
 
@@ -713,18 +704,17 @@
         Out << '&';
       }
 
-      if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
+      if (ValueDecl const *VD = Base.dyn_cast<ValueDecl const *>())
         Out << *VD;
       else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
         TI.print(Out, Policy);
       } else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
-        Out << "{*new "
-            << Base.getDynamicAllocType().stream(Policy) << "#"
+        Out << "{*new " << Base.getDynamicAllocType().stream(Policy) << "#"
             << DA.getIndex() << "}";
       } else {
-        assert(Base.get<const Expr *>() != nullptr &&
+        assert(Base.get<Expr const *>() != nullptr &&
                "Expecting non-null Expr");
-        Base.get<const Expr*>()->printPretty(Out, nullptr, Policy);
+        Base.get<Expr const *>()->printPretty(Out, nullptr, Policy);
       }
 
       if (!O.isZero()) {
@@ -742,7 +732,7 @@
       Out << "*(&";
 
     QualType ElemTy = Base.getType();
-    if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
+    if (ValueDecl const *VD = Base.dyn_cast<ValueDecl const *>()) {
       Out << *VD;
     } else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
       TI.print(Out, Policy);
@@ -750,24 +740,24 @@
       Out << "{*new " << Base.getDynamicAllocType().stream(Policy) << "#"
           << DA.getIndex() << "}";
     } else {
-      const Expr *E = Base.get<const Expr*>();
+      Expr const *E = Base.get<Expr const *>();
       assert(E != nullptr && "Expecting non-null Expr");
       E->printPretty(Out, nullptr, Policy);
     }
 
     ArrayRef<LValuePathEntry> Path = getLValuePath();
-    const CXXRecordDecl *CastToBase = nullptr;
+    CXXRecordDecl const *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)) {
+        Decl const *BaseOrMember = Path[I].getAsBaseOrMember().getPointer();
+        if (CXXRecordDecl const *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) {
           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);
+          ValueDecl const *VD = cast<ValueDecl>(BaseOrMember);
           Out << ".";
           if (CastToBase)
             Out << *CastToBase << "::";
@@ -792,7 +782,7 @@
     return;
   }
   case APValue::Array: {
-    const ArrayType *AT = Ty->castAsArrayTypeUnsafe();
+    ArrayType const *AT = Ty->castAsArrayTypeUnsafe();
     QualType ElemTy = AT->getElementType();
     Out << '{';
     if (unsigned N = getArrayInitializedElts()) {
@@ -812,10 +802,10 @@
   }
   case APValue::Struct: {
     Out << '{';
-    const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();
+    RecordDecl const *RD = Ty->castAs<RecordType>()->getDecl();
     bool First = true;
     if (unsigned N = getStructNumBases()) {
-      const CXXRecordDecl *CD = cast<CXXRecordDecl>(RD);
+      CXXRecordDecl const *CD = cast<CXXRecordDecl>(RD);
       CXXRecordDecl::base_class_const_iterator BI = CD->bases_begin();
       for (unsigned I = 0; I != N; ++I, ++BI) {
         assert(BI != CD->bases_end());
@@ -825,12 +815,13 @@
         First = false;
       }
     }
-    for (const auto *FI : RD->fields()) {
+    for (auto const *FI : RD->fields()) {
       if (!First)
         Out << ", ";
-      if (FI->isUnnamedBitfield()) continue;
-      getStructField(FI->getFieldIndex()).
-        printPretty(Out, Policy, FI->getType(), Ctx);
+      if (FI->isUnnamedBitfield())
+        continue;
+      getStructField(FI->getFieldIndex())
+          .printPretty(Out, Policy, FI->getType(), Ctx);
       First = false;
     }
     Out << '}';
@@ -838,7 +829,7 @@
   }
   case APValue::Union:
     Out << '{';
-    if (const FieldDecl *FD = getUnionField()) {
+    if (FieldDecl const *FD = getUnionField()) {
       Out << "." << *FD << " = ";
       getUnionValue().printPretty(Out, Policy, FD->getType(), Ctx);
     }
@@ -847,7 +838,7 @@
   case APValue::MemberPointer:
     // FIXME: This is not enough to unambiguously identify the member in a
     // multiple-inheritance scenario.
-    if (const ValueDecl *VD = getMemberPointerDecl()) {
+    if (ValueDecl const *VD = getMemberPointerDecl()) {
       Out << '&' << *cast<CXXRecordDecl>(VD->getDeclContext()) << "::" << *VD;
       return;
     }
@@ -862,7 +853,7 @@
   llvm_unreachable("Unknown APValue kind!");
 }
 
-std::string APValue::getAsString(const ASTContext &Ctx, QualType Ty) const {
+std::string APValue::getAsString(ASTContext const &Ctx, QualType Ty) const {
   std::string Result;
   llvm::raw_string_ostream Out(Result);
   printPretty(Out, Ctx, Ty);
@@ -871,7 +862,7 @@
 }
 
 bool APValue::toIntegralConstant(APSInt &Result, QualType SrcTy,
-                                 const ASTContext &Ctx) const {
+                                 ASTContext const &Ctx) const {
   if (isInt()) {
     Result = getInt();
     return true;
@@ -892,12 +883,12 @@
 
 const APValue::LValueBase APValue::getLValueBase() const {
   assert(isLValue() && "Invalid accessor");
-  return ((const LV *)(const void *)&Data)->Base;
+  return ((const LV *)(void const *)&Data)->Base;
 }
 
 bool APValue::isLValueOnePastTheEnd() const {
   assert(isLValue() && "Invalid accessor");
-  return ((const LV *)(const void *)&Data)->IsOnePastTheEnd;
+  return ((const LV *)(void const *)&Data)->IsOnePastTheEnd;
 }
 
 CharUnits &APValue::getLValueOffset() {
@@ -907,31 +898,31 @@
 
 bool APValue::hasLValuePath() const {
   assert(isLValue() && "Invalid accessor");
-  return ((const LV *)(const char *)&Data)->hasPath();
+  return ((const LV *)(char const *)&Data)->hasPath();
 }
 
 ArrayRef<APValue::LValuePathEntry> APValue::getLValuePath() const {
   assert(isLValue() && hasLValuePath() && "Invalid accessor");
-  const LV &LVal = *((const LV *)(const char *)&Data);
+  const LV &LVal = *((const LV *)(char const *)&Data);
   return llvm::makeArrayRef(LVal.getPath(), LVal.PathLength);
 }
 
 unsigned APValue::getLValueCallIndex() const {
   assert(isLValue() && "Invalid accessor");
-  return ((const LV *)(const char *)&Data)->Base.getCallIndex();
+  return ((const LV *)(char const *)&Data)->Base.getCallIndex();
 }
 
 unsigned APValue::getLValueVersion() const {
   assert(isLValue() && "Invalid accessor");
-  return ((const LV *)(const char *)&Data)->Base.getVersion();
+  return ((const LV *)(char const *)&Data)->Base.getVersion();
 }
 
 bool APValue::isNullPointer() const {
   assert(isLValue() && "Invalid usage");
-  return ((const LV *)(const char *)&Data)->IsNullPtr;
+  return ((const LV *)(char const *)&Data)->IsNullPtr;
 }
 
-void APValue::setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
+void APValue::setLValue(LValueBase B, CharUnits const &O, NoLValuePath,
                         bool IsNullPtr) {
   assert(isLValue() && "Invalid accessor");
   LV &LVal = *((LV *)(char *)&Data);
@@ -943,7 +934,7 @@
 }
 
 MutableArrayRef<APValue::LValuePathEntry>
-APValue::setLValueUninit(LValueBase B, const CharUnits &O, unsigned Size,
+APValue::setLValueUninit(LValueBase B, CharUnits const &O, unsigned Size,
                          bool IsOnePastTheEnd, bool IsNullPtr) {
   assert(isLValue() && "Invalid accessor");
   LV &LVal = *((LV *)(char *)&Data);
@@ -955,7 +946,7 @@
   return {LVal.getPath(), Size};
 }
 
-void APValue::setLValue(LValueBase B, const CharUnits &O,
+void APValue::setLValue(LValueBase B, CharUnits const &O,
                         ArrayRef<LValuePathEntry> Path, bool IsOnePastTheEnd,
                         bool IsNullPtr) {
   MutableArrayRef<APValue::LValuePathEntry> InternalPath =
@@ -966,31 +957,31 @@
   }
 }
 
-void APValue::setUnion(const FieldDecl *Field, const APValue &Value) {
+void APValue::setUnion(FieldDecl const *Field, APValue const &Value) {
   assert(isUnion() && "Invalid accessor");
   ((UnionData *)(char *)&Data)->Field =
       Field ? Field->getCanonicalDecl() : nullptr;
   *((UnionData *)(char *)&Data)->Value = Value;
 }
 
-const ValueDecl *APValue::getMemberPointerDecl() const {
+ValueDecl const *APValue::getMemberPointerDecl() const {
   assert(isMemberPointer() && "Invalid accessor");
-  const MemberPointerData &MPD =
-      *((const MemberPointerData *)(const char *)&Data);
+  MemberPointerData const &MPD =
+      *((MemberPointerData const *)(char const *)&Data);
   return MPD.MemberAndIsDerivedMember.getPointer();
 }
 
 bool APValue::isMemberPointerToDerivedMember() const {
   assert(isMemberPointer() && "Invalid accessor");
-  const MemberPointerData &MPD =
-      *((const MemberPointerData *)(const char *)&Data);
+  MemberPointerData const &MPD =
+      *((MemberPointerData const *)(char const *)&Data);
   return MPD.MemberAndIsDerivedMember.getInt();
 }
 
-ArrayRef<const CXXRecordDecl*> APValue::getMemberPointerPath() const {
+ArrayRef<CXXRecordDecl const *> APValue::getMemberPointerPath() const {
   assert(isMemberPointer() && "Invalid accessor");
-  const MemberPointerData &MPD =
-      *((const MemberPointerData *)(const char *)&Data);
+  MemberPointerData const &MPD =
+      *((MemberPointerData const *)(char const *)&Data);
   return llvm::makeArrayRef(MPD.getPath(), MPD.PathLength);
 }
 
@@ -1008,11 +999,11 @@
 }
 
 MutableArrayRef<APValue::LValuePathEntry>
-setLValueUninit(APValue::LValueBase B, const CharUnits &O, unsigned Size,
+setLValueUninit(APValue::LValueBase B, CharUnits const &O, unsigned Size,
                 bool OnePastTheEnd, bool IsNullPtr);
 
-MutableArrayRef<const CXXRecordDecl *>
-APValue::setMemberPointerUninit(const ValueDecl *Member, bool IsDerivedMember,
+MutableArrayRef<CXXRecordDecl const *>
+APValue::setMemberPointerUninit(ValueDecl const *Member, bool IsDerivedMember,
                                 unsigned Size) {
   assert(isAbsent() && "Bad state change");
   MemberPointerData *MPD = new ((void *)(char *)&Data) MemberPointerData;
@@ -1024,15 +1015,15 @@
   return {MPD->getPath(), MPD->PathLength};
 }
 
-void APValue::MakeMemberPointer(const ValueDecl *Member, bool IsDerivedMember,
-                                ArrayRef<const CXXRecordDecl *> Path) {
-  MutableArrayRef<const CXXRecordDecl *> InternalPath =
+void APValue::MakeMemberPointer(ValueDecl const *Member, bool IsDerivedMember,
+                                ArrayRef<CXXRecordDecl const *> Path) {
+  MutableArrayRef<CXXRecordDecl const *> InternalPath =
       setMemberPointerUninit(Member, IsDerivedMember, Path.size());
   for (unsigned I = 0; I != Path.size(); ++I)
     InternalPath[I] = Path[I]->getCanonicalDecl();
 }
 
-LinkageInfo LinkageComputer::getLVForValue(const APValue &V,
+LinkageInfo LinkageComputer::getLVForValue(APValue const &V,
                                            LVComputationKind computation) {
   LinkageInfo LV = LinkageInfo::external();
 
@@ -1040,7 +1031,7 @@
     LV.merge(MergeLV);
     return LV.getLinkage() == InternalLinkage;
   };
-  auto Merge = [&](const APValue &V) {
+  auto Merge = [&](APValue const &V) {
     return MergeLV(getLVForValue(V, computation));
   };
 
@@ -1087,14 +1078,14 @@
   case APValue::LValue: {
     if (!V.getLValueBase()) {
       // Null or absolute address: this is external.
-    } else if (const auto *VD =
-                   V.getLValueBase().dyn_cast<const ValueDecl *>()) {
+    } else if (auto const *VD =
+                   V.getLValueBase().dyn_cast<ValueDecl const *>()) {
       if (VD && MergeLV(getLVForDecl(VD, computation)))
         break;
-    } else if (const auto TI = V.getLValueBase().dyn_cast<TypeInfoLValue>()) {
+    } else if (auto const TI = V.getLValueBase().dyn_cast<TypeInfoLValue>()) {
       if (MergeLV(getLVForType(*TI.getType(), computation)))
         break;
-    } else if (const Expr *E = V.getLValueBase().dyn_cast<const Expr *>()) {
+    } else if (Expr const *E = V.getLValueBase().dyn_cast<Expr const *>()) {
       // Almost all expression bases are internal. The exception is
       // lifetime-extended temporaries.
       // FIXME: These should be modeled as having the
@@ -1117,7 +1108,7 @@
   }
 
   case APValue::MemberPointer:
-    if (const NamedDecl *D = V.getMemberPointerDecl())
+    if (NamedDecl const *D = V.getMemberPointerDecl())
       MergeLV(getLVForDecl(D, computation));
     // Note that we could have a base-to-derived conversion here to a member of
     // a derived class with less linkage/visibility. That's covered by the
Index: clang/lib/AST/ASTConcept.cpp
===================================================================
--- clang/lib/AST/ASTConcept.cpp
+++ clang/lib/AST/ASTConcept.cpp
@@ -19,17 +19,17 @@
 #include "llvm/ADT/FoldingSet.h"
 using namespace clang;
 
-ASTConstraintSatisfaction::ASTConstraintSatisfaction(const ASTContext &C,
-    const ConstraintSatisfaction &Satisfaction):
-    NumRecords{Satisfaction.Details.size()},
-    IsSatisfied{Satisfaction.IsSatisfied} {
+ASTConstraintSatisfaction::ASTConstraintSatisfaction(
+    ASTContext const &C, ConstraintSatisfaction const &Satisfaction)
+    : NumRecords{Satisfaction.Details.size()}, IsSatisfied{
+                                                   Satisfaction.IsSatisfied} {
   for (unsigned I = 0; I < NumRecords; ++I) {
     auto &Detail = Satisfaction.Details[I];
     if (Detail.second.is<Expr *>())
       new (getTrailingObjects<UnsatisfiedConstraintRecord>() + I)
-         UnsatisfiedConstraintRecord{Detail.first,
-                                     UnsatisfiedConstraintRecord::second_type(
-                                         Detail.second.get<Expr *>())};
+          UnsatisfiedConstraintRecord{Detail.first,
+                                      UnsatisfiedConstraintRecord::second_type(
+                                          Detail.second.get<Expr *>())};
     else {
       auto &SubstitutionDiagnostic =
           *Detail.second.get<std::pair<SourceLocation, StringRef> *>();
@@ -38,28 +38,26 @@
       memcpy(Mem, SubstitutionDiagnostic.second.data(), MessageSize);
       auto *NewSubstDiag = new (C) std::pair<SourceLocation, StringRef>(
           SubstitutionDiagnostic.first, StringRef(Mem, MessageSize));
-      new (getTrailingObjects<UnsatisfiedConstraintRecord>() + I)
-         UnsatisfiedConstraintRecord{Detail.first,
-                                     UnsatisfiedConstraintRecord::second_type(
-                                         NewSubstDiag)};
+      new (getTrailingObjects<UnsatisfiedConstraintRecord>() +
+           I) UnsatisfiedConstraintRecord{
+          Detail.first, UnsatisfiedConstraintRecord::second_type(NewSubstDiag)};
     }
   }
 }
 
-
 ASTConstraintSatisfaction *
-ASTConstraintSatisfaction::Create(const ASTContext &C,
-                                  const ConstraintSatisfaction &Satisfaction) {
-  std::size_t size =
-      totalSizeToAlloc<UnsatisfiedConstraintRecord>(
-          Satisfaction.Details.size());
+ASTConstraintSatisfaction::Create(ASTContext const &C,
+                                  ConstraintSatisfaction const &Satisfaction) {
+  std::size_t size = totalSizeToAlloc<UnsatisfiedConstraintRecord>(
+      Satisfaction.Details.size());
   void *Mem = C.Allocate(size, alignof(ASTConstraintSatisfaction));
   return new (Mem) ASTConstraintSatisfaction(C, Satisfaction);
 }
 
-void ConstraintSatisfaction::Profile(
-    llvm::FoldingSetNodeID &ID, const ASTContext &C,
-    const NamedDecl *ConstraintOwner, ArrayRef<TemplateArgument> TemplateArgs) {
+void ConstraintSatisfaction::Profile(llvm::FoldingSetNodeID &ID,
+                                     ASTContext const &C,
+                                     NamedDecl const *ConstraintOwner,
+                                     ArrayRef<TemplateArgument> TemplateArgs) {
   ID.AddPointer(ConstraintOwner);
   ID.AddInteger(TemplateArgs.size());
   for (auto &Arg : TemplateArgs)
Index: clang/lib/AST/ASTConsumer.cpp
===================================================================
--- clang/lib/AST/ASTConsumer.cpp
+++ clang/lib/AST/ASTConsumer.cpp
@@ -15,9 +15,7 @@
 #include "clang/AST/DeclGroup.h"
 using namespace clang;
 
-bool ASTConsumer::HandleTopLevelDecl(DeclGroupRef D) {
-  return true;
-}
+bool ASTConsumer::HandleTopLevelDecl(DeclGroupRef D) { return true; }
 
 void ASTConsumer::HandleInterestingDecl(DeclGroupRef D) {
   HandleTopLevelDecl(D);
Index: clang/lib/AST/ASTContext.cpp
===================================================================
--- clang/lib/AST/ASTContext.cpp
+++ clang/lib/AST/ASTContext.cpp
@@ -113,7 +113,7 @@
 
 /// \returns location that is relevant when searching for Doc comments related
 /// to \p D.
-static SourceLocation getDeclLocForCommentSearch(const Decl *D,
+static SourceLocation getDeclLocForCommentSearch(Decl const *D,
                                                  SourceManager &SourceMgr) {
   assert(D);
 
@@ -122,34 +122,33 @@
     return {};
 
   // User can not attach documentation to implicit instantiations.
-  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
+  if (auto const *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
       return {};
   }
 
-  if (const auto *VD = dyn_cast<VarDecl>(D)) {
+  if (auto const *VD = dyn_cast<VarDecl>(D)) {
     if (VD->isStaticDataMember() &&
         VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
       return {};
   }
 
-  if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
+  if (auto const *CRD = dyn_cast<CXXRecordDecl>(D)) {
     if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
       return {};
   }
 
-  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
+  if (auto const *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
     TemplateSpecializationKind TSK = CTSD->getSpecializationKind();
-    if (TSK == TSK_ImplicitInstantiation ||
-        TSK == TSK_Undeclared)
+    if (TSK == TSK_ImplicitInstantiation || TSK == TSK_Undeclared)
       return {};
   }
 
-  if (const auto *ED = dyn_cast<EnumDecl>(D)) {
+  if (auto const *ED = dyn_cast<EnumDecl>(D)) {
     if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
       return {};
   }
-  if (const auto *TD = dyn_cast<TagDecl>(D)) {
+  if (auto const *TD = dyn_cast<TagDecl>(D)) {
     // When tag declaration (but not definition!) is part of the
     // decl-specifier-seq of some other declaration, it doesn't get comment
     if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
@@ -161,8 +160,7 @@
 
   // TODO: we could look up template parameter documentation in the template
   // documentation.
-  if (isa<TemplateTypeParmDecl>(D) ||
-      isa<NonTypeTemplateParmDecl>(D) ||
+  if (isa<TemplateTypeParmDecl>(D) || isa<NonTypeTemplateParmDecl>(D) ||
       isa<TemplateTemplateParmDecl>(D))
     return {};
 
@@ -173,8 +171,7 @@
   // For all other declarations multiple declarators are used quite frequently,
   // so we use the location of the identifier as the "declaration location".
   if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) ||
-      isa<ObjCPropertyDecl>(D) ||
-      isa<RedeclarableTemplateDecl>(D) ||
+      isa<ObjCPropertyDecl>(D) || isa<RedeclarableTemplateDecl>(D) ||
       isa<ClassTemplateSpecializationDecl>(D) ||
       // Allow association with Y across {} in `typedef struct X {} Y`.
       isa<TypedefDecl>(D))
@@ -189,7 +186,7 @@
       return D->getBeginLoc();
     }
 
-    if (const auto *TD = dyn_cast<TagDecl>(D)) {
+    if (auto const *TD = dyn_cast<TagDecl>(D)) {
       // If location of the tag decl is inside a macro, but the spelling of
       // the tag name comes from a macro argument, it looks like a special
       // macro like NS_ENUM is being used to define the tag decl.  In that
@@ -204,8 +201,8 @@
 }
 
 RawComment *ASTContext::getRawCommentForDeclNoCacheImpl(
-    const Decl *D, const SourceLocation RepresentativeLocForDecl,
-    const std::map<unsigned, RawComment *> &CommentsInTheFile) const {
+    Decl const *D, const SourceLocation RepresentativeLocForDecl,
+    std::map<unsigned, RawComment *> const &CommentsInTheFile) const {
   // If the declaration doesn't map directly to a location in a file, we
   // can't find the comment.
   if (RepresentativeLocForDecl.isInvalid() ||
@@ -259,13 +256,13 @@
     return nullptr;
 
   // Decompose the end of the comment.
-  const unsigned CommentEndOffset =
+  unsigned const CommentEndOffset =
       Comments.getCommentEndOffset(CommentBeforeDecl);
 
   // Get the corresponding buffer.
   bool Invalid = false;
-  const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,
-                                               &Invalid).data();
+  char const *Buffer =
+      SourceMgr.getBufferData(DeclLocDecomp.first, &Invalid).data();
   if (Invalid)
     return nullptr;
 
@@ -281,7 +278,7 @@
   return CommentBeforeDecl;
 }
 
-RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
+RawComment *ASTContext::getRawCommentForDeclNoCache(Decl const *D) const {
   const SourceLocation DeclLoc = getDeclLocForCommentSearch(D, SourceMgr);
 
   // If the declaration doesn't map directly to a location in a file, we
@@ -298,14 +295,14 @@
     return nullptr;
 
   const FileID File = SourceMgr.getDecomposedLoc(DeclLoc).first;
-  const auto CommentsInThisFile = Comments.getCommentsInFile(File);
+  auto const CommentsInThisFile = Comments.getCommentsInFile(File);
   if (!CommentsInThisFile || CommentsInThisFile->empty())
     return nullptr;
 
   return getRawCommentForDeclNoCacheImpl(D, DeclLoc, *CommentsInThisFile);
 }
 
-void ASTContext::addComment(const RawComment &RC) {
+void ASTContext::addComment(RawComment const &RC) {
   assert(LangOpts.RetainCommentsFromSystemHeaders ||
          !SourceMgr.isInSystemHeader(RC.getSourceRange().getBegin()));
   Comments.addComment(RC, LangOpts.CommentOpts, BumpAlloc);
@@ -314,10 +311,10 @@
 /// If we have a 'templated' declaration for a template, adjust 'D' to
 /// refer to the actual template.
 /// If we have an implicit instantiation, adjust 'D' to refer to template.
-static const Decl &adjustDeclToTemplate(const Decl &D) {
-  if (const auto *FD = dyn_cast<FunctionDecl>(&D)) {
+static Decl const &adjustDeclToTemplate(Decl const &D) {
+  if (auto const *FD = dyn_cast<FunctionDecl>(&D)) {
     // Is this function declaration part of a function template?
-    if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
+    if (FunctionTemplateDecl const *FTD = FD->getDescribedFunctionTemplate())
       return *FTD;
 
     // Nothing to do if function is not an implicit instantiation.
@@ -325,54 +322,54 @@
       return D;
 
     // Function is an implicit instantiation of a function template?
-    if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())
+    if (FunctionTemplateDecl const *FTD = FD->getPrimaryTemplate())
       return *FTD;
 
     // Function is instantiated from a member definition of a class template?
-    if (const FunctionDecl *MemberDecl =
+    if (FunctionDecl const *MemberDecl =
             FD->getInstantiatedFromMemberFunction())
       return *MemberDecl;
 
     return D;
   }
-  if (const auto *VD = dyn_cast<VarDecl>(&D)) {
+  if (auto const *VD = dyn_cast<VarDecl>(&D)) {
     // Static data member is instantiated from a member definition of a class
     // template?
     if (VD->isStaticDataMember())
-      if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember())
+      if (VarDecl const *MemberDecl = VD->getInstantiatedFromStaticDataMember())
         return *MemberDecl;
 
     return D;
   }
-  if (const auto *CRD = dyn_cast<CXXRecordDecl>(&D)) {
+  if (auto const *CRD = dyn_cast<CXXRecordDecl>(&D)) {
     // Is this class declaration part of a class template?
-    if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate())
+    if (ClassTemplateDecl const *CTD = CRD->getDescribedClassTemplate())
       return *CTD;
 
     // Class is an implicit instantiation of a class template or partial
     // specialization?
-    if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
+    if (auto const *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
       if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation)
         return D;
       llvm::PointerUnion<ClassTemplateDecl *,
                          ClassTemplatePartialSpecializationDecl *>
           PU = CTSD->getSpecializedTemplateOrPartial();
       return PU.is<ClassTemplateDecl *>()
-                 ? *static_cast<const Decl *>(PU.get<ClassTemplateDecl *>())
-                 : *static_cast<const Decl *>(
+                 ? *static_cast<Decl const *>(PU.get<ClassTemplateDecl *>())
+                 : *static_cast<Decl const *>(
                        PU.get<ClassTemplatePartialSpecializationDecl *>());
     }
 
     // Class is instantiated from a member definition of a class template?
-    if (const MemberSpecializationInfo *Info =
+    if (MemberSpecializationInfo const *Info =
             CRD->getMemberSpecializationInfo())
       return *Info->getInstantiatedFrom();
 
     return D;
   }
-  if (const auto *ED = dyn_cast<EnumDecl>(&D)) {
+  if (auto const *ED = dyn_cast<EnumDecl>(&D)) {
     // Enum is instantiated from a member definition of a class template?
-    if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum())
+    if (EnumDecl const *MemberDecl = ED->getInstantiatedFromMemberEnum())
       return *MemberDecl;
 
     return D;
@@ -381,9 +378,9 @@
   return D;
 }
 
-const RawComment *ASTContext::getRawCommentForAnyRedecl(
-                                                const Decl *D,
-                                                const Decl **OriginalDecl) const {
+RawComment const *
+ASTContext::getRawCommentForAnyRedecl(Decl const *D,
+                                      Decl const **OriginalDecl) const {
   if (!D) {
     if (OriginalDecl)
       OriginalDecl = nullptr;
@@ -403,7 +400,7 @@
   }
 
   // Any comment attached to any redeclaration of D?
-  const Decl *CanonicalD = D->getCanonicalDecl();
+  Decl const *CanonicalD = D->getCanonicalDecl();
   if (!CanonicalD)
     return nullptr;
 
@@ -421,14 +418,14 @@
 
   // Any redeclarations of D that we haven't checked for comments yet?
   // We can't use DenseMap::iterator directly since it'd get invalid.
-  auto LastCheckedRedecl = [this, CanonicalD]() -> const Decl * {
+  auto LastCheckedRedecl = [this, CanonicalD]() -> Decl const * {
     auto LookupRes = CommentlessRedeclChains.find(CanonicalD);
     if (LookupRes != CommentlessRedeclChains.end())
       return LookupRes->second;
     return nullptr;
   }();
 
-  for (const auto Redecl : D->redecls()) {
+  for (auto const Redecl : D->redecls()) {
     assert(Redecl);
     // Skip all redeclarations that have been checked previously.
     if (LastCheckedRedecl) {
@@ -437,7 +434,7 @@
       }
       continue;
     }
-    const RawComment *RedeclComment = getRawCommentForDeclNoCache(Redecl);
+    RawComment const *RedeclComment = getRawCommentForDeclNoCache(Redecl);
     if (RedeclComment) {
       cacheRawCommentForDecl(*Redecl, *RedeclComment);
       if (OriginalDecl)
@@ -452,34 +449,34 @@
   return nullptr;
 }
 
-void ASTContext::cacheRawCommentForDecl(const Decl &OriginalD,
-                                        const RawComment &Comment) const {
+void ASTContext::cacheRawCommentForDecl(Decl const &OriginalD,
+                                        RawComment const &Comment) const {
   assert(Comment.isDocumentation() || LangOpts.CommentOpts.ParseAllComments);
   DeclRawComments.try_emplace(&OriginalD, &Comment);
-  const Decl *const CanonicalDecl = OriginalD.getCanonicalDecl();
+  Decl const *const CanonicalDecl = OriginalD.getCanonicalDecl();
   RedeclChainComments.try_emplace(CanonicalDecl, &OriginalD);
   CommentlessRedeclChains.erase(CanonicalDecl);
 }
 
-static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod,
-                   SmallVectorImpl<const NamedDecl *> &Redeclared) {
-  const DeclContext *DC = ObjCMethod->getDeclContext();
-  if (const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {
-    const ObjCInterfaceDecl *ID = IMD->getClassInterface();
+static void
+addRedeclaredMethods(ObjCMethodDecl const *ObjCMethod,
+                     SmallVectorImpl<NamedDecl const *> &Redeclared) {
+  DeclContext const *DC = ObjCMethod->getDeclContext();
+  if (auto const *IMD = dyn_cast<ObjCImplDecl>(DC)) {
+    ObjCInterfaceDecl const *ID = IMD->getClassInterface();
     if (!ID)
       return;
     // Add redeclared method here.
-    for (const auto *Ext : ID->known_extensions()) {
-      if (ObjCMethodDecl *RedeclaredMethod =
-            Ext->getMethod(ObjCMethod->getSelector(),
-                                  ObjCMethod->isInstanceMethod()))
+    for (auto const *Ext : ID->known_extensions()) {
+      if (ObjCMethodDecl *RedeclaredMethod = Ext->getMethod(
+              ObjCMethod->getSelector(), ObjCMethod->isInstanceMethod()))
         Redeclared.push_back(RedeclaredMethod);
     }
   }
 }
 
 void ASTContext::attachCommentsToJustParsedDecls(ArrayRef<Decl *> Decls,
-                                                 const Preprocessor *PP) {
+                                                 Preprocessor const *PP) {
   if (Comments.empty() || Decls.empty())
     return;
 
@@ -510,7 +507,7 @@
   // the lookahead in the lexer: we've consumed the semicolon and looked
   // ahead through comments.
 
-  for (const Decl *D : Decls) {
+  for (Decl const *D : Decls) {
     assert(D);
     if (D->isInvalidDecl())
       continue;
@@ -535,7 +532,7 @@
 }
 
 comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC,
-                                                    const Decl *D) const {
+                                                    Decl const *D) const {
   auto *ThisDeclInfo = new (*this) comments::DeclInfo;
   ThisDeclInfo->CommentDecl = D;
   ThisDeclInfo->IsFilled = false;
@@ -544,25 +541,24 @@
   if (!ThisDeclInfo->TemplateParameters)
     ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;
   comments::FullComment *CFC =
-    new (*this) comments::FullComment(FC->getBlocks(),
-                                      ThisDeclInfo);
+      new (*this) comments::FullComment(FC->getBlocks(), ThisDeclInfo);
   return CFC;
 }
 
-comments::FullComment *ASTContext::getLocalCommentForDeclUncached(const Decl *D) const {
-  const RawComment *RC = getRawCommentForDeclNoCache(D);
+comments::FullComment *
+ASTContext::getLocalCommentForDeclUncached(Decl const *D) const {
+  RawComment const *RC = getRawCommentForDeclNoCache(D);
   return RC ? RC->parse(*this, nullptr, D) : nullptr;
 }
 
-comments::FullComment *ASTContext::getCommentForDecl(
-                                              const Decl *D,
-                                              const Preprocessor *PP) const {
+comments::FullComment *
+ASTContext::getCommentForDecl(Decl const *D, Preprocessor const *PP) const {
   if (!D || D->isInvalidDecl())
     return nullptr;
   D = &adjustDeclToTemplate(*D);
 
-  const Decl *Canonical = D->getCanonicalDecl();
-  llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
+  Decl const *Canonical = D->getCanonicalDecl();
+  llvm::DenseMap<Decl const *, comments::FullComment *>::iterator Pos =
       ParsedComments.find(Canonical);
 
   if (Pos != ParsedComments.end()) {
@@ -574,15 +570,15 @@
     return Pos->second;
   }
 
-  const Decl *OriginalDecl = nullptr;
+  Decl const *OriginalDecl = nullptr;
 
-  const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);
+  RawComment const *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);
   if (!RC) {
     if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
-      SmallVector<const NamedDecl*, 8> Overridden;
-      const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
+      SmallVector<NamedDecl const *, 8> Overridden;
+      auto const *OMD = dyn_cast<ObjCMethodDecl>(D);
       if (OMD && OMD->isPropertyAccessor())
-        if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
+        if (ObjCPropertyDecl const *PDecl = OMD->findPropertyDecl())
           if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))
             return cloneFullComment(FC, D);
       if (OMD)
@@ -591,55 +587,52 @@
       for (unsigned i = 0, e = Overridden.size(); i < e; i++)
         if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP))
           return cloneFullComment(FC, D);
-    }
-    else if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
+    } else if (auto const *TD = dyn_cast<TypedefNameDecl>(D)) {
       // Attach any tag type's documentation to its typedef if latter
       // does not have one of its own.
       QualType QT = TD->getUnderlyingType();
-      if (const auto *TT = QT->getAs<TagType>())
-        if (const Decl *TD = TT->getDecl())
+      if (auto const *TT = QT->getAs<TagType>())
+        if (Decl const *TD = TT->getDecl())
           if (comments::FullComment *FC = getCommentForDecl(TD, PP))
             return cloneFullComment(FC, D);
-    }
-    else if (const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
+    } else if (auto const *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
       while (IC->getSuperClass()) {
         IC = IC->getSuperClass();
         if (comments::FullComment *FC = getCommentForDecl(IC, PP))
           return cloneFullComment(FC, D);
       }
-    }
-    else if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {
-      if (const ObjCInterfaceDecl *IC = CD->getClassInterface())
+    } else if (auto const *CD = dyn_cast<ObjCCategoryDecl>(D)) {
+      if (ObjCInterfaceDecl const *IC = CD->getClassInterface())
         if (comments::FullComment *FC = getCommentForDecl(IC, PP))
           return cloneFullComment(FC, D);
-    }
-    else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
+    } else if (auto const *RD = dyn_cast<CXXRecordDecl>(D)) {
       if (!(RD = RD->getDefinition()))
         return nullptr;
       // Check non-virtual bases.
-      for (const auto &I : RD->bases()) {
+      for (auto const &I : RD->bases()) {
         if (I.isVirtual() || (I.getAccessSpecifier() != AS_public))
           continue;
         QualType Ty = I.getType();
         if (Ty.isNull())
           continue;
-        if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) {
-          if (!(NonVirtualBase= NonVirtualBase->getDefinition()))
+        if (CXXRecordDecl const *NonVirtualBase = Ty->getAsCXXRecordDecl()) {
+          if (!(NonVirtualBase = NonVirtualBase->getDefinition()))
             continue;
 
-          if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP))
+          if (comments::FullComment *FC =
+                  getCommentForDecl((NonVirtualBase), PP))
             return cloneFullComment(FC, D);
         }
       }
       // Check virtual bases.
-      for (const auto &I : RD->vbases()) {
+      for (auto const &I : RD->vbases()) {
         if (I.getAccessSpecifier() != AS_public)
           continue;
         QualType Ty = I.getType();
         if (Ty.isNull())
           continue;
-        if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) {
-          if (!(VirtualBase= VirtualBase->getDefinition()))
+        if (CXXRecordDecl const *VirtualBase = Ty->getAsCXXRecordDecl()) {
+          if (!(VirtualBase = VirtualBase->getDefinition()))
             continue;
           if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP))
             return cloneFullComment(FC, D);
@@ -661,10 +654,9 @@
   return FC;
 }
 
-void
-ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
-                                                   const ASTContext &C,
-                                               TemplateTemplateParmDecl *Parm) {
+void ASTContext::CanonicalTemplateTemplateParm::Profile(
+    llvm::FoldingSetNodeID &ID, ASTContext const &C,
+    TemplateTemplateParmDecl *Parm) {
   ID.AddInteger(Parm->getDepth());
   ID.AddInteger(Parm->getPosition());
   ID.AddBoolean(Parm->isParameterPack());
@@ -672,12 +664,12 @@
   TemplateParameterList *Params = Parm->getTemplateParameters();
   ID.AddInteger(Params->size());
   for (TemplateParameterList::const_iterator P = Params->begin(),
-                                          PEnd = Params->end();
+                                             PEnd = Params->end();
        P != PEnd; ++P) {
-    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
+    if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
       ID.AddInteger(0);
       ID.AddBoolean(TTP->isParameterPack());
-      const TypeConstraint *TC = TTP->getTypeConstraint();
+      TypeConstraint const *TC = TTP->getTypeConstraint();
       ID.AddBoolean(TC != nullptr);
       if (TC)
         TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,
@@ -690,7 +682,7 @@
       continue;
     }
 
-    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
+    if (auto const *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
       ID.AddInteger(1);
       ID.AddBoolean(NTTP->isParameterPack());
       ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
@@ -717,7 +709,7 @@
 }
 
 static Expr *
-canonicalizeImmediatelyDeclaredConstraint(const ASTContext &C, Expr *IDC,
+canonicalizeImmediatelyDeclaredConstraint(ASTContext const &C, Expr *IDC,
                                           QualType ConstrainedType) {
   // This is a bit ugly - we need to form a new immediately-declared
   // constraint that references the new parameter; this would ideally
@@ -727,7 +719,7 @@
   // We don't have semantic analysis here so we dig deep into the
   // ready-made constraint expr and change the thing manually.
   ConceptSpecializationExpr *CSE;
-  if (const auto *Fold = dyn_cast<CXXFoldExpr>(IDC))
+  if (auto const *Fold = dyn_cast<CXXFoldExpr>(IDC))
     CSE = cast<ConceptSpecializationExpr>(Fold->getLHS());
   else
     CSE = cast<ConceptSpecializationExpr>(IDC);
@@ -760,22 +752,21 @@
       CSE->isInstantiationDependent(), CSE->containsUnexpandedParameterPack());
 
   if (auto *OrigFold = dyn_cast<CXXFoldExpr>(IDC))
-    NewIDC = new (C) CXXFoldExpr(
-        OrigFold->getType(), /*Callee*/nullptr, SourceLocation(), NewIDC,
-        BinaryOperatorKind::BO_LAnd, SourceLocation(), /*RHS=*/nullptr,
-        SourceLocation(), /*NumExpansions=*/None);
+    NewIDC = new (C)
+        CXXFoldExpr(OrigFold->getType(), /*Callee*/ nullptr, SourceLocation(),
+                    NewIDC, BinaryOperatorKind::BO_LAnd, SourceLocation(),
+                    /*RHS=*/nullptr, SourceLocation(), /*NumExpansions=*/None);
   return NewIDC;
 }
 
-TemplateTemplateParmDecl *
-ASTContext::getCanonicalTemplateTemplateParmDecl(
-                                          TemplateTemplateParmDecl *TTP) const {
+TemplateTemplateParmDecl *ASTContext::getCanonicalTemplateTemplateParmDecl(
+    TemplateTemplateParmDecl *TTP) const {
   // Check if we already have a canonical template template parameter.
   llvm::FoldingSetNodeID ID;
   CanonicalTemplateTemplateParm::Profile(ID, *this, TTP);
   void *InsertPos = nullptr;
-  CanonicalTemplateTemplateParm *Canonical
-    = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
+  CanonicalTemplateTemplateParm *Canonical =
+      CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
   if (Canonical)
     return Canonical->getParam();
 
@@ -784,36 +775,36 @@
   SmallVector<NamedDecl *, 4> CanonParams;
   CanonParams.reserve(Params->size());
   for (TemplateParameterList::const_iterator P = Params->begin(),
-                                          PEnd = Params->end();
+                                             PEnd = Params->end();
        P != PEnd; ++P) {
-    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
-      TemplateTypeParmDecl *NewTTP = TemplateTypeParmDecl::Create(*this,
-          getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
+    if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
+      TemplateTypeParmDecl *NewTTP = TemplateTypeParmDecl::Create(
+          *this, getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
           TTP->getDepth(), TTP->getIndex(), nullptr, false,
           TTP->isParameterPack(), TTP->hasTypeConstraint(),
-          TTP->isExpandedParameterPack() ?
-          llvm::Optional<unsigned>(TTP->getNumExpansionParameters()) : None);
-      if (const auto *TC = TTP->getTypeConstraint()) {
+          TTP->isExpandedParameterPack()
+              ? llvm::Optional<unsigned>(TTP->getNumExpansionParameters())
+              : None);
+      if (auto const *TC = TTP->getTypeConstraint()) {
         QualType ParamAsArgument(NewTTP->getTypeForDecl(), 0);
         Expr *NewIDC = canonicalizeImmediatelyDeclaredConstraint(
-                *this, TC->getImmediatelyDeclaredConstraint(),
-                ParamAsArgument);
+            *this, TC->getImmediatelyDeclaredConstraint(), ParamAsArgument);
         TemplateArgumentListInfo CanonArgsAsWritten;
         if (auto *Args = TC->getTemplateArgsAsWritten())
-          for (const auto &ArgLoc : Args->arguments())
-            CanonArgsAsWritten.addArgument(
-                TemplateArgumentLoc(ArgLoc.getArgument(),
-                                    TemplateArgumentLocInfo()));
+          for (auto const &ArgLoc : Args->arguments())
+            CanonArgsAsWritten.addArgument(TemplateArgumentLoc(
+                ArgLoc.getArgument(), TemplateArgumentLocInfo()));
         NewTTP->setTypeConstraint(
             NestedNameSpecifierLoc(),
             DeclarationNameInfo(TC->getNamedConcept()->getDeclName(),
-                                SourceLocation()), /*FoundDecl=*/nullptr,
+                                SourceLocation()),
+            /*FoundDecl=*/nullptr,
             // Actually canonicalizing a TemplateArgumentLoc is difficult so we
             // simply omit the ArgsAsWritten
             TC->getNamedConcept(), /*ArgsAsWritten=*/nullptr, NewIDC);
       }
       CanonParams.push_back(NewTTP);
-    } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
+    } else if (auto const *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
       QualType T = getCanonicalType(NTTP->getType());
       TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
       NonTypeTemplateParmDecl *Param;
@@ -823,27 +814,18 @@
         for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
           ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I)));
           ExpandedTInfos.push_back(
-                                getTrivialTypeSourceInfo(ExpandedTypes.back()));
+              getTrivialTypeSourceInfo(ExpandedTypes.back()));
         }
 
-        Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
-                                                SourceLocation(),
-                                                SourceLocation(),
-                                                NTTP->getDepth(),
-                                                NTTP->getPosition(), nullptr,
-                                                T,
-                                                TInfo,
-                                                ExpandedTypes,
-                                                ExpandedTInfos);
+        Param = NonTypeTemplateParmDecl::Create(
+            *this, getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
+            NTTP->getDepth(), NTTP->getPosition(), nullptr, T, TInfo,
+            ExpandedTypes, ExpandedTInfos);
       } else {
-        Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
-                                                SourceLocation(),
-                                                SourceLocation(),
-                                                NTTP->getDepth(),
-                                                NTTP->getPosition(), nullptr,
-                                                T,
-                                                NTTP->isParameterPack(),
-                                                TInfo);
+        Param = NonTypeTemplateParmDecl::Create(
+            *this, getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
+            NTTP->getDepth(), NTTP->getPosition(), nullptr, T,
+            NTTP->isParameterPack(), TInfo);
       }
       if (AutoType *AT = T->getContainedAutoType()) {
         if (AT->isConstrained()) {
@@ -856,24 +838,19 @@
 
     } else
       CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
-                                           cast<TemplateTemplateParmDecl>(*P)));
+          cast<TemplateTemplateParmDecl>(*P)));
   }
 
   Expr *CanonRequiresClause = nullptr;
   if (Expr *RequiresClause = TTP->getTemplateParameters()->getRequiresClause())
     CanonRequiresClause = RequiresClause;
 
-  TemplateTemplateParmDecl *CanonTTP
-    = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
-                                       SourceLocation(), TTP->getDepth(),
-                                       TTP->getPosition(),
-                                       TTP->isParameterPack(),
-                                       nullptr,
-                         TemplateParameterList::Create(*this, SourceLocation(),
-                                                       SourceLocation(),
-                                                       CanonParams,
-                                                       SourceLocation(),
-                                                       CanonRequiresClause));
+  TemplateTemplateParmDecl *CanonTTP = TemplateTemplateParmDecl::Create(
+      *this, getTranslationUnitDecl(), SourceLocation(), TTP->getDepth(),
+      TTP->getPosition(), TTP->isParameterPack(), nullptr,
+      TemplateParameterList::Create(*this, SourceLocation(), SourceLocation(),
+                                    CanonParams, SourceLocation(),
+                                    CanonRequiresClause));
 
   // Get the new insert position for the node we care about.
   Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
@@ -891,8 +868,9 @@
   return getLangOpts().CXXABI.getValueOr(Kind);
 }
 
-CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
-  if (!LangOpts.CPlusPlus) return nullptr;
+CXXABI *ASTContext::createCXXABI(TargetInfo const &T) {
+  if (!LangOpts.CPlusPlus)
+    return nullptr;
 
   switch (getCXXABIKind()) {
   case TargetCXXABI::AppleARM64:
@@ -925,12 +903,12 @@
   return *ParentMapCtx.get();
 }
 
-static const LangASMap *getAddressSpaceMap(const TargetInfo &T,
-                                           const LangOptions &LOpts) {
+static LangASMap const *getAddressSpaceMap(TargetInfo const &T,
+                                           LangOptions const &LOpts) {
   if (LOpts.FakeAddressSpaceMap) {
     // The fake address space map must have a distinct entry for each
     // language-specific address space.
-    static const unsigned FakeAddrSpaceMap[] = {
+    static unsigned const FakeAddrSpaceMap[] = {
         0,  // Default
         1,  // opencl_global
         3,  // opencl_local
@@ -957,8 +935,8 @@
   }
 }
 
-static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI,
-                                          const LangOptions &LangOpts) {
+static bool isAddrSpaceMapManglingEnabled(TargetInfo const &TI,
+                                          LangOptions const &LangOpts) {
   switch (LangOpts.getAddressSpaceMapMangling()) {
   case LangOptions::ASMM_Target:
     return TI.useAddressSpaceMapMangling();
@@ -1001,30 +979,34 @@
 
   // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed
   // because they can contain DenseMaps.
-  for (llvm::DenseMap<const ObjCContainerDecl*,
-       const ASTRecordLayout*>::iterator
-       I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
+  for (llvm::DenseMap<ObjCContainerDecl const *,
+                      ASTRecordLayout const *>::iterator
+           I = ObjCLayouts.begin(),
+           E = ObjCLayouts.end();
+       I != E;)
     // Increment in loop to prevent using deallocated memory.
     if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
       R->Destroy(*this);
 
-  for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
-       I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
+  for (llvm::DenseMap<RecordDecl const *, ASTRecordLayout const *>::iterator
+           I = ASTRecordLayouts.begin(),
+           E = ASTRecordLayouts.end();
+       I != E;) {
     // Increment in loop to prevent using deallocated memory.
     if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
       R->Destroy(*this);
   }
 
-  for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
-                                                    AEnd = DeclAttrs.end();
+  for (llvm::DenseMap<Decl const *, AttrVec *>::iterator A = DeclAttrs.begin(),
+                                                         AEnd = DeclAttrs.end();
        A != AEnd; ++A)
     A->second->~AttrVec();
 
-  for (const auto &Value : ModuleInitializers)
+  for (auto const &Value : ModuleInitializers)
     Value.second->~PerModuleInitializers();
 }
 
-void ASTContext::setTraversalScope(const std::vector<Decl *> &TopLevelDecls) {
+void ASTContext::setTraversalScope(std::vector<Decl *> const &TopLevelDecls) {
   TraversalScope = TopLevelDecls;
   getParentMapContext().clear();
 }
@@ -1033,8 +1015,8 @@
   Deallocations.push_back({Callback, Data});
 }
 
-void
-ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) {
+void ASTContext::setExternalSource(
+    IntrusiveRefCntPtr<ExternalASTSource> Source) {
   ExternalSource = std::move(Source);
 }
 
@@ -1046,7 +1028,7 @@
 #define TYPE(Name, Parent) 0,
 #define ABSTRACT_TYPE(Name, Parent)
 #include "clang/AST/TypeNodes.inc"
-    0 // Extra
+      0 // Extra
   };
 
   for (unsigned i = 0, e = Types.size(); i != e; ++i) {
@@ -1056,13 +1038,12 @@
 
   unsigned Idx = 0;
   unsigned TotalBytes = 0;
-#define TYPE(Name, Parent)                                              \
-  if (counts[Idx])                                                      \
-    llvm::errs() << "    " << counts[Idx] << " " << #Name               \
-                 << " types, " << sizeof(Name##Type) << " each "        \
-                 << "(" << counts[Idx] * sizeof(Name##Type)             \
-                 << " bytes)\n";                                        \
-  TotalBytes += counts[Idx] * sizeof(Name##Type);                       \
+#define TYPE(Name, Parent)                                                     \
+  if (counts[Idx])                                                             \
+    llvm::errs() << "    " << counts[Idx] << " " << #Name << " types, "        \
+                 << sizeof(Name##Type) << " each "                             \
+                 << "(" << counts[Idx] * sizeof(Name##Type) << " bytes)\n";    \
+  TotalBytes += counts[Idx] * sizeof(Name##Type);                              \
   ++Idx;
 #define ABSTRACT_TYPE(Name, Parent)
 #include "clang/AST/TypeNodes.inc"
@@ -1088,8 +1069,7 @@
                  << NumImplicitMoveAssignmentOperators
                  << " implicit move assignment operators created\n";
   llvm::errs() << NumImplicitDestructorsDeclared << "/"
-               << NumImplicitDestructors
-               << " implicit destructors created\n";
+               << NumImplicitDestructors << " implicit destructors created\n";
 
   if (ExternalSource) {
     llvm::errs() << "\n";
@@ -1114,15 +1094,16 @@
     return;
 
   auto &Merged = It->second;
-  llvm::DenseSet<Module*> Found;
+  llvm::DenseSet<Module *> Found;
   for (Module *&M : Merged)
     if (!Found.insert(M).second)
       M = nullptr;
-  Merged.erase(std::remove(Merged.begin(), Merged.end(), nullptr), Merged.end());
+  Merged.erase(std::remove(Merged.begin(), Merged.end(), nullptr),
+               Merged.end());
 }
 
 ArrayRef<Module *>
-ASTContext::getModulesWithMergedDefinition(const NamedDecl *Def) {
+ASTContext::getModulesWithMergedDefinition(NamedDecl const *Def) {
   auto MergedIt =
       MergedDefModules.find(cast<NamedDecl>(Def->getCanonicalDecl()));
   if (MergedIt == MergedDefModules.end())
@@ -1150,7 +1131,7 @@
 void ASTContext::addModuleInitializer(Module *M, Decl *D) {
   // One special case: if we add a module initializer that imports another
   // module, and that module's only initializer is an ImportDecl, simplify.
-  if (const auto *ID = dyn_cast<ImportDecl>(D)) {
+  if (auto const *ID = dyn_cast<ImportDecl>(D)) {
     auto It = ModuleInitializers.find(ID->getImportedModule());
 
     // Maybe the ImportDecl does nothing at all. (Common case.)
@@ -1177,8 +1158,8 @@
   auto *&Inits = ModuleInitializers[M];
   if (!Inits)
     Inits = new (*this) PerModuleInitializers;
-  Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
-                                 IDs.begin(), IDs.end());
+  Inits->LazyInitializers.insert(Inits->LazyInitializers.end(), IDs.begin(),
+                                 IDs.end());
 }
 
 ArrayRef<Decl *> ASTContext::getModuleInitializers(Module *M) {
@@ -1193,14 +1174,15 @@
 
 ExternCContextDecl *ASTContext::getExternCContextDecl() const {
   if (!ExternCContext)
-    ExternCContext = ExternCContextDecl::Create(*this, getTranslationUnitDecl());
+    ExternCContext =
+        ExternCContextDecl::Create(*this, getTranslationUnitDecl());
 
   return ExternCContext;
 }
 
 BuiltinTemplateDecl *
 ASTContext::buildBuiltinTemplateDecl(BuiltinTemplateKind BTK,
-                                     const IdentifierInfo *II) const {
+                                     IdentifierInfo const *II) const {
   auto *BuiltinTemplate =
       BuiltinTemplateDecl::Create(*this, getTranslationUnitDecl(), II, BTK);
   BuiltinTemplate->setImplicit();
@@ -1209,16 +1191,14 @@
   return BuiltinTemplate;
 }
 
-BuiltinTemplateDecl *
-ASTContext::getMakeIntegerSeqDecl() const {
+BuiltinTemplateDecl *ASTContext::getMakeIntegerSeqDecl() const {
   if (!MakeIntegerSeqDecl)
     MakeIntegerSeqDecl = buildBuiltinTemplateDecl(BTK__make_integer_seq,
                                                   getMakeIntegerSeqName());
   return MakeIntegerSeqDecl;
 }
 
-BuiltinTemplateDecl *
-ASTContext::getTypePackElementDecl() const {
+BuiltinTemplateDecl *ASTContext::getTypePackElementDecl() const {
   if (!TypePackElementDecl)
     TypePackElementDecl = buildBuiltinTemplateDecl(BTK__type_pack_element,
                                                    getTypePackElementName());
@@ -1269,8 +1249,8 @@
   Types.push_back(Ty);
 }
 
-void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
-                                  const TargetInfo *AuxTarget) {
+void ASTContext::InitBuiltinTypes(TargetInfo const &Target,
+                                  TargetInfo const *AuxTarget) {
   assert((!this->Target || this->Target == &Target) &&
          "Incorrect target reinitialization");
   assert(VoidTy.isNull() && "Context reinitialized?");
@@ -1283,78 +1263,78 @@
   AddrSpaceMapMangling = isAddrSpaceMapManglingEnabled(Target, LangOpts);
 
   // C99 6.2.5p19.
-  InitBuiltinType(VoidTy,              BuiltinType::Void);
+  InitBuiltinType(VoidTy, BuiltinType::Void);
 
   // C99 6.2.5p2.
-  InitBuiltinType(BoolTy,              BuiltinType::Bool);
+  InitBuiltinType(BoolTy, BuiltinType::Bool);
   // C99 6.2.5p3.
   if (LangOpts.CharIsSigned)
-    InitBuiltinType(CharTy,            BuiltinType::Char_S);
+    InitBuiltinType(CharTy, BuiltinType::Char_S);
   else
-    InitBuiltinType(CharTy,            BuiltinType::Char_U);
+    InitBuiltinType(CharTy, BuiltinType::Char_U);
   // C99 6.2.5p4.
-  InitBuiltinType(SignedCharTy,        BuiltinType::SChar);
-  InitBuiltinType(ShortTy,             BuiltinType::Short);
-  InitBuiltinType(IntTy,               BuiltinType::Int);
-  InitBuiltinType(LongTy,              BuiltinType::Long);
-  InitBuiltinType(LongLongTy,          BuiltinType::LongLong);
+  InitBuiltinType(SignedCharTy, BuiltinType::SChar);
+  InitBuiltinType(ShortTy, BuiltinType::Short);
+  InitBuiltinType(IntTy, BuiltinType::Int);
+  InitBuiltinType(LongTy, BuiltinType::Long);
+  InitBuiltinType(LongLongTy, BuiltinType::LongLong);
 
   // C99 6.2.5p6.
-  InitBuiltinType(UnsignedCharTy,      BuiltinType::UChar);
-  InitBuiltinType(UnsignedShortTy,     BuiltinType::UShort);
-  InitBuiltinType(UnsignedIntTy,       BuiltinType::UInt);
-  InitBuiltinType(UnsignedLongTy,      BuiltinType::ULong);
-  InitBuiltinType(UnsignedLongLongTy,  BuiltinType::ULongLong);
+  InitBuiltinType(UnsignedCharTy, BuiltinType::UChar);
+  InitBuiltinType(UnsignedShortTy, BuiltinType::UShort);
+  InitBuiltinType(UnsignedIntTy, BuiltinType::UInt);
+  InitBuiltinType(UnsignedLongTy, BuiltinType::ULong);
+  InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong);
 
   // C99 6.2.5p10.
-  InitBuiltinType(FloatTy,             BuiltinType::Float);
-  InitBuiltinType(DoubleTy,            BuiltinType::Double);
-  InitBuiltinType(LongDoubleTy,        BuiltinType::LongDouble);
+  InitBuiltinType(FloatTy, BuiltinType::Float);
+  InitBuiltinType(DoubleTy, BuiltinType::Double);
+  InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble);
 
   // GNU extension, __float128 for IEEE quadruple precision
-  InitBuiltinType(Float128Ty,          BuiltinType::Float128);
+  InitBuiltinType(Float128Ty, BuiltinType::Float128);
 
   // __ibm128 for IBM extended precision
   InitBuiltinType(Ibm128Ty, BuiltinType::Ibm128);
 
   // C11 extension ISO/IEC TS 18661-3
-  InitBuiltinType(Float16Ty,           BuiltinType::Float16);
+  InitBuiltinType(Float16Ty, BuiltinType::Float16);
 
   // ISO/IEC JTC1 SC22 WG14 N1169 Extension
-  InitBuiltinType(ShortAccumTy,            BuiltinType::ShortAccum);
-  InitBuiltinType(AccumTy,                 BuiltinType::Accum);
-  InitBuiltinType(LongAccumTy,             BuiltinType::LongAccum);
-  InitBuiltinType(UnsignedShortAccumTy,    BuiltinType::UShortAccum);
-  InitBuiltinType(UnsignedAccumTy,         BuiltinType::UAccum);
-  InitBuiltinType(UnsignedLongAccumTy,     BuiltinType::ULongAccum);
-  InitBuiltinType(ShortFractTy,            BuiltinType::ShortFract);
-  InitBuiltinType(FractTy,                 BuiltinType::Fract);
-  InitBuiltinType(LongFractTy,             BuiltinType::LongFract);
-  InitBuiltinType(UnsignedShortFractTy,    BuiltinType::UShortFract);
-  InitBuiltinType(UnsignedFractTy,         BuiltinType::UFract);
-  InitBuiltinType(UnsignedLongFractTy,     BuiltinType::ULongFract);
-  InitBuiltinType(SatShortAccumTy,         BuiltinType::SatShortAccum);
-  InitBuiltinType(SatAccumTy,              BuiltinType::SatAccum);
-  InitBuiltinType(SatLongAccumTy,          BuiltinType::SatLongAccum);
+  InitBuiltinType(ShortAccumTy, BuiltinType::ShortAccum);
+  InitBuiltinType(AccumTy, BuiltinType::Accum);
+  InitBuiltinType(LongAccumTy, BuiltinType::LongAccum);
+  InitBuiltinType(UnsignedShortAccumTy, BuiltinType::UShortAccum);
+  InitBuiltinType(UnsignedAccumTy, BuiltinType::UAccum);
+  InitBuiltinType(UnsignedLongAccumTy, BuiltinType::ULongAccum);
+  InitBuiltinType(ShortFractTy, BuiltinType::ShortFract);
+  InitBuiltinType(FractTy, BuiltinType::Fract);
+  InitBuiltinType(LongFractTy, BuiltinType::LongFract);
+  InitBuiltinType(UnsignedShortFractTy, BuiltinType::UShortFract);
+  InitBuiltinType(UnsignedFractTy, BuiltinType::UFract);
+  InitBuiltinType(UnsignedLongFractTy, BuiltinType::ULongFract);
+  InitBuiltinType(SatShortAccumTy, BuiltinType::SatShortAccum);
+  InitBuiltinType(SatAccumTy, BuiltinType::SatAccum);
+  InitBuiltinType(SatLongAccumTy, BuiltinType::SatLongAccum);
   InitBuiltinType(SatUnsignedShortAccumTy, BuiltinType::SatUShortAccum);
-  InitBuiltinType(SatUnsignedAccumTy,      BuiltinType::SatUAccum);
-  InitBuiltinType(SatUnsignedLongAccumTy,  BuiltinType::SatULongAccum);
-  InitBuiltinType(SatShortFractTy,         BuiltinType::SatShortFract);
-  InitBuiltinType(SatFractTy,              BuiltinType::SatFract);
-  InitBuiltinType(SatLongFractTy,          BuiltinType::SatLongFract);
+  InitBuiltinType(SatUnsignedAccumTy, BuiltinType::SatUAccum);
+  InitBuiltinType(SatUnsignedLongAccumTy, BuiltinType::SatULongAccum);
+  InitBuiltinType(SatShortFractTy, BuiltinType::SatShortFract);
+  InitBuiltinType(SatFractTy, BuiltinType::SatFract);
+  InitBuiltinType(SatLongFractTy, BuiltinType::SatLongFract);
   InitBuiltinType(SatUnsignedShortFractTy, BuiltinType::SatUShortFract);
-  InitBuiltinType(SatUnsignedFractTy,      BuiltinType::SatUFract);
-  InitBuiltinType(SatUnsignedLongFractTy,  BuiltinType::SatULongFract);
+  InitBuiltinType(SatUnsignedFractTy, BuiltinType::SatUFract);
+  InitBuiltinType(SatUnsignedLongFractTy, BuiltinType::SatULongFract);
 
   // GNU extension, 128-bit integers.
-  InitBuiltinType(Int128Ty,            BuiltinType::Int128);
-  InitBuiltinType(UnsignedInt128Ty,    BuiltinType::UInt128);
+  InitBuiltinType(Int128Ty, BuiltinType::Int128);
+  InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128);
 
   // C++ 3.9.1p5
   if (TargetInfo::isTypeSigned(Target.getWCharType()))
-    InitBuiltinType(WCharTy,           BuiltinType::WChar_S);
-  else  // -fshort-wchar makes wchar_t be unsigned.
-    InitBuiltinType(WCharTy,           BuiltinType::WChar_U);
+    InitBuiltinType(WCharTy, BuiltinType::WChar_S);
+  else // -fshort-wchar makes wchar_t be unsigned.
+    InitBuiltinType(WCharTy, BuiltinType::WChar_U);
   if (LangOpts.CPlusPlus && LangOpts.WChar)
     WideCharTy = WCharTy;
   else {
@@ -1365,15 +1345,15 @@
   WIntTy = getFromTargetType(Target.getWIntType());
 
   // C++20 (proposed)
-  InitBuiltinType(Char8Ty,              BuiltinType::Char8);
+  InitBuiltinType(Char8Ty, BuiltinType::Char8);
 
   if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
-    InitBuiltinType(Char16Ty,           BuiltinType::Char16);
+    InitBuiltinType(Char16Ty, BuiltinType::Char16);
   else // C99
     Char16Ty = getFromTargetType(Target.getChar16Type());
 
   if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
-    InitBuiltinType(Char32Ty,           BuiltinType::Char32);
+    InitBuiltinType(Char32Ty, BuiltinType::Char32);
   else // C99
     Char32Ty = getFromTargetType(Target.getChar32Type());
 
@@ -1382,25 +1362,25 @@
   // DependentTy and users should never see it; however, it is here to
   // help diagnose failures to properly check for type-dependent
   // expressions.
-  InitBuiltinType(DependentTy,         BuiltinType::Dependent);
+  InitBuiltinType(DependentTy, BuiltinType::Dependent);
 
   // Placeholder type for functions.
-  InitBuiltinType(OverloadTy,          BuiltinType::Overload);
+  InitBuiltinType(OverloadTy, BuiltinType::Overload);
 
   // Placeholder type for bound members.
-  InitBuiltinType(BoundMemberTy,       BuiltinType::BoundMember);
+  InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember);
 
   // Placeholder type for pseudo-objects.
-  InitBuiltinType(PseudoObjectTy,      BuiltinType::PseudoObject);
+  InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject);
 
   // "any" type; useful for debugger-like clients.
-  InitBuiltinType(UnknownAnyTy,        BuiltinType::UnknownAny);
+  InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny);
 
   // Placeholder type for unbridged ARC casts.
-  InitBuiltinType(ARCUnbridgedCastTy,  BuiltinType::ARCUnbridgedCast);
+  InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast);
 
   // Placeholder type for builtin functions.
-  InitBuiltinType(BuiltinFnTy,  BuiltinType::BuiltinFn);
+  InitBuiltinType(BuiltinFnTy, BuiltinType::BuiltinFn);
 
   // Placeholder type for OMP array sections.
   if (LangOpts.OpenMP) {
@@ -1412,10 +1392,10 @@
     InitBuiltinType(IncompleteMatrixIdxTy, BuiltinType::IncompleteMatrixIdx);
 
   // C99 6.2.5p11.
-  FloatComplexTy      = getComplexType(FloatTy);
-  DoubleComplexTy     = getComplexType(DoubleTy);
+  FloatComplexTy = getComplexType(FloatTy);
+  DoubleComplexTy = getComplexType(DoubleTy);
   LongDoubleComplexTy = getComplexType(LongDoubleTy);
-  Float128ComplexTy   = getComplexType(Float128Ty);
+  Float128ComplexTy = getComplexType(Float128Ty);
 
   // Builtin types for 'id', 'Class', and 'SEL'.
   InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
@@ -1423,8 +1403,8 @@
   InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);
 
   if (LangOpts.OpenCL) {
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-    InitBuiltinType(SingletonId, BuiltinType::Id);
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
+  InitBuiltinType(SingletonId, BuiltinType::Id);
 #include "clang/Basic/OpenCLImageTypes.def"
 
     InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler);
@@ -1433,26 +1413,26 @@
     InitBuiltinType(OCLQueueTy, BuiltinType::OCLQueue);
     InitBuiltinType(OCLReserveIDTy, BuiltinType::OCLReserveID);
 
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-    InitBuiltinType(Id##Ty, BuiltinType::Id);
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext)                                      \
+  InitBuiltinType(Id##Ty, BuiltinType::Id);
 #include "clang/Basic/OpenCLExtensionTypes.def"
   }
 
   if (Target.hasAArch64SVETypes()) {
-#define SVE_TYPE(Name, Id, SingletonId) \
-    InitBuiltinType(SingletonId, BuiltinType::Id);
+#define SVE_TYPE(Name, Id, SingletonId)                                        \
+  InitBuiltinType(SingletonId, BuiltinType::Id);
 #include "clang/Basic/AArch64SVEACLETypes.def"
   }
 
   if (Target.getTriple().isPPC64() &&
       Target.hasFeature("paired-vector-memops")) {
     if (Target.hasFeature("mma")) {
-#define PPC_VECTOR_MMA_TYPE(Name, Id, Size) \
-      InitBuiltinType(Id##Ty, BuiltinType::Id);
+#define PPC_VECTOR_MMA_TYPE(Name, Id, Size)                                    \
+  InitBuiltinType(Id##Ty, BuiltinType::Id);
 #include "clang/Basic/PPCTypes.def"
     }
-#define PPC_VECTOR_VSX_TYPE(Name, Id, Size) \
-    InitBuiltinType(Id##Ty, BuiltinType::Id);
+#define PPC_VECTOR_VSX_TYPE(Name, Id, Size)                                    \
+  InitBuiltinType(Id##Ty, BuiltinType::Id);
 #include "clang/Basic/PPCTypes.def"
   }
 
@@ -1463,8 +1443,8 @@
   }
 
   // Builtin type for __objc_yes and __objc_no
-  ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ?
-                       SignedCharTy : BoolTy);
+  ObjCBuiltinBoolTy =
+      (Target.useSignedCharForObjCBool() ? SignedCharTy : BoolTy);
 
   ObjCConstantStringType = QualType();
 
@@ -1474,14 +1454,14 @@
   if (LangOpts.OpenCLGenericAddressSpace) {
     auto Q = VoidTy.getQualifiers();
     Q.setAddressSpace(LangAS::opencl_generic);
-    VoidPtrTy = getPointerType(getCanonicalType(
-        getQualifiedType(VoidTy.getUnqualifiedType(), Q)));
+    VoidPtrTy = getPointerType(
+        getCanonicalType(getQualifiedType(VoidTy.getUnqualifiedType(), Q)));
   } else {
     VoidPtrTy = getPointerType(VoidTy);
   }
 
   // nullptr type (C++0x 2.14.7)
-  InitBuiltinType(NullPtrTy,           BuiltinType::NullPtr);
+  InitBuiltinType(NullPtrTy, BuiltinType::NullPtr);
 
   // half type (OpenCL 6.1.1.1) / ARM NEON __fp16
   InitBuiltinType(HalfTy, BuiltinType::Half);
@@ -1502,7 +1482,7 @@
   return SourceMgr.getDiagnostics();
 }
 
-AttrVec& ASTContext::getDeclAttrs(const Decl *D) {
+AttrVec &ASTContext::getDeclAttrs(Decl const *D) {
   AttrVec *&Result = DeclAttrs[D];
   if (!Result) {
     void *Mem = Allocate(sizeof(AttrVec));
@@ -1513,8 +1493,8 @@
 }
 
 /// Erase the attributes corresponding to the given declaration.
-void ASTContext::eraseDeclAttrs(const Decl *D) {
-  llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
+void ASTContext::eraseDeclAttrs(Decl const *D) {
+  llvm::DenseMap<Decl const *, AttrVec *>::iterator Pos = DeclAttrs.find(D);
   if (Pos != DeclAttrs.end()) {
     Pos->second->~AttrVec();
     DeclAttrs.erase(Pos);
@@ -1523,15 +1503,15 @@
 
 // FIXME: Remove ?
 MemberSpecializationInfo *
-ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) {
+ASTContext::getInstantiatedFromStaticDataMember(VarDecl const *Var) {
   assert(Var->isStaticDataMember() && "Not a static data member");
   return getTemplateOrSpecializationInfo(Var)
       .dyn_cast<MemberSpecializationInfo *>();
 }
 
 ASTContext::TemplateOrSpecializationInfo
-ASTContext::getTemplateOrSpecializationInfo(const VarDecl *Var) {
-  llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
+ASTContext::getTemplateOrSpecializationInfo(VarDecl const *Var) {
+  llvm::DenseMap<VarDecl const *, TemplateOrSpecializationInfo>::iterator Pos =
       TemplateOrInstantiation.find(Var);
   if (Pos == TemplateOrInstantiation.end())
     return {};
@@ -1539,26 +1519,23 @@
   return Pos->second;
 }
 
-void
-ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
-                                                TemplateSpecializationKind TSK,
-                                          SourceLocation PointOfInstantiation) {
+void ASTContext::setInstantiatedFromStaticDataMember(
+    VarDecl *Inst, VarDecl *Tmpl, TemplateSpecializationKind TSK,
+    SourceLocation PointOfInstantiation) {
   assert(Inst->isStaticDataMember() && "Not a static data member");
   assert(Tmpl->isStaticDataMember() && "Not a static data member");
   setTemplateOrSpecializationInfo(Inst, new (*this) MemberSpecializationInfo(
                                             Tmpl, TSK, PointOfInstantiation));
 }
 
-void
-ASTContext::setTemplateOrSpecializationInfo(VarDecl *Inst,
-                                            TemplateOrSpecializationInfo TSI) {
+void ASTContext::setTemplateOrSpecializationInfo(
+    VarDecl *Inst, TemplateOrSpecializationInfo TSI) {
   assert(!TemplateOrInstantiation[Inst] &&
          "Already noted what the variable was instantiated from");
   TemplateOrInstantiation[Inst] = TSI;
 }
 
-NamedDecl *
-ASTContext::getInstantiatedFromUsingDecl(NamedDecl *UUD) {
+NamedDecl *ASTContext::getInstantiatedFromUsingDecl(NamedDecl *UUD) {
   auto Pos = InstantiatedFromUsingDecl.find(UUD);
   if (Pos == InstantiatedFromUsingDecl.end())
     return nullptr;
@@ -1566,14 +1543,12 @@
   return Pos->second;
 }
 
-void
-ASTContext::setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern) {
-  assert((isa<UsingDecl>(Pattern) ||
-          isa<UnresolvedUsingValueDecl>(Pattern) ||
+void ASTContext::setInstantiatedFromUsingDecl(NamedDecl *Inst,
+                                              NamedDecl *Pattern) {
+  assert((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) ||
           isa<UnresolvedUsingTypenameDecl>(Pattern)) &&
          "pattern decl is not a using decl");
-  assert((isa<UsingDecl>(Inst) ||
-          isa<UnresolvedUsingValueDecl>(Inst) ||
+  assert((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) ||
           isa<UnresolvedUsingTypenameDecl>(Inst)) &&
          "instantiation did not produce a using decl");
   assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists");
@@ -1597,24 +1572,23 @@
 
 UsingShadowDecl *
 ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) {
-  llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
-    = InstantiatedFromUsingShadowDecl.find(Inst);
+  llvm::DenseMap<UsingShadowDecl *, UsingShadowDecl *>::const_iterator Pos =
+      InstantiatedFromUsingShadowDecl.find(Inst);
   if (Pos == InstantiatedFromUsingShadowDecl.end())
     return nullptr;
 
   return Pos->second;
 }
 
-void
-ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
-                                               UsingShadowDecl *Pattern) {
+void ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
+                                                    UsingShadowDecl *Pattern) {
   assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists");
   InstantiatedFromUsingShadowDecl[Inst] = Pattern;
 }
 
 FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) {
-  llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
-    = InstantiatedFromUnnamedFieldDecl.find(Field);
+  llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos =
+      InstantiatedFromUnnamedFieldDecl.find(Field);
   if (Pos == InstantiatedFromUnnamedFieldDecl.end())
     return nullptr;
 
@@ -1632,52 +1606,51 @@
 }
 
 ASTContext::overridden_cxx_method_iterator
-ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const {
+ASTContext::overridden_methods_begin(CXXMethodDecl const *Method) const {
   return overridden_methods(Method).begin();
 }
 
 ASTContext::overridden_cxx_method_iterator
-ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const {
+ASTContext::overridden_methods_end(CXXMethodDecl const *Method) const {
   return overridden_methods(Method).end();
 }
 
 unsigned
-ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const {
+ASTContext::overridden_methods_size(CXXMethodDecl const *Method) const {
   auto Range = overridden_methods(Method);
   return Range.end() - Range.begin();
 }
 
 ASTContext::overridden_method_range
-ASTContext::overridden_methods(const CXXMethodDecl *Method) const {
-  llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
+ASTContext::overridden_methods(CXXMethodDecl const *Method) const {
+  llvm::DenseMap<CXXMethodDecl const *, CXXMethodVector>::const_iterator Pos =
       OverriddenMethods.find(Method->getCanonicalDecl());
   if (Pos == OverriddenMethods.end())
     return overridden_method_range(nullptr, nullptr);
   return overridden_method_range(Pos->second.begin(), Pos->second.end());
 }
 
-void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method,
-                                     const CXXMethodDecl *Overridden) {
+void ASTContext::addOverriddenMethod(CXXMethodDecl const *Method,
+                                     CXXMethodDecl const *Overridden) {
   assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl());
   OverriddenMethods[Method].push_back(Overridden);
 }
 
 void ASTContext::getOverriddenMethods(
-                      const NamedDecl *D,
-                      SmallVectorImpl<const NamedDecl *> &Overridden) const {
+    NamedDecl const *D, SmallVectorImpl<NamedDecl const *> &Overridden) const {
   assert(D);
 
-  if (const auto *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
+  if (auto const *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
     Overridden.append(overridden_methods_begin(CXXMethod),
                       overridden_methods_end(CXXMethod));
     return;
   }
 
-  const auto *Method = dyn_cast<ObjCMethodDecl>(D);
+  auto const *Method = dyn_cast<ObjCMethodDecl>(D);
   if (!Method)
     return;
 
-  SmallVector<const ObjCMethodDecl *, 8> OverDecls;
+  SmallVector<ObjCMethodDecl const *, 8> OverDecls;
   Method->getOverriddenMethods(OverDecls);
   Overridden.append(OverDecls.begin(), OverDecls.end());
 }
@@ -1702,7 +1675,7 @@
 
 /// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
 /// scalar floating point type.
-const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
+llvm::fltSemantics const &ASTContext::getFloatTypeSemantics(QualType T) const {
   switch (T->castAs<BuiltinType>()->getKind()) {
   default:
     llvm_unreachable("Not a floating point type!");
@@ -1711,8 +1684,10 @@
   case BuiltinType::Float16:
   case BuiltinType::Half:
     return Target->getHalfFormat();
-  case BuiltinType::Float:      return Target->getFloatFormat();
-  case BuiltinType::Double:     return Target->getDoubleFormat();
+  case BuiltinType::Float:
+    return Target->getFloatFormat();
+  case BuiltinType::Double:
+    return Target->getDoubleFormat();
   case BuiltinType::Ibm128:
     return Target->getIbm128Format();
   case BuiltinType::LongDouble:
@@ -1726,7 +1701,7 @@
   }
 }
 
-CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
+CharUnits ASTContext::getDeclAlign(Decl const *D, bool ForAlignof) const {
   unsigned Align = Target->getCharWidth();
 
   bool UseAlignAttrOnly = false;
@@ -1741,23 +1716,21 @@
     // ignore that possibility;  Sema should diagnose it.
     if (isa<FieldDecl>(D)) {
       UseAlignAttrOnly = D->hasAttr<PackedAttr>() ||
-        cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
+                         cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
     } else {
       UseAlignAttrOnly = true;
     }
-  }
-  else if (isa<FieldDecl>(D))
-      UseAlignAttrOnly =
-        D->hasAttr<PackedAttr>() ||
-        cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
+  } else if (isa<FieldDecl>(D))
+    UseAlignAttrOnly = D->hasAttr<PackedAttr>() ||
+                       cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
 
   // If we're using the align attribute only, just ignore everything
   // else about the declaration and its type.
   if (UseAlignAttrOnly) {
     // do nothing
-  } else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
+  } else if (auto const *VD = dyn_cast<ValueDecl>(D)) {
     QualType T = VD->getType();
-    if (const auto *RT = T->getAs<ReferenceType>()) {
+    if (auto const *RT = T->getAs<ReferenceType>()) {
       if (ForAlignof)
         T = RT->getPointeeType();
       else
@@ -1769,7 +1742,7 @@
     else if (!BaseT->isIncompleteType()) {
       // Adjust alignments of declarations with array type by the
       // large-array alignment on the target.
-      if (const ArrayType *arrayType = getAsArrayType(T)) {
+      if (ArrayType const *arrayType = getAsArrayType(T)) {
         unsigned MinWidth = Target->getLargeArrayMinWidth();
         if (!ForAlignof && MinWidth) {
           if (isa<VariableArrayType>(arrayType))
@@ -1782,7 +1755,7 @@
       Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
       if (BaseT.getQualifiers().hasUnaligned())
         Align = Target->getCharWidth();
-      if (const auto *VD = dyn_cast<VarDecl>(D)) {
+      if (auto const *VD = dyn_cast<VarDecl>(D)) {
         if (VD->hasGlobalStorage() && !ForAlignof) {
           uint64_t TypeSize = getTypeSize(T.getTypePtr());
           Align = std::max(Align, getTargetInfo().getMinGlobalAlign(TypeSize));
@@ -1795,11 +1768,11 @@
     // a max-field-alignment constraint (#pragma pack).  So calculate
     // the actual alignment of the field within the struct, and then
     // (as we're expected to) constrain that by the alignment of the type.
-    if (const auto *Field = dyn_cast<FieldDecl>(VD)) {
-      const RecordDecl *Parent = Field->getParent();
+    if (auto const *Field = dyn_cast<FieldDecl>(VD)) {
+      RecordDecl const *Parent = Field->getParent();
       // We can only produce a sensible answer if the record is valid.
       if (!Parent->isInvalidDecl()) {
-        const ASTRecordLayout &Layout = getASTRecordLayout(Parent);
+        ASTRecordLayout const &Layout = getASTRecordLayout(Parent);
 
         // Start with the record's overall alignment.
         unsigned FieldAlign = toBits(Layout.getAlignment());
@@ -1821,8 +1794,8 @@
 
   // Some targets have hard limitation on the maximum requestable alignment in
   // aligned attribute for static variables.
-  const unsigned MaxAlignedAttr = getTargetInfo().getMaxAlignedAttribute();
-  const auto *VD = dyn_cast<VarDecl>(D);
+  unsigned const MaxAlignedAttr = getTargetInfo().getMaxAlignedAttribute();
+  auto const *VD = dyn_cast<VarDecl>(D);
   if (MaxAlignedAttr && VD && VD->getStorageClass() == SC_Static)
     Align = std::min(Align, MaxAlignedAttr);
 
@@ -1844,8 +1817,8 @@
   // of a base-class subobject.  We decide whether that's possible
   // during class layout, so here we can just trust the layout results.
   if (getLangOpts().CPlusPlus) {
-    if (const auto *RT = T->getAs<RecordType>()) {
-      const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl());
+    if (auto const *RT = T->getAs<RecordType>()) {
+      ASTRecordLayout const &layout = getASTRecordLayout(RT->getDecl());
       Info.Width = layout.getDataSize();
     }
   }
@@ -1855,13 +1828,12 @@
 
 /// getConstantArrayInfoInChars - Performing the computation in CharUnits
 /// instead of in bits prevents overflowing the uint64_t for some large arrays.
-TypeInfoChars
-static getConstantArrayInfoInChars(const ASTContext &Context,
-                                   const ConstantArrayType *CAT) {
+static TypeInfoChars getConstantArrayInfoInChars(ASTContext const &Context,
+                                                 ConstantArrayType const *CAT) {
   TypeInfoChars EltInfo = Context.getTypeInfoInChars(CAT->getElementType());
   uint64_t Size = CAT->getSize().getZExtValue();
   assert((Size == 0 || static_cast<uint64_t>(EltInfo.Width.getQuantity()) <=
-              (uint64_t)(-1)/Size) &&
+                           (uint64_t)(-1) / Size) &&
          "Overflow in array type char size evaluation");
   uint64_t Width = EltInfo.Width.getQuantity() * Size;
   unsigned Align = EltInfo.Align.getQuantity();
@@ -1873,8 +1845,8 @@
                        EltInfo.AlignRequirement);
 }
 
-TypeInfoChars ASTContext::getTypeInfoInChars(const Type *T) const {
-  if (const auto *CAT = dyn_cast<ConstantArrayType>(T))
+TypeInfoChars ASTContext::getTypeInfoInChars(Type const *T) const {
+  if (auto const *CAT = dyn_cast<ConstantArrayType>(T))
     return getConstantArrayInfoInChars(*this, CAT);
   TypeInfo Info = getTypeInfo(T);
   return TypeInfoChars(toCharUnitsFromBits(Info.Width),
@@ -1885,7 +1857,7 @@
   return getTypeInfoInChars(T.getTypePtr());
 }
 
-bool ASTContext::isAlignmentRequired(const Type *T) const {
+bool ASTContext::isAlignmentRequired(Type const *T) const {
   return getTypeInfo(T).AlignRequirement != AlignRequirementKind::None;
 }
 
@@ -1896,7 +1868,7 @@
 unsigned ASTContext::getTypeAlignIfKnown(QualType T,
                                          bool NeedsPreferredAlignment) const {
   // An alignment on a typedef overrides anything else.
-  if (const auto *TT = T->getAs<TypedefType>())
+  if (auto const *TT = T->getAs<TypedefType>())
     if (unsigned Align = TT->getDecl()->getMaxAlignment())
       return Align;
 
@@ -1907,18 +1879,18 @@
 
   // If we had an array type, its element type might be a typedef
   // type with an alignment attribute.
-  if (const auto *TT = T->getAs<TypedefType>())
+  if (auto const *TT = T->getAs<TypedefType>())
     if (unsigned Align = TT->getDecl()->getMaxAlignment())
       return Align;
 
   // Otherwise, see if the declaration of the type had an attribute.
-  if (const auto *TT = T->getAs<TagType>())
+  if (auto const *TT = T->getAs<TagType>())
     return TT->getDecl()->getMaxAlignment();
 
   return 0;
 }
 
-TypeInfo ASTContext::getTypeInfo(const Type *T) const {
+TypeInfo ASTContext::getTypeInfo(Type const *T) const {
   TypeInfoMap::iterator I = MemoizedTypeInfo.find(T);
   if (I != MemoizedTypeInfo.end())
     return I->second;
@@ -1935,7 +1907,7 @@
 /// FIXME: Pointers into different addr spaces could have different sizes and
 /// alignment requirements: getPointerInfo should take an AddrSpace, this
 /// should take a QualType, &c.
-TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
+TypeInfo ASTContext::getTypeInfoImpl(Type const *T) const {
   uint64_t Width = 0;
   unsigned Align = 8;
   AlignRequirementKind AlignRequirement = AlignRequirementKind::None;
@@ -1947,8 +1919,8 @@
 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base)                       \
   case Type::Class:                                                            \
-  assert(!T->isDependentType() && "should not see dependent types here");      \
-  return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
+    assert(!T->isDependentType() && "should not see dependent types here");    \
+    return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
 #include "clang/AST/TypeNodes.inc"
     llvm_unreachable("Should not see dependent types");
 
@@ -1964,7 +1936,7 @@
   case Type::ConstantArray: {
     // Model non-constant sized arrays as size zero, but track the alignment.
     uint64_t Size = 0;
-    if (const auto *CAT = dyn_cast<ConstantArrayType>(T))
+    if (auto const *CAT = dyn_cast<ConstantArrayType>(T))
       Size = CAT->getSize().getZExtValue();
 
     TypeInfo EltInfo = getTypeInfo(cast<ArrayType>(T)->getElementType());
@@ -1981,13 +1953,13 @@
 
   case Type::ExtVector:
   case Type::Vector: {
-    const auto *VT = cast<VectorType>(T);
+    auto const *VT = cast<VectorType>(T);
     TypeInfo EltInfo = getTypeInfo(VT->getElementType());
     Width = EltInfo.Width * VT->getNumElements();
     Align = Width;
     // If the alignment is not a power of 2, round up to the next power of 2.
     // This happens for non-power-of-2 length vectors.
-    if (Align & (Align-1)) {
+    if (Align & (Align - 1)) {
       Align = llvm::NextPowerOf2(Align);
       Width = llvm::alignTo(Width, Align);
     }
@@ -2006,7 +1978,7 @@
   }
 
   case Type::ConstantMatrix: {
-    const auto *MT = cast<ConstantMatrixType>(T);
+    auto const *MT = cast<ConstantMatrixType>(T);
     TypeInfo ElementInfo = getTypeInfo(MT->getElementType());
     // The internal layout of a matrix value is implementation defined.
     // Initially be ABI compatible with arrays with respect to alignment and
@@ -2018,7 +1990,8 @@
 
   case Type::Builtin:
     switch (cast<BuiltinType>(T)->getKind()) {
-    default: llvm_unreachable("Unknown builtin type!");
+    default:
+      llvm_unreachable("Unknown builtin type!");
     case BuiltinType::Void:
       // GCC extension: alignof(void) = 8 bits.
       Width = 0;
@@ -2183,25 +2156,24 @@
     case BuiltinType::OCLClkEvent:
     case BuiltinType::OCLQueue:
     case BuiltinType::OCLReserveID:
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-    case BuiltinType::Id:
-#include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
   case BuiltinType::Id:
+#include "clang/Basic/OpenCLImageTypes.def"
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
 #include "clang/Basic/OpenCLExtensionTypes.def"
       AS = getTargetAddressSpace(
           Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T)));
       Width = Target->getPointerWidth(AS);
       Align = Target->getPointerAlign(AS);
       break;
-    // The SVE types are effectively target-specific.  The length of an
-    // SVE_VECTOR_TYPE is only known at runtime, but it is always a multiple
-    // of 128 bits.  There is one predicate bit for each vector byte, so the
-    // length of an SVE_PREDICATE_TYPE is always a multiple of 16 bits.
-    //
-    // Because the length is only known at runtime, we use a dummy value
-    // of 0 for the static length.  The alignment values are those defined
-    // by the Procedure Call Standard for the Arm Architecture.
+      // The SVE types are effectively target-specific.  The length of an
+      // SVE_VECTOR_TYPE is only known at runtime, but it is always a multiple
+      // of 128 bits.  There is one predicate bit for each vector byte, so the
+      // length of an SVE_PREDICATE_TYPE is always a multiple of 16 bits.
+      //
+      // Because the length is only known at runtime, we use a dummy value
+      // of 0 for the static length.  The alignment values are those defined
+      // by the Procedure Call Standard for the Arm Architecture.
 #define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId, NumEls, ElBits,    \
                         IsSigned, IsFP, IsBF)                                  \
   case BuiltinType::Id:                                                        \
@@ -2257,7 +2229,7 @@
     Align = Target->getPointerAlign(AS);
     break;
   case Type::MemberPointer: {
-    const auto *MPT = cast<MemberPointerType>(T);
+    auto const *MPT = cast<MemberPointerType>(T);
     CXXABI::MemberPointerInfo MPI = ABI->getMemberPointerInfo(MPT);
     Width = MPI.Width;
     Align = MPI.Align;
@@ -2277,19 +2249,19 @@
   case Type::Decayed:
     return getTypeInfo(cast<AdjustedType>(T)->getAdjustedType().getTypePtr());
   case Type::ObjCInterface: {
-    const auto *ObjCI = cast<ObjCInterfaceType>(T);
+    auto const *ObjCI = cast<ObjCInterfaceType>(T);
     if (ObjCI->getDecl()->isInvalidDecl()) {
       Width = 8;
       Align = 8;
       break;
     }
-    const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
+    ASTRecordLayout const &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
     Width = toBits(Layout.getSize());
     Align = toBits(Layout.getAlignment());
     break;
   }
   case Type::ExtInt: {
-    const auto *EIT = cast<ExtIntType>(T);
+    auto const *EIT = cast<ExtIntType>(T);
     Align =
         std::min(static_cast<unsigned>(std::max(
                      getCharWidth(), llvm::PowerOf2Ceil(EIT->getNumBits()))),
@@ -2299,7 +2271,7 @@
   }
   case Type::Record:
   case Type::Enum: {
-    const auto *TT = cast<TagType>(T);
+    auto const *TT = cast<TagType>(T);
 
     if (TT->getDecl()->isInvalidDecl()) {
       Width = 8;
@@ -2307,8 +2279,8 @@
       break;
     }
 
-    if (const auto *ET = dyn_cast<EnumType>(TT)) {
-      const EnumDecl *ED = ET->getDecl();
+    if (auto const *ET = dyn_cast<EnumType>(TT)) {
+      EnumDecl const *ED = ET->getDecl();
       TypeInfo Info =
           getTypeInfo(ED->getIntegerType()->getUnqualifiedDesugaredType());
       if (unsigned AttrAlign = ED->getMaxAlignment()) {
@@ -2318,9 +2290,9 @@
       return Info;
     }
 
-    const auto *RT = cast<RecordType>(TT);
-    const RecordDecl *RD = RT->getDecl();
-    const ASTRecordLayout &Layout = getASTRecordLayout(RD);
+    auto const *RT = cast<RecordType>(TT);
+    RecordDecl const *RD = RT->getDecl();
+    ASTRecordLayout const &Layout = getASTRecordLayout(RD);
     Width = toBits(Layout.getSize());
     Align = toBits(Layout.getAlignment());
     AlignRequirement = RD->hasAttr<AlignedAttr>()
@@ -2330,12 +2302,12 @@
   }
 
   case Type::SubstTemplateTypeParm:
-    return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
-                       getReplacementType().getTypePtr());
+    return getTypeInfo(
+        cast<SubstTemplateTypeParmType>(T)->getReplacementType().getTypePtr());
 
   case Type::Auto:
   case Type::DeducedTemplateSpecialization: {
-    const auto *A = cast<DeducedType>(T);
+    auto const *A = cast<DeducedType>(T);
     assert(!A->getDeducedType().isNull() &&
            "cannot request the size of an undeduced or dependent auto type");
     return getTypeInfo(A->getDeducedType().getTypePtr());
@@ -2352,7 +2324,7 @@
     return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr());
 
   case Type::Typedef: {
-    const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl();
+    TypedefNameDecl const *Typedef = cast<TypedefType>(T)->getDecl();
     TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
     // If the typedef has an aligned attribute on it, it overrides any computed
     // alignment we have.  This violates the GCC documentation (which says that
@@ -2373,7 +2345,7 @@
 
   case Type::Attributed:
     return getTypeInfo(
-                  cast<AttributedType>(T)->getEquivalentType().getTypePtr());
+        cast<AttributedType>(T)->getEquivalentType().getTypePtr());
 
   case Type::Atomic: {
     // Start with the base type information.
@@ -2398,12 +2370,13 @@
       // Set the alignment equal to the size.
       Align = static_cast<unsigned>(Width);
     }
-  }
-  break;
+  } break;
 
   case Type::Pipe:
-    Width = Target->getPointerWidth(getTargetAddressSpace(LangAS::opencl_global));
-    Align = Target->getPointerAlign(getTargetAddressSpace(LangAS::opencl_global));
+    Width =
+        Target->getPointerWidth(getTargetAddressSpace(LangAS::opencl_global));
+    Align =
+        Target->getPointerAlign(getTargetAddressSpace(LangAS::opencl_global));
     break;
   }
 
@@ -2411,18 +2384,18 @@
   return TypeInfo(Width, Align, AlignRequirement);
 }
 
-unsigned ASTContext::getTypeUnadjustedAlign(const Type *T) const {
+unsigned ASTContext::getTypeUnadjustedAlign(Type const *T) const {
   UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(T);
   if (I != MemoizedUnadjustedAlign.end())
     return I->second;
 
   unsigned UnadjustedAlign;
-  if (const auto *RT = T->getAs<RecordType>()) {
-    const RecordDecl *RD = RT->getDecl();
-    const ASTRecordLayout &Layout = getASTRecordLayout(RD);
+  if (auto const *RT = T->getAs<RecordType>()) {
+    RecordDecl const *RD = RT->getDecl();
+    ASTRecordLayout const &Layout = getASTRecordLayout(RD);
     UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
-  } else if (const auto *ObjCI = T->getAs<ObjCInterfaceType>()) {
-    const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
+  } else if (auto const *ObjCI = T->getAs<ObjCInterfaceType>()) {
+    ASTRecordLayout const &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
     UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
   } else {
     UnadjustedAlign = getTypeAlign(T->getUnqualifiedDesugaredType());
@@ -2452,7 +2425,7 @@
 CharUnits ASTContext::getTypeSizeInChars(QualType T) const {
   return getTypeInfoInChars(T).Width;
 }
-CharUnits ASTContext::getTypeSizeInChars(const Type *T) const {
+CharUnits ASTContext::getTypeSizeInChars(Type const *T) const {
   return getTypeInfoInChars(T).Width;
 }
 
@@ -2461,7 +2434,7 @@
 CharUnits ASTContext::getTypeAlignInChars(QualType T) const {
   return toCharUnitsFromBits(getTypeAlign(T));
 }
-CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
+CharUnits ASTContext::getTypeAlignInChars(Type const *T) const {
   return toCharUnitsFromBits(getTypeAlign(T));
 }
 
@@ -2471,7 +2444,7 @@
 CharUnits ASTContext::getTypeUnadjustedAlignInChars(QualType T) const {
   return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
 }
-CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const {
+CharUnits ASTContext::getTypeUnadjustedAlignInChars(Type const *T) const {
   return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
 }
 
@@ -2480,7 +2453,7 @@
 /// alignment in cases where it is beneficial for performance or backwards
 /// compatibility preserving to overalign a data type. (Note: despite the name,
 /// the preferred alignment is ABI-impacting, and not an optimization.)
-unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
+unsigned ASTContext::getPreferredTypeAlign(Type const *T) const {
   TypeInfo TI = getTypeInfo(T);
   unsigned ABIAlign = TI.Align;
 
@@ -2493,8 +2466,8 @@
   if (!Target->allowsLargerPreferedTypeAlignment())
     return ABIAlign;
 
-  if (const auto *RT = T->getAs<RecordType>()) {
-    const RecordDecl *RD = RT->getDecl();
+  if (auto const *RT = T->getAs<RecordType>()) {
+    RecordDecl const *RD = RT->getDecl();
 
     // When used as part of a typedef, or together with a 'packed' attribute,
     // the 'aligned' attribute can be used to decrease alignment. Note that the
@@ -2514,9 +2487,9 @@
   // Double (and, for targets supporting AIX `power` alignment, long double) and
   // long long should be naturally aligned (despite requiring less alignment) if
   // possible.
-  if (const auto *CT = T->getAs<ComplexType>())
+  if (auto const *CT = T->getAs<ComplexType>())
     T = CT->getElementType().getTypePtr();
-  if (const auto *ET = T->getAs<EnumType>())
+  if (auto const *ET = T->getAs<EnumType>())
     T = ET->getDecl()->getIntegerType().getTypePtr();
   if (T->isSpecificBuiltinType(BuiltinType::Double) ||
       T->isSpecificBuiltinType(BuiltinType::LongLong) ||
@@ -2552,25 +2525,25 @@
   return toCharUnitsFromBits(getAlignOfGlobalVar(T));
 }
 
-CharUnits ASTContext::getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const {
+CharUnits ASTContext::getOffsetOfBaseWithVBPtr(CXXRecordDecl const *RD) const {
   CharUnits Offset = CharUnits::Zero();
-  const ASTRecordLayout *Layout = &getASTRecordLayout(RD);
-  while (const CXXRecordDecl *Base = Layout->getBaseSharingVBPtr()) {
+  ASTRecordLayout const *Layout = &getASTRecordLayout(RD);
+  while (CXXRecordDecl const *Base = Layout->getBaseSharingVBPtr()) {
     Offset += Layout->getBaseClassOffset(Base);
     Layout = &getASTRecordLayout(Base);
   }
   return Offset;
 }
 
-CharUnits ASTContext::getMemberPointerPathAdjustment(const APValue &MP) const {
-  const ValueDecl *MPD = MP.getMemberPointerDecl();
+CharUnits ASTContext::getMemberPointerPathAdjustment(APValue const &MP) const {
+  ValueDecl const *MPD = MP.getMemberPointerDecl();
   CharUnits ThisAdjustment = CharUnits::Zero();
-  ArrayRef<const CXXRecordDecl*> Path = MP.getMemberPointerPath();
+  ArrayRef<CXXRecordDecl const *> Path = MP.getMemberPointerPath();
   bool DerivedMember = MP.isMemberPointerToDerivedMember();
-  const CXXRecordDecl *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
+  CXXRecordDecl const *RD = cast<CXXRecordDecl>(MPD->getDeclContext());
   for (unsigned I = 0, N = Path.size(); I != N; ++I) {
-    const CXXRecordDecl *Base = RD;
-    const CXXRecordDecl *Derived = Path[I];
+    CXXRecordDecl const *Base = RD;
+    CXXRecordDecl const *Derived = Path[I];
     if (DerivedMember)
       std::swap(Base, Derived);
     ThisAdjustment += getASTRecordLayout(Derived).getBaseClassOffset(Base);
@@ -2586,27 +2559,27 @@
 /// super class and then collects all ivars, including those synthesized for
 /// current class. This routine is used for implementation of current class
 /// when all ivars, declared and synthesized are known.
-void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI,
-                                      bool leafClass,
-                            SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const {
-  if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
+void ASTContext::DeepCollectObjCIvars(
+    ObjCInterfaceDecl const *OI, bool leafClass,
+    SmallVectorImpl<ObjCIvarDecl const *> &Ivars) const {
+  if (ObjCInterfaceDecl const *SuperClass = OI->getSuperClass())
     DeepCollectObjCIvars(SuperClass, false, Ivars);
   if (!leafClass) {
-    for (const auto *I : OI->ivars())
+    for (auto const *I : OI->ivars())
       Ivars.push_back(I);
   } else {
     auto *IDecl = const_cast<ObjCInterfaceDecl *>(OI);
-    for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
-         Iv= Iv->getNextIvar())
+    for (ObjCIvarDecl const *Iv = IDecl->all_declared_ivar_begin(); Iv;
+         Iv = Iv->getNextIvar())
       Ivars.push_back(Iv);
   }
 }
 
 /// CollectInheritedProtocols - Collect all protocols in current class and
 /// those inherited by it.
-void ASTContext::CollectInheritedProtocols(const Decl *CDecl,
-                          llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
-  if (const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
+void ASTContext::CollectInheritedProtocols(
+    Decl const *CDecl, llvm::SmallPtrSet<ObjCProtocolDecl *, 8> &Protocols) {
+  if (auto const *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
     // We can use protocol_iterator here instead of
     // all_referenced_protocol_iterator since we are walking all categories.
     for (auto *Proto : OI->all_referenced_protocols()) {
@@ -2614,7 +2587,7 @@
     }
 
     // Categories of this Interface.
-    for (const auto *Cat : OI->visible_categories())
+    for (auto const *Cat : OI->visible_categories())
       CollectInheritedProtocols(Cat, Protocols);
 
     if (ObjCInterfaceDecl *SD = OI->getSuperClass())
@@ -2622,14 +2595,15 @@
         CollectInheritedProtocols(SD, Protocols);
         SD = SD->getSuperClass();
       }
-  } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
+  } else if (auto const *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
     for (auto *Proto : OC->protocols()) {
       CollectInheritedProtocols(Proto, Protocols);
     }
-  } else if (const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
+  } else if (auto const *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
     // Insert the protocol.
-    if (!Protocols.insert(
-          const_cast<ObjCProtocolDecl *>(OP->getCanonicalDecl())).second)
+    if (!Protocols
+             .insert(const_cast<ObjCProtocolDecl *>(OP->getCanonicalDecl()))
+             .second)
       return;
 
     for (auto *Proto : OP->protocols())
@@ -2637,12 +2611,12 @@
   }
 }
 
-static bool unionHasUniqueObjectRepresentations(const ASTContext &Context,
-                                                const RecordDecl *RD) {
+static bool unionHasUniqueObjectRepresentations(ASTContext const &Context,
+                                                RecordDecl const *RD) {
   assert(RD->isUnion() && "Must be union type");
   CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());
 
-  for (const auto *Field : RD->fields()) {
+  for (auto const *Field : RD->fields()) {
     if (!Context.hasUniqueObjectRepresentations(Field->getType()))
       return false;
     CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
@@ -2652,26 +2626,26 @@
   return !RD->field_empty();
 }
 
-static int64_t getSubobjectOffset(const FieldDecl *Field,
-                                  const ASTContext &Context,
-                                  const clang::ASTRecordLayout & /*Layout*/) {
+static int64_t getSubobjectOffset(FieldDecl const *Field,
+                                  ASTContext const &Context,
+                                  clang::ASTRecordLayout const & /*Layout*/) {
   return Context.getFieldOffset(Field);
 }
 
-static int64_t getSubobjectOffset(const CXXRecordDecl *RD,
-                                  const ASTContext &Context,
-                                  const clang::ASTRecordLayout &Layout) {
+static int64_t getSubobjectOffset(CXXRecordDecl const *RD,
+                                  ASTContext const &Context,
+                                  clang::ASTRecordLayout const &Layout) {
   return Context.toBits(Layout.getBaseClassOffset(RD));
 }
 
 static llvm::Optional<int64_t>
-structHasUniqueObjectRepresentations(const ASTContext &Context,
-                                     const RecordDecl *RD);
+structHasUniqueObjectRepresentations(ASTContext const &Context,
+                                     RecordDecl const *RD);
 
 static llvm::Optional<int64_t>
-getSubobjectSizeInBits(const FieldDecl *Field, const ASTContext &Context) {
+getSubobjectSizeInBits(FieldDecl const *Field, ASTContext const &Context) {
   if (Field->getType()->isRecordType()) {
-    const RecordDecl *RD = Field->getType()->getAsRecordDecl();
+    RecordDecl const *RD = Field->getType()->getAsRecordDecl();
     if (!RD->isUnion())
       return structHasUniqueObjectRepresentations(Context, RD);
   }
@@ -2691,15 +2665,15 @@
 }
 
 static llvm::Optional<int64_t>
-getSubobjectSizeInBits(const CXXRecordDecl *RD, const ASTContext &Context) {
+getSubobjectSizeInBits(CXXRecordDecl const *RD, ASTContext const &Context) {
   return structHasUniqueObjectRepresentations(Context, RD);
 }
 
 template <typename RangeT>
 static llvm::Optional<int64_t> structSubobjectsHaveUniqueObjectRepresentations(
-    const RangeT &Subobjects, int64_t CurOffsetInBits,
-    const ASTContext &Context, const clang::ASTRecordLayout &Layout) {
-  for (const auto *Subobject : Subobjects) {
+    RangeT const &Subobjects, int64_t CurOffsetInBits,
+    ASTContext const &Context, clang::ASTRecordLayout const &Layout) {
+  for (auto const *Subobject : Subobjects) {
     llvm::Optional<int64_t> SizeInBits =
         getSubobjectSizeInBits(Subobject, Context);
     if (!SizeInBits)
@@ -2715,24 +2689,24 @@
 }
 
 static llvm::Optional<int64_t>
-structHasUniqueObjectRepresentations(const ASTContext &Context,
-                                     const RecordDecl *RD) {
+structHasUniqueObjectRepresentations(ASTContext const &Context,
+                                     RecordDecl const *RD) {
   assert(!RD->isUnion() && "Must be struct/class type");
-  const auto &Layout = Context.getASTRecordLayout(RD);
+  auto const &Layout = Context.getASTRecordLayout(RD);
 
   int64_t CurOffsetInBits = 0;
-  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
+  if (auto const *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
     if (ClassDecl->isDynamicClass())
       return llvm::None;
 
     SmallVector<CXXRecordDecl *, 4> Bases;
-    for (const auto &Base : ClassDecl->bases()) {
+    for (auto const &Base : ClassDecl->bases()) {
       // Empty types can be inherited from, and non-empty types can potentially
       // have tail padding, so just make sure there isn't an error.
       Bases.emplace_back(Base.getType()->getAsCXXRecordDecl());
     }
 
-    llvm::sort(Bases, [&](const CXXRecordDecl *L, const CXXRecordDecl *R) {
+    llvm::sort(Bases, [&](CXXRecordDecl const *L, CXXRecordDecl const *R) {
       return Layout.getBaseClassOffset(L) < Layout.getBaseClassOffset(R);
     });
 
@@ -2791,12 +2765,12 @@
     return true;
 
   if (Ty->isMemberPointerType()) {
-    const auto *MPT = Ty->getAs<MemberPointerType>();
+    auto const *MPT = Ty->getAs<MemberPointerType>();
     return !ABI->getMemberPointerInfo(MPT).HasPadding;
   }
 
   if (Ty->isRecordType()) {
-    const RecordDecl *Record = Ty->castAs<RecordType>()->getDecl();
+    RecordDecl const *Record = Ty->castAs<RecordType>()->getDecl();
 
     if (Record->isInvalidDecl())
       return false;
@@ -2825,10 +2799,10 @@
   return false;
 }
 
-unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const {
+unsigned ASTContext::CountNonClassIvars(ObjCInterfaceDecl const *OI) const {
   unsigned count = 0;
   // Count ivars declared in class extension.
-  for (const auto *Ext : OI->known_extensions())
+  for (auto const *Ext : OI->known_extensions())
     count += Ext->ivar_size();
 
   // Count ivar defined in this class's implementation.  This
@@ -2839,29 +2813,32 @@
   return count;
 }
 
-bool ASTContext::isSentinelNullExpr(const Expr *E) {
+bool ASTContext::isSentinelNullExpr(Expr const *E) {
   if (!E)
     return false;
 
   // nullptr_t is always treated as null.
-  if (E->getType()->isNullPtrType()) return true;
+  if (E->getType()->isNullPtrType())
+    return true;
 
   if (E->getType()->isAnyPointerType() &&
-      E->IgnoreParenCasts()->isNullPointerConstant(*this,
-                                                Expr::NPC_ValueDependentIsNull))
+      E->IgnoreParenCasts()->isNullPointerConstant(
+          *this, Expr::NPC_ValueDependentIsNull))
     return true;
 
   // Unfortunately, __null has type 'int'.
-  if (isa<GNUNullExpr>(E)) return true;
+  if (isa<GNUNullExpr>(E))
+    return true;
 
   return false;
 }
 
 /// Get the implementation of ObjCInterfaceDecl, or nullptr if none
 /// exists.
-ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
-  llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
-    I = ObjCImpls.find(D);
+ObjCImplementationDecl *
+ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
+  llvm::DenseMap<ObjCContainerDecl *, ObjCImplDecl *>::iterator I =
+      ObjCImpls.find(D);
   if (I != ObjCImpls.end())
     return cast<ObjCImplementationDecl>(I->second);
   return nullptr;
@@ -2870,8 +2847,8 @@
 /// Get the implementation of ObjCCategoryDecl, or nullptr if none
 /// exists.
 ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) {
-  llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
-    I = ObjCImpls.find(D);
+  llvm::DenseMap<ObjCContainerDecl *, ObjCImplDecl *>::iterator I =
+      ObjCImpls.find(D);
   if (I != ObjCImpls.end())
     return cast<ObjCCategoryImplDecl>(I->second);
   return nullptr;
@@ -2879,36 +2856,36 @@
 
 /// Set the implementation of ObjCInterfaceDecl.
 void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD,
-                           ObjCImplementationDecl *ImplD) {
+                                       ObjCImplementationDecl *ImplD) {
   assert(IFaceD && ImplD && "Passed null params");
   ObjCImpls[IFaceD] = ImplD;
 }
 
 /// Set the implementation of ObjCCategoryDecl.
 void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD,
-                           ObjCCategoryImplDecl *ImplD) {
+                                       ObjCCategoryImplDecl *ImplD) {
   assert(CatD && ImplD && "Passed null params");
   ObjCImpls[CatD] = ImplD;
 }
 
-const ObjCMethodDecl *
-ASTContext::getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const {
+ObjCMethodDecl const *
+ASTContext::getObjCMethodRedeclaration(ObjCMethodDecl const *MD) const {
   return ObjCMethodRedecls.lookup(MD);
 }
 
-void ASTContext::setObjCMethodRedeclaration(const ObjCMethodDecl *MD,
-                                            const ObjCMethodDecl *Redecl) {
+void ASTContext::setObjCMethodRedeclaration(ObjCMethodDecl const *MD,
+                                            ObjCMethodDecl const *Redecl) {
   assert(!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration");
   ObjCMethodRedecls[MD] = Redecl;
 }
 
-const ObjCInterfaceDecl *ASTContext::getObjContainingInterface(
-                                              const NamedDecl *ND) const {
-  if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext()))
+ObjCInterfaceDecl const *
+ASTContext::getObjContainingInterface(NamedDecl const *ND) const {
+  if (auto const *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext()))
     return ID;
-  if (const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext()))
+  if (auto const *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext()))
     return CD->getClassInterface();
-  if (const auto *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext()))
+  if (auto const *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext()))
     return IMD->getClassInterface();
 
   return nullptr;
@@ -2916,10 +2893,9 @@
 
 /// Get the copy initialization expression of VarDecl, or nullptr if
 /// none exists.
-BlockVarCopyInit ASTContext::getBlockVarCopyInit(const VarDecl *VD) const {
+BlockVarCopyInit ASTContext::getBlockVarCopyInit(VarDecl const *VD) const {
   assert(VD && "Passed null params");
-  assert(VD->hasAttr<BlocksAttr>() &&
-         "getBlockVarCopyInits - not __block var");
+  assert(VD->hasAttr<BlocksAttr>() && "getBlockVarCopyInits - not __block var");
   auto I = BlockVarCopyInits.find(VD);
   if (I != BlockVarCopyInits.end())
     return I->second;
@@ -2927,11 +2903,10 @@
 }
 
 /// Set the copy initialization expression of a block var decl.
-void ASTContext::setBlockVarCopyInit(const VarDecl*VD, Expr *CopyExpr,
+void ASTContext::setBlockVarCopyInit(VarDecl const *VD, Expr *CopyExpr,
                                      bool CanThrow) {
   assert(VD && CopyExpr && "Passed null params");
-  assert(VD->hasAttr<BlocksAttr>() &&
-         "setBlockVarCopyInits - not __block var");
+  assert(VD->hasAttr<BlocksAttr>() && "setBlockVarCopyInits - not __block var");
   BlockVarCopyInits[VD].setExprAndFlag(CopyExpr, CanThrow);
 }
 
@@ -2943,8 +2918,8 @@
     assert(DataSize == TypeLoc::getFullDataSizeForType(T) &&
            "incorrect data size provided to CreateTypeSourceInfo!");
 
-  auto *TInfo =
-    (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
+  auto *TInfo = (TypeSourceInfo *)BumpAlloc.Allocate(
+      sizeof(TypeSourceInfo) + DataSize, 8);
   new (TInfo) TypeSourceInfo(T);
   return TInfo;
 }
@@ -2956,14 +2931,13 @@
   return DI;
 }
 
-const ASTRecordLayout &
-ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const {
+ASTRecordLayout const &
+ASTContext::getASTObjCInterfaceLayout(ObjCInterfaceDecl const *D) const {
   return getObjCLayout(D, nullptr);
 }
 
-const ASTRecordLayout &
-ASTContext::getASTObjCImplementationLayout(
-                                        const ObjCImplementationDecl *D) const {
+ASTRecordLayout const &ASTContext::getASTObjCImplementationLayout(
+    ObjCImplementationDecl const *D) const {
   return getObjCLayout(D->getClassInterface(), D);
 }
 
@@ -2971,8 +2945,8 @@
 //                   Type creation/memoization methods
 //===----------------------------------------------------------------------===//
 
-QualType
-ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
+QualType ASTContext::getExtQualType(Type const *baseType,
+                                    Qualifiers quals) const {
   unsigned fastQuals = quals.getFastQualifiers();
   quals.removeFastQualifiers();
 
@@ -2993,7 +2967,7 @@
     canon = getExtQualType(canonSplit.Ty, canonSplit.Quals);
 
     // Re-find the insert position.
-    (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
+    (void)ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
   }
 
   auto *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
@@ -3010,12 +2984,11 @@
   // If we are composing extended qualifiers together, merge together
   // into one ExtQuals node.
   QualifierCollector Quals;
-  const Type *TypeNode = Quals.strip(T);
+  Type const *TypeNode = Quals.strip(T);
 
   // If this type already has an address space specified, it cannot get
   // another one.
-  assert(!Quals.hasAddressSpace() &&
-         "Type cannot be in multiple addr spaces!");
+  assert(!Quals.hasAddressSpace() && "Type cannot be in multiple addr spaces!");
   Quals.addAddressSpace(AddressSpace);
 
   return getExtQualType(TypeNode, Quals);
@@ -3030,7 +3003,7 @@
   // If we are composing extended qualifiers together, merge together
   // into one ExtQuals node.
   QualifierCollector Quals;
-  const Type *TypeNode;
+  Type const *TypeNode;
 
   while (T.hasAddressSpace()) {
     TypeNode = Quals.strip(T);
@@ -3061,7 +3034,7 @@
   if (CanT.getObjCGCAttr() == GCAttr)
     return T;
 
-  if (const auto *ptr = T->getAs<PointerType>()) {
+  if (auto const *ptr = T->getAs<PointerType>()) {
     QualType Pointee = ptr->getPointeeType();
     if (Pointee->isAnyPointerType()) {
       QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
@@ -3072,19 +3045,18 @@
   // If we are composing extended qualifiers together, merge together
   // into one ExtQuals node.
   QualifierCollector Quals;
-  const Type *TypeNode = Quals.strip(T);
+  Type const *TypeNode = Quals.strip(T);
 
   // If this type already has an ObjCGC specified, it cannot get
   // another one.
-  assert(!Quals.hasObjCGCAttr() &&
-         "Type cannot have multiple ObjCGCs!");
+  assert(!Quals.hasObjCGCAttr() && "Type cannot have multiple ObjCGCs!");
   Quals.addObjCGCAttr(GCAttr);
 
   return getExtQualType(TypeNode, Quals);
 }
 
 QualType ASTContext::removePtrSizeAddrSpace(QualType T) const {
-  if (const PointerType *Ptr = T->getAs<PointerType>()) {
+  if (PointerType const *Ptr = T->getAs<PointerType>()) {
     QualType Pointee = Ptr->getPointeeType();
     if (isPtrSizeAddressSpace(Pointee.getAddressSpace())) {
       return getPointerType(removeAddrSpaceQualType(Pointee));
@@ -3093,16 +3065,16 @@
   return T;
 }
 
-const FunctionType *ASTContext::adjustFunctionType(const FunctionType *T,
+FunctionType const *ASTContext::adjustFunctionType(FunctionType const *T,
                                                    FunctionType::ExtInfo Info) {
   if (T->getExtInfo() == Info)
     return T;
 
   QualType Result;
-  if (const auto *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
+  if (auto const *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
     Result = getFunctionNoProtoType(FNPT->getReturnType(), Info);
   } else {
-    const auto *FPT = cast<FunctionProtoType>(T);
+    auto const *FPT = cast<FunctionProtoType>(T);
     FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
     EPI.ExtInfo = Info;
     Result = getFunctionType(FPT->getReturnType(), FPT->getParamTypes(), EPI);
@@ -3115,7 +3087,7 @@
                                                  QualType ResultType) {
   FD = FD->getMostRecentDecl();
   while (true) {
-    const auto *FPT = FD->getType()->castAs<FunctionProtoType>();
+    auto const *FPT = FD->getType()->castAs<FunctionProtoType>();
     FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
     FD->setType(getFunctionType(ResultType, FPT->getParamTypes(), EPI));
     if (FunctionDecl *Next = FD->getPreviousDecl())
@@ -3132,20 +3104,20 @@
 /// declaration of a function with an exception specification is permitted
 /// and preserved. Other type sugar (for instance, typedefs) is not.
 QualType ASTContext::getFunctionTypeWithExceptionSpec(
-    QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) {
+    QualType Orig, FunctionProtoType::ExceptionSpecInfo const &ESI) {
   // Might have some parens.
-  if (const auto *PT = dyn_cast<ParenType>(Orig))
+  if (auto const *PT = dyn_cast<ParenType>(Orig))
     return getParenType(
         getFunctionTypeWithExceptionSpec(PT->getInnerType(), ESI));
 
   // Might be wrapped in a macro qualified type.
-  if (const auto *MQT = dyn_cast<MacroQualifiedType>(Orig))
+  if (auto const *MQT = dyn_cast<MacroQualifiedType>(Orig))
     return getMacroQualifiedType(
         getFunctionTypeWithExceptionSpec(MQT->getUnderlyingType(), ESI),
         MQT->getMacroIdentifier());
 
   // Might have a calling-convention attribute.
-  if (const auto *AT = dyn_cast<AttributedType>(Orig))
+  if (auto const *AT = dyn_cast<AttributedType>(Orig))
     return getAttributedType(
         AT->getAttrKind(),
         getFunctionTypeWithExceptionSpec(AT->getModifiedType(), ESI),
@@ -3153,10 +3125,9 @@
 
   // Anything else must be a function type. Rebuild it with the new exception
   // specification.
-  const auto *Proto = Orig->castAs<FunctionProtoType>();
-  return getFunctionType(
-      Proto->getReturnType(), Proto->getParamTypes(),
-      Proto->getExtProtoInfo().withExceptionSpec(ESI));
+  auto const *Proto = Orig->castAs<FunctionProtoType>();
+  return getFunctionType(Proto->getReturnType(), Proto->getParamTypes(),
+                         Proto->getExtProtoInfo().withExceptionSpec(ESI));
 }
 
 bool ASTContext::hasSameFunctionTypeIgnoringExceptionSpec(QualType T,
@@ -3168,7 +3139,7 @@
 }
 
 QualType ASTContext::getFunctionTypeWithoutPtrSizes(QualType T) {
-  if (const auto *Proto = T->getAs<FunctionProtoType>()) {
+  if (auto const *Proto = T->getAs<FunctionProtoType>()) {
     QualType RetTy = removePtrSizeAddrSpace(Proto->getReturnType());
     SmallVector<QualType, 16> Args(Proto->param_types());
     for (unsigned i = 0, n = Args.size(); i != n; ++i)
@@ -3176,7 +3147,7 @@
     return getFunctionType(RetTy, Args, Proto->getExtProtoInfo());
   }
 
-  if (const FunctionNoProtoType *Proto = T->getAs<FunctionNoProtoType>()) {
+  if (FunctionNoProtoType const *Proto = T->getAs<FunctionNoProtoType>()) {
     QualType RetTy = removePtrSizeAddrSpace(Proto->getReturnType());
     return getFunctionNoProtoType(RetTy, Proto->getExtInfo());
   }
@@ -3185,17 +3156,15 @@
 }
 
 bool ASTContext::hasSameFunctionTypeIgnoringPtrSizes(QualType T, QualType U) {
-  return hasSameType(T, U) ||
-         hasSameType(getFunctionTypeWithoutPtrSizes(T),
-                     getFunctionTypeWithoutPtrSizes(U));
+  return hasSameType(T, U) || hasSameType(getFunctionTypeWithoutPtrSizes(T),
+                                          getFunctionTypeWithoutPtrSizes(U));
 }
 
 void ASTContext::adjustExceptionSpec(
-    FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI,
+    FunctionDecl *FD, FunctionProtoType::ExceptionSpecInfo const &ESI,
     bool AsWritten) {
   // Update the type.
-  QualType Updated =
-      getFunctionTypeWithExceptionSpec(FD->getType(), ESI);
+  QualType Updated = getFunctionTypeWithExceptionSpec(FD->getType(), ESI);
   FD->setType(Updated);
 
   if (!AsWritten)
@@ -3238,7 +3207,8 @@
 
     // Get the new insert position for the node we care about.
     ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
   auto *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
   Types.push_back(New);
@@ -3266,7 +3236,8 @@
 
     // Get the new insert position for the node we care about.
     PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
   auto *New = new (*this, TypeAlignment) PointerType(T, Canonical);
   Types.push_back(New);
@@ -3345,7 +3316,7 @@
 
   void *InsertPos = nullptr;
   if (BlockPointerType *PT =
-        BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
+          BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(PT, 0);
 
   // If the block pointee type isn't canonical, this won't be a canonical
@@ -3356,8 +3327,9 @@
 
     // Get the new insert position for the node we care about.
     BlockPointerType *NewIP =
-      BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+        BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
   auto *New = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
   Types.push_back(New);
@@ -3367,8 +3339,8 @@
 
 /// getLValueReferenceType - Return the uniqued reference to the type for an
 /// lvalue reference to the specified type.
-QualType
-ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const {
+QualType ASTContext::getLValueReferenceType(QualType T,
+                                            bool SpelledAsLValue) const {
   assert(getCanonicalType(T) != OverloadTy &&
          "Unresolved overloaded function type");
 
@@ -3379,10 +3351,10 @@
 
   void *InsertPos = nullptr;
   if (LValueReferenceType *RT =
-        LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
+          LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(RT, 0);
 
-  const auto *InnerRef = T->getAs<ReferenceType>();
+  auto const *InnerRef = T->getAs<ReferenceType>();
 
   // If the referencee type isn't canonical, this won't be a canonical type
   // either, so fill in the canonical type field.
@@ -3393,12 +3365,13 @@
 
     // Get the new insert position for the node we care about.
     LValueReferenceType *NewIP =
-      LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+        LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
 
-  auto *New = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
-                                                             SpelledAsLValue);
+  auto *New = new (*this, TypeAlignment)
+      LValueReferenceType(T, Canonical, SpelledAsLValue);
   Types.push_back(New);
   LValueReferenceTypes.InsertNode(New, InsertPos);
 
@@ -3415,10 +3388,10 @@
 
   void *InsertPos = nullptr;
   if (RValueReferenceType *RT =
-        RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
+          RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(RT, 0);
 
-  const auto *InnerRef = T->getAs<ReferenceType>();
+  auto const *InnerRef = T->getAs<ReferenceType>();
 
   // If the referencee type isn't canonical, this won't be a canonical type
   // either, so fill in the canonical type field.
@@ -3429,8 +3402,9 @@
 
     // Get the new insert position for the node we care about.
     RValueReferenceType *NewIP =
-      RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+        RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
 
   auto *New = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
@@ -3441,7 +3415,7 @@
 
 /// getMemberPointerType - Return the uniqued reference to the type for a
 /// member pointer to the specified type, in the specified class.
-QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const {
+QualType ASTContext::getMemberPointerType(QualType T, Type const *Cls) const {
   // Unique pointers, to guarantee there is only one pointer of a particular
   // structure.
   llvm::FoldingSetNodeID ID;
@@ -3449,19 +3423,21 @@
 
   void *InsertPos = nullptr;
   if (MemberPointerType *PT =
-      MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
+          MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(PT, 0);
 
   // If the pointee or class type isn't canonical, this won't be a canonical
   // type either, so fill in the canonical type field.
   QualType Canonical;
   if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
-    Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
+    Canonical =
+        getMemberPointerType(getCanonicalType(T), getCanonicalType(Cls));
 
     // Get the new insert position for the node we care about.
     MemberPointerType *NewIP =
-      MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+        MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
   auto *New = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
   Types.push_back(New);
@@ -3472,12 +3448,12 @@
 /// getConstantArrayType - Return the unique reference to the type for an
 /// array of the specified element type.
 QualType ASTContext::getConstantArrayType(QualType EltTy,
-                                          const llvm::APInt &ArySizeIn,
-                                          const Expr *SizeExpr,
+                                          llvm::APInt const &ArySizeIn,
+                                          Expr const *SizeExpr,
                                           ArrayType::ArraySizeModifier ASM,
                                           unsigned IndexTypeQuals) const {
-  assert((EltTy->isDependentType() ||
-          EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&
+  assert((EltTy->isDependentType() || EltTy->isIncompleteType() ||
+          EltTy->isConstantSizeType()) &&
          "Constant array of VLAs is illegal!");
 
   // We only need the size as part of the type if it's instantiation-dependent.
@@ -3495,7 +3471,7 @@
 
   void *InsertPos = nullptr;
   if (ConstantArrayType *ATP =
-      ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
+          ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(ATP, 0);
 
   // If the element type isn't canonical or has qualifiers, or the array bound
@@ -3510,15 +3486,16 @@
 
     // Get the new insert position for the node we care about.
     ConstantArrayType *NewIP =
-      ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+        ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
 
   void *Mem = Allocate(
-      ConstantArrayType::totalSizeToAlloc<const Expr *>(SizeExpr ? 1 : 0),
+      ConstantArrayType::totalSizeToAlloc<Expr const *>(SizeExpr ? 1 : 0),
       TypeAlignment);
   auto *New = new (Mem)
-    ConstantArrayType(EltTy, Canon, ArySize, SizeExpr, ASM, IndexTypeQuals);
+      ConstantArrayType(EltTy, Canon, ArySize, SizeExpr, ASM, IndexTypeQuals);
   ConstantArrayTypes.InsertNode(New, InsertPos);
   Types.push_back(New);
   return QualType(New, 0);
@@ -3529,12 +3506,13 @@
 /// sizes replaced with [*].
 QualType ASTContext::getVariableArrayDecayedType(QualType type) const {
   // Vastly most common case.
-  if (!type->isVariablyModifiedType()) return type;
+  if (!type->isVariablyModifiedType())
+    return type;
 
   QualType result;
 
   SplitQualType split = type.getSplitDesugaredType();
-  const Type *ty = split.Ty;
+  Type const *ty = split.Ty;
   switch (ty->getTypeClass()) {
 #define TYPE(Class, Base)
 #define ABSTRACT_TYPE(Class, Base)
@@ -3589,74 +3567,66 @@
   // TODO: if we ever care about optimizing VLAs, there are no-op
   // optimizations available here.
   case Type::Pointer:
-    result = getPointerType(getVariableArrayDecayedType(
-                              cast<PointerType>(ty)->getPointeeType()));
+    result = getPointerType(
+        getVariableArrayDecayedType(cast<PointerType>(ty)->getPointeeType()));
     break;
 
   case Type::LValueReference: {
-    const auto *lv = cast<LValueReferenceType>(ty);
+    auto const *lv = cast<LValueReferenceType>(ty);
     result = getLValueReferenceType(
-                 getVariableArrayDecayedType(lv->getPointeeType()),
-                                    lv->isSpelledAsLValue());
+        getVariableArrayDecayedType(lv->getPointeeType()),
+        lv->isSpelledAsLValue());
     break;
   }
 
   case Type::RValueReference: {
-    const auto *lv = cast<RValueReferenceType>(ty);
+    auto const *lv = cast<RValueReferenceType>(ty);
     result = getRValueReferenceType(
-                 getVariableArrayDecayedType(lv->getPointeeType()));
+        getVariableArrayDecayedType(lv->getPointeeType()));
     break;
   }
 
   case Type::Atomic: {
-    const auto *at = cast<AtomicType>(ty);
+    auto const *at = cast<AtomicType>(ty);
     result = getAtomicType(getVariableArrayDecayedType(at->getValueType()));
     break;
   }
 
   case Type::ConstantArray: {
-    const auto *cat = cast<ConstantArrayType>(ty);
+    auto const *cat = cast<ConstantArrayType>(ty);
     result = getConstantArrayType(
-                 getVariableArrayDecayedType(cat->getElementType()),
-                                  cat->getSize(),
-                                  cat->getSizeExpr(),
-                                  cat->getSizeModifier(),
-                                  cat->getIndexTypeCVRQualifiers());
+        getVariableArrayDecayedType(cat->getElementType()), cat->getSize(),
+        cat->getSizeExpr(), cat->getSizeModifier(),
+        cat->getIndexTypeCVRQualifiers());
     break;
   }
 
   case Type::DependentSizedArray: {
-    const auto *dat = cast<DependentSizedArrayType>(ty);
+    auto const *dat = cast<DependentSizedArrayType>(ty);
     result = getDependentSizedArrayType(
-                 getVariableArrayDecayedType(dat->getElementType()),
-                                        dat->getSizeExpr(),
-                                        dat->getSizeModifier(),
-                                        dat->getIndexTypeCVRQualifiers(),
-                                        dat->getBracketsRange());
+        getVariableArrayDecayedType(dat->getElementType()), dat->getSizeExpr(),
+        dat->getSizeModifier(), dat->getIndexTypeCVRQualifiers(),
+        dat->getBracketsRange());
     break;
   }
 
   // Turn incomplete types into [*] types.
   case Type::IncompleteArray: {
-    const auto *iat = cast<IncompleteArrayType>(ty);
-    result = getVariableArrayType(
-                 getVariableArrayDecayedType(iat->getElementType()),
-                                  /*size*/ nullptr,
-                                  ArrayType::Normal,
-                                  iat->getIndexTypeCVRQualifiers(),
-                                  SourceRange());
+    auto const *iat = cast<IncompleteArrayType>(ty);
+    result =
+        getVariableArrayType(getVariableArrayDecayedType(iat->getElementType()),
+                             /*size*/ nullptr, ArrayType::Normal,
+                             iat->getIndexTypeCVRQualifiers(), SourceRange());
     break;
   }
 
   // Turn VLA types into [*] types.
   case Type::VariableArray: {
-    const auto *vat = cast<VariableArrayType>(ty);
+    auto const *vat = cast<VariableArrayType>(ty);
     result = getVariableArrayType(
-                 getVariableArrayDecayedType(vat->getElementType()),
-                                  /*size*/ nullptr,
-                                  ArrayType::Star,
-                                  vat->getIndexTypeCVRQualifiers(),
-                                  vat->getBracketsRange());
+        getVariableArrayDecayedType(vat->getElementType()),
+        /*size*/ nullptr, ArrayType::Star, vat->getIndexTypeCVRQualifiers(),
+        vat->getBracketsRange());
     break;
   }
   }
@@ -3667,8 +3637,7 @@
 
 /// getVariableArrayType - Returns a non-unique reference to the type for a
 /// variable array of the specified element type.
-QualType ASTContext::getVariableArrayType(QualType EltTy,
-                                          Expr *NumElts,
+QualType ASTContext::getVariableArrayType(QualType EltTy, Expr *NumElts,
                                           ArrayType::ArraySizeModifier ASM,
                                           unsigned IndexTypeQuals,
                                           SourceRange Brackets) const {
@@ -3685,7 +3654,7 @@
   }
 
   auto *New = new (*this, TypeAlignment)
-    VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);
+      VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);
 
   VariableArrayTypes.push_back(New);
   Types.push_back(New);
@@ -3695,11 +3664,9 @@
 /// getDependentSizedArrayType - Returns a non-unique reference to
 /// the type for a dependently-sized array of the specified element
 /// type.
-QualType ASTContext::getDependentSizedArrayType(QualType elementType,
-                                                Expr *numElements,
-                                                ArrayType::ArraySizeModifier ASM,
-                                                unsigned elementTypeQuals,
-                                                SourceRange brackets) const {
+QualType ASTContext::getDependentSizedArrayType(
+    QualType elementType, Expr *numElements, ArrayType::ArraySizeModifier ASM,
+    unsigned elementTypeQuals, SourceRange brackets) const {
   assert((!numElements || numElements->isTypeDependent() ||
           numElements->isValueDependent()) &&
          "Size must be type- or value-dependent!");
@@ -3709,11 +3676,9 @@
   // initializer.  We do no canonicalization here at all, which is okay
   // because they can't be used in most locations.
   if (!numElements) {
-    auto *newType
-      = new (*this, TypeAlignment)
-          DependentSizedArrayType(*this, elementType, QualType(),
-                                  numElements, ASM, elementTypeQuals,
-                                  brackets);
+    auto *newType = new (*this, TypeAlignment)
+        DependentSizedArrayType(*this, elementType, QualType(), numElements,
+                                ASM, elementTypeQuals, brackets);
     Types.push_back(newType);
     return QualType(newType, 0);
   }
@@ -3725,27 +3690,25 @@
 
   void *insertPos = nullptr;
   llvm::FoldingSetNodeID ID;
-  DependentSizedArrayType::Profile(ID, *this,
-                                   QualType(canonElementType.Ty, 0),
+  DependentSizedArrayType::Profile(ID, *this, QualType(canonElementType.Ty, 0),
                                    ASM, elementTypeQuals, numElements);
 
   // Look for an existing type with these properties.
   DependentSizedArrayType *canonTy =
-    DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
+      DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
 
   // If we don't have one, build one.
   if (!canonTy) {
-    canonTy = new (*this, TypeAlignment)
-      DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0),
-                              QualType(), numElements, ASM, elementTypeQuals,
-                              brackets);
+    canonTy = new (*this, TypeAlignment) DependentSizedArrayType(
+        *this, QualType(canonElementType.Ty, 0), QualType(), numElements, ASM,
+        elementTypeQuals, brackets);
     DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
     Types.push_back(canonTy);
   }
 
   // Apply qualifiers from the element type to the array.
-  QualType canon = getQualifiedType(QualType(canonTy,0),
-                                    canonElementType.Quals);
+  QualType canon =
+      getQualifiedType(QualType(canonTy, 0), canonElementType.Quals);
 
   // If we didn't need extra canonicalization for the element type or the size
   // expression, then just use that as our result.
@@ -3755,10 +3718,8 @@
 
   // Otherwise, we need to build a type which follows the spelling
   // of the element type.
-  auto *sugaredType
-    = new (*this, TypeAlignment)
-        DependentSizedArrayType(*this, elementType, canon, numElements,
-                                ASM, elementTypeQuals, brackets);
+  auto *sugaredType = new (*this, TypeAlignment) DependentSizedArrayType(
+      *this, elementType, canon, numElements, ASM, elementTypeQuals, brackets);
   Types.push_back(sugaredType);
   return QualType(sugaredType, 0);
 }
@@ -3771,7 +3732,7 @@
 
   void *insertPos = nullptr;
   if (IncompleteArrayType *iat =
-       IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
+          IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
     return QualType(iat, 0);
 
   // If the element type isn't canonical, this won't be a canonical type
@@ -3781,18 +3742,19 @@
 
   if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) {
     SplitQualType canonSplit = getCanonicalType(elementType).split();
-    canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0),
-                                   ASM, elementTypeQuals);
+    canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0), ASM,
+                                   elementTypeQuals);
     canon = getQualifiedType(canon, canonSplit.Quals);
 
     // Get the new insert position for the node we care about.
     IncompleteArrayType *existing =
-      IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
-    assert(!existing && "Shouldn't be in the map!"); (void) existing;
+        IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
+    assert(!existing && "Shouldn't be in the map!");
+    (void)existing;
   }
 
   auto *newType = new (*this, TypeAlignment)
-    IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);
+      IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);
 
   IncompleteArrayTypes.InsertNode(newType, insertPos);
   Types.push_back(newType);
@@ -3800,7 +3762,7 @@
 }
 
 ASTContext::BuiltinVectorTypeInfo
-ASTContext::getBuiltinVectorTypeInfo(const BuiltinType *Ty) const {
+ASTContext::getBuiltinVectorTypeInfo(BuiltinType const *Ty) const {
 #define SVE_INT_ELTTY(BITS, ELTS, SIGNED, NUMVECTORS)                          \
   {getIntTypeForBitwidth(BITS, SIGNED), llvm::ElementCount::getScalable(ELTS), \
    NUMVECTORS};
@@ -3952,15 +3914,15 @@
     uint64_t EltTySize = getTypeSize(EltTy);
 #define RVV_VECTOR_TYPE(Name, Id, SingletonId, NumEls, ElBits, NF, IsSigned,   \
                         IsFP)                                                  \
-    if (!EltTy->isBooleanType() &&                                             \
-        ((EltTy->hasIntegerRepresentation() &&                                 \
-          EltTy->hasSignedIntegerRepresentation() == IsSigned) ||              \
-         (EltTy->hasFloatingRepresentation() && IsFP)) &&                      \
-        EltTySize == ElBits && NumElts == NumEls)                              \
-      return SingletonId;
+  if (!EltTy->isBooleanType() &&                                               \
+      ((EltTy->hasIntegerRepresentation() &&                                   \
+        EltTy->hasSignedIntegerRepresentation() == IsSigned) ||                \
+       (EltTy->hasFloatingRepresentation() && IsFP)) &&                        \
+      EltTySize == ElBits && NumElts == NumEls)                                \
+    return SingletonId;
 #define RVV_PREDICATE_TYPE(Name, Id, SingletonId, NumEls)                      \
-    if (EltTy->isBooleanType() && NumElts == NumEls)                           \
-      return SingletonId;
+  if (EltTy->isBooleanType() && NumElts == NumEls)                             \
+    return SingletonId;
 #include "clang/Basic/RISCVVTypes.def"
   }
   return QualType();
@@ -3988,10 +3950,11 @@
 
     // Get the new insert position for the node we care about.
     VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
   auto *New = new (*this, TypeAlignment)
-    VectorType(vecType, NumElts, Canonical, VecKind);
+      VectorType(vecType, NumElts, Canonical, VecKind);
   VectorTypes.InsertNode(New, InsertPos);
   Types.push_back(New);
   return QualType(New, 0);
@@ -4038,8 +4001,8 @@
 
 /// getExtVectorType - Return the unique reference to an extended vector type of
 /// the specified element type and size. VectorType must be a built-in type.
-QualType
-ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const {
+QualType ASTContext::getExtVectorType(QualType vecType,
+                                      unsigned NumElts) const {
   assert(vecType->isBuiltinType() || vecType->isDependentType());
 
   // Check if we've already instantiated a vector of this type.
@@ -4058,42 +4021,40 @@
 
     // Get the new insert position for the node we care about.
     VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
-  auto *New = new (*this, TypeAlignment)
-    ExtVectorType(vecType, NumElts, Canonical);
+  auto *New =
+      new (*this, TypeAlignment) ExtVectorType(vecType, NumElts, Canonical);
   VectorTypes.InsertNode(New, InsertPos);
   Types.push_back(New);
   return QualType(New, 0);
 }
 
 QualType
-ASTContext::getDependentSizedExtVectorType(QualType vecType,
-                                           Expr *SizeExpr,
+ASTContext::getDependentSizedExtVectorType(QualType vecType, Expr *SizeExpr,
                                            SourceLocation AttrLoc) const {
   llvm::FoldingSetNodeID ID;
   DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType),
                                        SizeExpr);
 
   void *InsertPos = nullptr;
-  DependentSizedExtVectorType *Canon
-    = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
+  DependentSizedExtVectorType *Canon =
+      DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
   DependentSizedExtVectorType *New;
   if (Canon) {
     // We already have a canonical version of this array type; use it as
     // the canonical type for a newly-built type.
-    New = new (*this, TypeAlignment)
-      DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
-                                  SizeExpr, AttrLoc);
+    New = new (*this, TypeAlignment) DependentSizedExtVectorType(
+        *this, vecType, QualType(Canon, 0), SizeExpr, AttrLoc);
   } else {
     QualType CanonVecTy = getCanonicalType(vecType);
     if (CanonVecTy == vecType) {
-      New = new (*this, TypeAlignment)
-        DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
-                                    AttrLoc);
+      New = new (*this, TypeAlignment) DependentSizedExtVectorType(
+          *this, vecType, QualType(), SizeExpr, AttrLoc);
 
-      DependentSizedExtVectorType *CanonCheck
-        = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
+      DependentSizedExtVectorType *CanonCheck =
+          DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
       assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken");
       (void)CanonCheck;
       DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
@@ -4181,9 +4142,8 @@
   return QualType(New, 0);
 }
 
-QualType ASTContext::getDependentAddressSpaceType(QualType PointeeType,
-                                                  Expr *AddrSpaceExpr,
-                                                  SourceLocation AttrLoc) const {
+QualType ASTContext::getDependentAddressSpaceType(
+    QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const {
   assert(AddrSpaceExpr->isInstantiationDependent());
 
   QualType canonPointeeType = getCanonicalType(PointeeType);
@@ -4194,12 +4154,11 @@
                                      AddrSpaceExpr);
 
   DependentAddressSpaceType *canonTy =
-    DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
+      DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
 
   if (!canonTy) {
-    canonTy = new (*this, TypeAlignment)
-      DependentAddressSpaceType(*this, canonPointeeType,
-                                QualType(), AddrSpaceExpr, AttrLoc);
+    canonTy = new (*this, TypeAlignment) DependentAddressSpaceType(
+        *this, canonPointeeType, QualType(), AddrSpaceExpr, AttrLoc);
     DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
     Types.push_back(canonTy);
   }
@@ -4208,10 +4167,8 @@
       canonTy->getAddrSpaceExpr() == AddrSpaceExpr)
     return QualType(canonTy, 0);
 
-  auto *sugaredType
-    = new (*this, TypeAlignment)
-        DependentAddressSpaceType(*this, PointeeType, QualType(canonTy, 0),
-                                  AddrSpaceExpr, AttrLoc);
+  auto *sugaredType = new (*this, TypeAlignment) DependentAddressSpaceType(
+      *this, PointeeType, QualType(canonTy, 0), AddrSpaceExpr, AttrLoc);
   Types.push_back(sugaredType);
   return QualType(sugaredType, 0);
 }
@@ -4226,7 +4183,7 @@
 /// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
 QualType
 ASTContext::getFunctionNoProtoType(QualType ResultTy,
-                                   const FunctionType::ExtInfo &Info) const {
+                                   FunctionType::ExtInfo const &Info) const {
   // Unique functions, to guarantee there is only one function of a particular
   // structure.
   llvm::FoldingSetNodeID ID;
@@ -4234,22 +4191,23 @@
 
   void *InsertPos = nullptr;
   if (FunctionNoProtoType *FT =
-        FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
+          FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(FT, 0);
 
   QualType Canonical;
   if (!isCanonicalResultType(ResultTy)) {
     Canonical =
-      getFunctionNoProtoType(getCanonicalFunctionResultType(ResultTy), Info);
+        getFunctionNoProtoType(getCanonicalFunctionResultType(ResultTy), Info);
 
     // Get the new insert position for the node we care about.
     FunctionNoProtoType *NewIP =
-      FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+        FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
 
-  auto *New = new (*this, TypeAlignment)
-    FunctionNoProtoType(ResultTy, Canonical, Info);
+  auto *New =
+      new (*this, TypeAlignment) FunctionNoProtoType(ResultTy, Canonical, Info);
   Types.push_back(New);
   FunctionNoProtoTypes.InsertNode(New, InsertPos);
   return QualType(New, 0);
@@ -4264,14 +4222,14 @@
     Qualifiers Qs = CanResultType.getQualifiers();
     Qs.removeObjCLifetime();
     return CanQualType::CreateUnsafe(
-             getQualifiedType(CanResultType.getUnqualifiedType(), Qs));
+        getQualifiedType(CanResultType.getUnqualifiedType(), Qs));
   }
 
   return CanResultType;
 }
 
 static bool isCanonicalExceptionSpecification(
-    const FunctionProtoType::ExceptionSpecInfo &ESI, bool NoexceptInType) {
+    FunctionProtoType::ExceptionSpecInfo const &ESI, bool NoexceptInType) {
   if (ESI.Type == EST_None)
     return true;
   if (!NoexceptInType)
@@ -4306,7 +4264,7 @@
 
 QualType ASTContext::getFunctionTypeInternal(
     QualType ResultTy, ArrayRef<QualType> ArgArray,
-    const FunctionProtoType::ExtProtoInfo &EPI, bool OnlyWantCanonical) const {
+    FunctionProtoType::ExtProtoInfo const &EPI, bool OnlyWantCanonical) const {
   size_t NumArgs = ArgArray.size();
 
   // Unique functions, to guarantee there is only one function of a particular
@@ -4320,7 +4278,7 @@
 
   void *InsertPos = nullptr;
   if (FunctionProtoType *FPT =
-        FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
+          FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
     QualType Existing = QualType(FPT, 0);
 
     // If we find a pre-existing equivalent FunctionProtoType, we can just reuse
@@ -4371,11 +4329,15 @@
       // Exception spec is already OK.
     } else if (NoexceptInType) {
       switch (EPI.ExceptionSpec.Type) {
-      case EST_Unparsed: case EST_Unevaluated: case EST_Uninstantiated:
+      case EST_Unparsed:
+      case EST_Unevaluated:
+      case EST_Uninstantiated:
         // We don't know yet. It shouldn't matter what we pick here; no-one
         // should ever look at this.
         LLVM_FALLTHROUGH;
-      case EST_None: case EST_MSAny: case EST_NoexceptFalse:
+      case EST_None:
+      case EST_MSAny:
+      case EST_NoexceptFalse:
         CanonicalEPI.ExceptionSpec.Type = EST_None;
         break;
 
@@ -4418,8 +4380,9 @@
 
     // Get the new insert position for the node we care about.
     FunctionProtoType *NewIP =
-      FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+        FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
 
   // Compute the needed size to hold this FunctionProtoType and the
@@ -4518,9 +4481,10 @@
 }
 
 #ifndef NDEBUG
-static bool NeedsInjectedClassNameType(const RecordDecl *D) {
-  if (!isa<CXXRecordDecl>(D)) return false;
-  const auto *RD = cast<CXXRecordDecl>(D);
+static bool NeedsInjectedClassNameType(RecordDecl const *D) {
+  if (!isa<CXXRecordDecl>(D))
+    return false;
+  auto const *RD = cast<CXXRecordDecl>(D);
   if (isa<ClassTemplatePartialSpecializationDecl>(RD))
     return true;
   if (RD->getDescribedClassTemplate() &&
@@ -4542,8 +4506,7 @@
     Decl->TypeForDecl = PrevDecl->TypeForDecl;
     assert(isa<InjectedClassNameType>(Decl->TypeForDecl));
   } else {
-    Type *newType =
-      new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
+    Type *newType = new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
     Decl->TypeForDecl = newType;
     Types.push_back(newType);
   }
@@ -4552,24 +4515,24 @@
 
 /// getTypeDeclType - Return the unique reference to the type for the
 /// specified type declaration.
-QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const {
+QualType ASTContext::getTypeDeclTypeSlow(TypeDecl const *Decl) const {
   assert(Decl && "Passed null for Decl param");
   assert(!Decl->TypeForDecl && "TypeForDecl present in slow case");
 
-  if (const auto *Typedef = dyn_cast<TypedefNameDecl>(Decl))
+  if (auto const *Typedef = dyn_cast<TypedefNameDecl>(Decl))
     return getTypedefType(Typedef);
 
   assert(!isa<TemplateTypeParmDecl>(Decl) &&
          "Template type parameter types are always available.");
 
-  if (const auto *Record = dyn_cast<RecordDecl>(Decl)) {
+  if (auto const *Record = dyn_cast<RecordDecl>(Decl)) {
     assert(Record->isFirstDecl() && "struct/union has previous declaration");
     assert(!NeedsInjectedClassNameType(Record));
     return getRecordType(Record);
-  } else if (const auto *Enum = dyn_cast<EnumDecl>(Decl)) {
+  } else if (auto const *Enum = dyn_cast<EnumDecl>(Decl)) {
     assert(Enum->isFirstDecl() && "enum has previous declaration");
     return getEnumType(Enum);
-  } else if (const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
+  } else if (auto const *Using = dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
     Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using);
     Decl->TypeForDecl = newType;
     Types.push_back(newType);
@@ -4581,9 +4544,10 @@
 
 /// getTypedefType - Return the unique reference to the type for the
 /// specified typedef name decl.
-QualType ASTContext::getTypedefType(const TypedefNameDecl *Decl,
+QualType ASTContext::getTypedefType(TypedefNameDecl const *Decl,
                                     QualType Underlying) const {
-  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
+  if (Decl->TypeForDecl)
+    return QualType(Decl->TypeForDecl, 0);
 
   if (Underlying.isNull())
     Underlying = Decl->getUnderlyingType();
@@ -4595,10 +4559,11 @@
   return QualType(newType, 0);
 }
 
-QualType ASTContext::getRecordType(const RecordDecl *Decl) const {
-  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
+QualType ASTContext::getRecordType(RecordDecl const *Decl) const {
+  if (Decl->TypeForDecl)
+    return QualType(Decl->TypeForDecl, 0);
 
-  if (const RecordDecl *PrevDecl = Decl->getPreviousDecl())
+  if (RecordDecl const *PrevDecl = Decl->getPreviousDecl())
     if (PrevDecl->TypeForDecl)
       return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
 
@@ -4608,10 +4573,11 @@
   return QualType(newType, 0);
 }
 
-QualType ASTContext::getEnumType(const EnumDecl *Decl) const {
-  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
+QualType ASTContext::getEnumType(EnumDecl const *Decl) const {
+  if (Decl->TypeForDecl)
+    return QualType(Decl->TypeForDecl, 0);
 
-  if (const EnumDecl *PrevDecl = Decl->getPreviousDecl())
+  if (EnumDecl const *PrevDecl = Decl->getPreviousDecl())
     if (PrevDecl->TypeForDecl)
       return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
 
@@ -4629,7 +4595,8 @@
 
   void *insertPos = nullptr;
   AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos);
-  if (type) return QualType(type, 0);
+  if (type)
+    return QualType(type, 0);
 
   QualType canon = getCanonicalType(equivalentType);
   type = new (*this, TypeAlignment)
@@ -4643,20 +4610,20 @@
 
 /// Retrieve a substitution-result type.
 QualType
-ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
+ASTContext::getSubstTemplateTypeParmType(TemplateTypeParmType const *Parm,
                                          QualType Replacement) const {
-  assert(Replacement.isCanonical()
-         && "replacement types must always be canonical");
+  assert(Replacement.isCanonical() &&
+         "replacement types must always be canonical");
 
   llvm::FoldingSetNodeID ID;
   SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
   void *InsertPos = nullptr;
-  SubstTemplateTypeParmType *SubstParm
-    = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
+  SubstTemplateTypeParmType *SubstParm =
+      SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!SubstParm) {
-    SubstParm = new (*this, TypeAlignment)
-      SubstTemplateTypeParmType(Parm, Replacement);
+    SubstParm =
+        new (*this, TypeAlignment) SubstTemplateTypeParmType(Parm, Replacement);
     Types.push_back(SubstParm);
     SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
   }
@@ -4665,12 +4632,12 @@
 }
 
 /// Retrieve a
-QualType ASTContext::getSubstTemplateTypeParmPackType(
-                                          const TemplateTypeParmType *Parm,
-                                              const TemplateArgument &ArgPack) {
+QualType
+ASTContext::getSubstTemplateTypeParmPackType(TemplateTypeParmType const *Parm,
+                                             TemplateArgument const &ArgPack) {
 #ifndef NDEBUG
-  for (const auto &P : ArgPack.pack_elements()) {
-    assert(P.getKind() == TemplateArgument::Type &&"Pack contains a non-type");
+  for (auto const &P : ArgPack.pack_elements()) {
+    assert(P.getKind() == TemplateArgument::Type && "Pack contains a non-type");
     assert(P.getAsType().isCanonical() && "Pack contains non-canonical type");
   }
 #endif
@@ -4678,8 +4645,8 @@
   llvm::FoldingSetNodeID ID;
   SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack);
   void *InsertPos = nullptr;
-  if (SubstTemplateTypeParmPackType *SubstParm
-        = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
+  if (SubstTemplateTypeParmPackType *SubstParm =
+          SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(SubstParm, 0);
 
   QualType Canon;
@@ -4690,9 +4657,8 @@
     SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
   }
 
-  auto *SubstParm
-    = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon,
-                                                               ArgPack);
+  auto *SubstParm = new (*this, TypeAlignment)
+      SubstTemplateTypeParmPackType(Parm, Canon, ArgPack);
   Types.push_back(SubstParm);
   SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
   return QualType(SubstParm, 0);
@@ -4701,14 +4667,15 @@
 /// Retrieve the template type parameter type for a template
 /// parameter or parameter pack with the given depth, index, and (optionally)
 /// name.
-QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
-                                             bool ParameterPack,
-                                             TemplateTypeParmDecl *TTPDecl) const {
+QualType
+ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
+                                    bool ParameterPack,
+                                    TemplateTypeParmDecl *TTPDecl) const {
   llvm::FoldingSetNodeID ID;
   TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
   void *InsertPos = nullptr;
-  TemplateTypeParmType *TypeParm
-    = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
+  TemplateTypeParmType *TypeParm =
+      TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
 
   if (TypeParm)
     return QualType(TypeParm, 0);
@@ -4717,13 +4684,13 @@
     QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
     TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon);
 
-    TemplateTypeParmType *TypeCheck
-      = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
+    TemplateTypeParmType *TypeCheck =
+        TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(!TypeCheck && "Template type parameter canonical type broken");
     (void)TypeCheck;
   } else
     TypeParm = new (*this, TypeAlignment)
-      TemplateTypeParmType(Depth, Index, ParameterPack);
+        TemplateTypeParmType(Depth, Index, ParameterPack);
 
   Types.push_back(TypeParm);
   TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
@@ -4731,11 +4698,9 @@
   return QualType(TypeParm, 0);
 }
 
-TypeSourceInfo *
-ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name,
-                                              SourceLocation NameLoc,
-                                        const TemplateArgumentListInfo &Args,
-                                              QualType Underlying) const {
+TypeSourceInfo *ASTContext::getTemplateSpecializationTypeInfo(
+    TemplateName Name, SourceLocation NameLoc,
+    TemplateArgumentListInfo const &Args, QualType Underlying) const {
   assert(!Name.getAsDependentTemplateName() &&
          "No dependent template names here!");
   QualType TST = getTemplateSpecializationType(Name, Args, Underlying);
@@ -4754,14 +4719,14 @@
 
 QualType
 ASTContext::getTemplateSpecializationType(TemplateName Template,
-                                          const TemplateArgumentListInfo &Args,
+                                          TemplateArgumentListInfo const &Args,
                                           QualType Underlying) const {
   assert(!Template.getAsDependentTemplateName() &&
          "No dependent template names here!");
 
   SmallVector<TemplateArgument, 4> ArgVec;
   ArgVec.reserve(Args.size());
-  for (const TemplateArgumentLoc &Arg : Args.arguments())
+  for (TemplateArgumentLoc const &Arg : Args.arguments())
     ArgVec.push_back(Arg.getArgument());
 
   return getTemplateSpecializationType(Template, ArgVec, Underlying);
@@ -4769,7 +4734,7 @@
 
 #ifndef NDEBUG
 static bool hasAnyPackExpansions(ArrayRef<TemplateArgument> Args) {
-  for (const TemplateArgument &Arg : Args)
+  for (TemplateArgument const &Arg : Args)
     if (Arg.isPackExpansion())
       return true;
 
@@ -4787,9 +4752,8 @@
   if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
     Template = TemplateName(QTN->getTemplateDecl());
 
-  bool IsTypeAlias =
-    Template.getAsTemplateDecl() &&
-    isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
+  bool IsTypeAlias = Template.getAsTemplateDecl() &&
+                     isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
   QualType CanonType;
   if (!Underlying.isNull())
     CanonType = getCanonicalType(Underlying);
@@ -4806,12 +4770,11 @@
   // try to unique it: these types typically have location information that
   // we don't unique and don't want to lose.
   void *Mem = Allocate(sizeof(TemplateSpecializationType) +
-                       sizeof(TemplateArgument) * Args.size() +
-                       (IsTypeAlias? sizeof(QualType) : 0),
+                           sizeof(TemplateArgument) * Args.size() +
+                           (IsTypeAlias ? sizeof(QualType) : 0),
                        TypeAlignment);
-  auto *Spec
-    = new (Mem) TemplateSpecializationType(Template, Args, CanonType,
-                                         IsTypeAlias ? Underlying : QualType());
+  auto *Spec = new (Mem) TemplateSpecializationType(
+      Template, Args, CanonType, IsTypeAlias ? Underlying : QualType());
 
   Types.push_back(Spec);
   return QualType(Spec, 0);
@@ -4831,26 +4794,24 @@
   SmallVector<TemplateArgument, 4> CanonArgs;
   unsigned NumArgs = Args.size();
   CanonArgs.reserve(NumArgs);
-  for (const TemplateArgument &Arg : Args)
+  for (TemplateArgument const &Arg : Args)
     CanonArgs.push_back(getCanonicalTemplateArgument(Arg));
 
   // Determine whether this canonical template specialization type already
   // exists.
   llvm::FoldingSetNodeID ID;
-  TemplateSpecializationType::Profile(ID, CanonTemplate,
-                                      CanonArgs, *this);
+  TemplateSpecializationType::Profile(ID, CanonTemplate, CanonArgs, *this);
 
   void *InsertPos = nullptr;
-  TemplateSpecializationType *Spec
-    = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
+  TemplateSpecializationType *Spec =
+      TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!Spec) {
     // Allocate a new canonical template specialization type.
     void *Mem = Allocate((sizeof(TemplateSpecializationType) +
                           sizeof(TemplateArgument) * NumArgs),
                          TypeAlignment);
-    Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
-                                                CanonArgs,
+    Spec = new (Mem) TemplateSpecializationType(CanonTemplate, CanonArgs,
                                                 QualType(), QualType());
     Types.push_back(Spec);
     TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
@@ -4881,8 +4842,9 @@
     (void)CheckT;
   }
 
-  void *Mem = Allocate(ElaboratedType::totalSizeToAlloc<TagDecl *>(!!OwnedTagDecl),
-                       TypeAlignment);
+  void *Mem =
+      Allocate(ElaboratedType::totalSizeToAlloc<TagDecl *>(!!OwnedTagDecl),
+               TypeAlignment);
   T = new (Mem) ElaboratedType(Keyword, NNS, NamedType, Canon, OwnedTagDecl);
 
   Types.push_back(T);
@@ -4890,8 +4852,7 @@
   return QualType(T, 0);
 }
 
-QualType
-ASTContext::getParenType(QualType InnerType) const {
+QualType ASTContext::getParenType(QualType InnerType) const {
   llvm::FoldingSetNodeID ID;
   ParenType::Profile(ID, InnerType);
 
@@ -4916,7 +4877,7 @@
 
 QualType
 ASTContext::getMacroQualifiedType(QualType UnderlyingTy,
-                                  const IdentifierInfo *MacroII) const {
+                                  IdentifierInfo const *MacroII) const {
   QualType Canon = UnderlyingTy;
   if (!Canon.isCanonical())
     Canon = getCanonicalType(UnderlyingTy);
@@ -4929,7 +4890,7 @@
 
 QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
                                           NestedNameSpecifier *NNS,
-                                          const IdentifierInfo *Name,
+                                          IdentifierInfo const *Name,
                                           QualType Canon) const {
   if (Canon.isNull()) {
     NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
@@ -4941,8 +4902,7 @@
   DependentNameType::Profile(ID, Keyword, NNS, Name);
 
   void *InsertPos = nullptr;
-  DependentNameType *T
-    = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
+  DependentNameType *T = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
   if (T)
     return QualType(T, 0);
 
@@ -4952,12 +4912,9 @@
   return QualType(T, 0);
 }
 
-QualType
-ASTContext::getDependentTemplateSpecializationType(
-                                 ElaboratedTypeKeyword Keyword,
-                                 NestedNameSpecifier *NNS,
-                                 const IdentifierInfo *Name,
-                                 const TemplateArgumentListInfo &Args) const {
+QualType ASTContext::getDependentTemplateSpecializationType(
+    ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
+    IdentifierInfo const *Name, TemplateArgumentListInfo const &Args) const {
   // TODO: avoid this copy
   SmallVector<TemplateArgument, 16> ArgCopy;
   for (unsigned I = 0, E = Args.size(); I != E; ++I)
@@ -4965,29 +4922,27 @@
   return getDependentTemplateSpecializationType(Keyword, NNS, Name, ArgCopy);
 }
 
-QualType
-ASTContext::getDependentTemplateSpecializationType(
-                                 ElaboratedTypeKeyword Keyword,
-                                 NestedNameSpecifier *NNS,
-                                 const IdentifierInfo *Name,
-                                 ArrayRef<TemplateArgument> Args) const {
+QualType ASTContext::getDependentTemplateSpecializationType(
+    ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
+    IdentifierInfo const *Name, ArrayRef<TemplateArgument> Args) const {
   assert((!NNS || NNS->isDependent()) &&
          "nested-name-specifier must be dependent");
 
   llvm::FoldingSetNodeID ID;
-  DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
-                                               Name, Args);
+  DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS, Name,
+                                               Args);
 
   void *InsertPos = nullptr;
-  DependentTemplateSpecializationType *T
-    = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
+  DependentTemplateSpecializationType *T =
+      DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
   if (T)
     return QualType(T, 0);
 
   NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
 
   ElaboratedTypeKeyword CanonKeyword = Keyword;
-  if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
+  if (Keyword == ETK_None)
+    CanonKeyword = ETK_Typename;
 
   bool AnyNonCanonArgs = false;
   unsigned NumArgs = Args.size();
@@ -5000,8 +4955,7 @@
 
   QualType Canon;
   if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
-    Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
-                                                   Name,
+    Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS, Name,
                                                    CanonArgs);
 
     // Find the insert position again.
@@ -5011,8 +4965,8 @@
   void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
                         sizeof(TemplateArgument) * NumArgs),
                        TypeAlignment);
-  T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
-                                                    Name, Args, Canon);
+  T = new (Mem)
+      DependentTemplateSpecializationType(Keyword, NNS, Name, Args, Canon);
   Types.push_back(T);
   DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
   return QualType(T, 0);
@@ -5020,7 +4974,7 @@
 
 TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) {
   TemplateArgument Arg;
-  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
+  if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
     QualType ArgType = getTypeDeclType(TTP);
     if (TTP->isParameterPack())
       ArgType = getPackExpansionType(ArgType, None);
@@ -5040,8 +4994,8 @@
         Expr::getValueKindForType(NTTP->getType()), NTTP->getLocation());
 
     if (NTTP->isParameterPack())
-      E = new (*this) PackExpansionExpr(DependentTy, E, NTTP->getLocation(),
-                                        None);
+      E = new (*this)
+          PackExpansionExpr(DependentTy, E, NTTP->getLocation(), None);
     Arg = TemplateArgument(E);
   } else {
     auto *TTP = cast<TemplateTemplateParmDecl>(Param);
@@ -5057,9 +5011,9 @@
   return Arg;
 }
 
-void
-ASTContext::getInjectedTemplateArgs(const TemplateParameterList *Params,
-                                    SmallVectorImpl<TemplateArgument> &Args) {
+void ASTContext::getInjectedTemplateArgs(
+    TemplateParameterList const *Params,
+    SmallVectorImpl<TemplateArgument> &Args) {
   Args.reserve(Args.size() + Params->size());
 
   for (NamedDecl *Param : *Params)
@@ -5105,7 +5059,8 @@
 }
 
 static bool areSortedAndUniqued(ArrayRef<ObjCProtocolDecl *> Protocols) {
-  if (Protocols.empty()) return true;
+  if (Protocols.empty())
+    return true;
 
   if (Protocols[0]->getCanonicalDecl() != Protocols[0])
     return false;
@@ -5132,18 +5087,17 @@
 }
 
 QualType ASTContext::getObjCObjectType(QualType BaseType,
-                                       ObjCProtocolDecl * const *Protocols,
+                                       ObjCProtocolDecl *const *Protocols,
                                        unsigned NumProtocols) const {
   return getObjCObjectType(BaseType, {},
                            llvm::makeArrayRef(Protocols, NumProtocols),
                            /*isKindOf=*/false);
 }
 
-QualType ASTContext::getObjCObjectType(
-           QualType baseType,
-           ArrayRef<QualType> typeArgs,
-           ArrayRef<ObjCProtocolDecl *> protocols,
-           bool isKindOf) const {
+QualType ASTContext::getObjCObjectType(QualType baseType,
+                                       ArrayRef<QualType> typeArgs,
+                                       ArrayRef<ObjCProtocolDecl *> protocols,
+                                       bool isKindOf) const {
   // If the base type is an interface and there aren't any protocols or
   // type arguments to add, then the interface type will do just fine.
   if (typeArgs.empty() && protocols.empty() && !isKindOf &&
@@ -5162,7 +5116,7 @@
   // type.
   ArrayRef<QualType> effectiveTypeArgs = typeArgs;
   if (effectiveTypeArgs.empty()) {
-    if (const auto *baseObject = baseType->getAs<ObjCObjectType>())
+    if (auto const *baseObject = baseType->getAs<ObjCObjectType>())
       effectiveTypeArgs = baseObject->getTypeArgs();
   }
 
@@ -5170,11 +5124,9 @@
   // sorted-and-uniqued list of protocols and the type arguments
   // canonicalized.
   QualType canonical;
-  bool typeArgsAreCanonical = std::all_of(effectiveTypeArgs.begin(),
-                                          effectiveTypeArgs.end(),
-                                          [&](QualType type) {
-                                            return type.isCanonical();
-                                          });
+  bool typeArgsAreCanonical =
+      std::all_of(effectiveTypeArgs.begin(), effectiveTypeArgs.end(),
+                  [&](QualType type) { return type.isCanonical(); });
   bool protocolsSorted = areSortedAndUniqued(protocols);
   if (!typeArgsAreCanonical || !protocolsSorted || !baseType.isCanonical()) {
     // Determine the canonical type arguments.
@@ -5190,7 +5142,7 @@
     }
 
     ArrayRef<ObjCProtocolDecl *> canonProtocols;
-    SmallVector<ObjCProtocolDecl*, 8> canonProtocolsVec;
+    SmallVector<ObjCProtocolDecl *, 8> canonProtocolsVec;
     if (!protocolsSorted) {
       canonProtocolsVec.append(protocols.begin(), protocols.end());
       SortAndUniqueProtocols(canonProtocolsVec);
@@ -5210,9 +5162,8 @@
   size += typeArgs.size() * sizeof(QualType);
   size += protocols.size() * sizeof(ObjCProtocolDecl *);
   void *mem = Allocate(size, TypeAlignment);
-  auto *T =
-    new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
-                                 isKindOf);
+  auto *T = new (mem)
+      ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols, isKindOf);
 
   Types.push_back(T);
   ObjCObjectTypes.InsertNode(T, InsertPos);
@@ -5222,45 +5173,39 @@
 /// Apply Objective-C protocol qualifiers to the given type.
 /// If this is for the canonical type of a type parameter, we can apply
 /// protocol qualifiers on the ObjCObjectPointerType.
-QualType
-ASTContext::applyObjCProtocolQualifiers(QualType type,
-                  ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
-                  bool allowOnPointerType) const {
+QualType ASTContext::applyObjCProtocolQualifiers(
+    QualType type, ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
+    bool allowOnPointerType) const {
   hasError = false;
 
-  if (const auto *objT = dyn_cast<ObjCTypeParamType>(type.getTypePtr())) {
+  if (auto const *objT = dyn_cast<ObjCTypeParamType>(type.getTypePtr())) {
     return getObjCTypeParamType(objT->getDecl(), protocols);
   }
 
   // Apply protocol qualifiers to ObjCObjectPointerType.
   if (allowOnPointerType) {
-    if (const auto *objPtr =
+    if (auto const *objPtr =
             dyn_cast<ObjCObjectPointerType>(type.getTypePtr())) {
-      const ObjCObjectType *objT = objPtr->getObjectType();
+      ObjCObjectType const *objT = objPtr->getObjectType();
       // Merge protocol lists and construct ObjCObjectType.
-      SmallVector<ObjCProtocolDecl*, 8> protocolsVec;
-      protocolsVec.append(objT->qual_begin(),
-                          objT->qual_end());
+      SmallVector<ObjCProtocolDecl *, 8> protocolsVec;
+      protocolsVec.append(objT->qual_begin(), objT->qual_end());
       protocolsVec.append(protocols.begin(), protocols.end());
       ArrayRef<ObjCProtocolDecl *> protocols = protocolsVec;
-      type = getObjCObjectType(
-             objT->getBaseType(),
-             objT->getTypeArgsAsWritten(),
-             protocols,
-             objT->isKindOfTypeAsWritten());
+      type =
+          getObjCObjectType(objT->getBaseType(), objT->getTypeArgsAsWritten(),
+                            protocols, objT->isKindOfTypeAsWritten());
       return getObjCObjectPointerType(type);
     }
   }
 
   // Apply protocol qualifiers to ObjCObjectType.
-  if (const auto *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){
+  if (auto const *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())) {
     // FIXME: Check for protocols to which the class type is already
     // known to conform.
 
-    return getObjCObjectType(objT->getBaseType(),
-                             objT->getTypeArgsAsWritten(),
-                             protocols,
-                             objT->isKindOfTypeAsWritten());
+    return getObjCObjectType(objT->getBaseType(), objT->getTypeArgsAsWritten(),
+                             protocols, objT->isKindOfTypeAsWritten());
   }
 
   // If the canonical type is ObjCObjectType, ...
@@ -5275,17 +5220,17 @@
 
   // id<protocol-list>
   if (type->isObjCIdType()) {
-    const auto *objPtr = type->castAs<ObjCObjectPointerType>();
+    auto const *objPtr = type->castAs<ObjCObjectPointerType>();
     type = getObjCObjectType(ObjCBuiltinIdTy, {}, protocols,
-                                 objPtr->isKindOfType());
+                             objPtr->isKindOfType());
     return getObjCObjectPointerType(type);
   }
 
   // Class<protocol-list>
   if (type->isObjCClassType()) {
-    const auto *objPtr = type->castAs<ObjCObjectPointerType>();
+    auto const *objPtr = type->castAs<ObjCObjectPointerType>();
     type = getObjCObjectType(ObjCBuiltinClassTy, {}, protocols,
-                                 objPtr->isKindOfType());
+                             objPtr->isKindOfType());
     return getObjCObjectPointerType(type);
   }
 
@@ -5294,14 +5239,14 @@
 }
 
 QualType
-ASTContext::getObjCTypeParamType(const ObjCTypeParamDecl *Decl,
+ASTContext::getObjCTypeParamType(ObjCTypeParamDecl const *Decl,
                                  ArrayRef<ObjCProtocolDecl *> protocols) const {
   // Look in the folding set for an existing type.
   llvm::FoldingSetNodeID ID;
   ObjCTypeParamType::Profile(ID, Decl, Decl->getUnderlyingType(), protocols);
   void *InsertPos = nullptr;
   if (ObjCTypeParamType *TypeParam =
-      ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
+          ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(TypeParam, 0);
 
   // We canonicalize to the underlying type.
@@ -5324,7 +5269,7 @@
   return QualType(newType, 0);
 }
 
-void ASTContext::adjustObjCTypeParamBoundType(const ObjCTypeParamDecl *Orig,
+void ASTContext::adjustObjCTypeParamBoundType(ObjCTypeParamDecl const *Orig,
                                               ObjCTypeParamDecl *New) const {
   New->setTypeSourceInfo(getTrivialTypeSourceInfo(Orig->getUnderlyingType()));
   // Update TypeForDecl after updating TypeSourceInfo.
@@ -5343,7 +5288,7 @@
   if (!QT->isObjCQualifiedIdType())
     return false;
 
-  if (const auto *OPT = QT->getAs<ObjCObjectPointerType>()) {
+  if (auto const *OPT = QT->getAs<ObjCObjectPointerType>()) {
     // If both the right and left sides have qualifiers.
     for (auto *Proto : OPT->quals()) {
       if (!IC->ClassImplementsProtocol(Proto, false))
@@ -5357,11 +5302,11 @@
 /// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
 /// QT's qualified-id protocol list adopt all protocols in IDecl's list
 /// of protocols.
-bool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
-                                                ObjCInterfaceDecl *IDecl) {
+bool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(
+    QualType QT, ObjCInterfaceDecl *IDecl) {
   if (!QT->isObjCQualifiedIdType())
     return false;
-  const auto *OPT = QT->getAs<ObjCObjectPointerType>();
+  auto const *OPT = QT->getAs<ObjCObjectPointerType>();
   if (!OPT)
     return false;
   if (!IDecl->hasDefinition())
@@ -5409,7 +5354,7 @@
 
   void *InsertPos = nullptr;
   if (ObjCObjectPointerType *QT =
-              ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
+          ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(QT, 0);
 
   // Find the canonical object type.
@@ -5423,8 +5368,7 @@
 
   // No match.
   void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
-  auto *QType =
-    new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
+  auto *QType = new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
 
   Types.push_back(QType);
   ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
@@ -5433,7 +5377,7 @@
 
 /// getObjCInterfaceType - Return the unique reference to the type for the
 /// specified ObjC interface decl. The list of protocols is optional.
-QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
+QualType ASTContext::getObjCInterfaceType(ObjCInterfaceDecl const *Decl,
                                           ObjCInterfaceDecl *PrevDecl) const {
   if (Decl->TypeForDecl)
     return QualType(Decl->TypeForDecl, 0);
@@ -5445,7 +5389,7 @@
   }
 
   // Prefer the definition, if there is one.
-  if (const ObjCInterfaceDecl *Def = Decl->getDefinition())
+  if (ObjCInterfaceDecl const *Def = Decl->getDefinition())
     Decl = Def;
 
   void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
@@ -5467,17 +5411,17 @@
     DependentTypeOfExprType::Profile(ID, *this, tofExpr);
 
     void *InsertPos = nullptr;
-    DependentTypeOfExprType *Canon
-      = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
+    DependentTypeOfExprType *Canon =
+        DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
     if (Canon) {
       // We already have a "canonical" version of an identical, dependent
       // typeof(expr) type. Use that as our canonical type.
-      toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
-                                          QualType((TypeOfExprType*)Canon, 0));
+      toe = new (*this, TypeAlignment)
+          TypeOfExprType(tofExpr, QualType((TypeOfExprType *)Canon, 0));
     } else {
       // Build a new, canonical typeof(expr) type.
-      Canon
-        = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
+      Canon =
+          new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
       DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
       toe = Canon;
     }
@@ -5504,7 +5448,7 @@
 /// getReferenceQualifiedType - Given an expr, will return the type for
 /// that expression, as in [dcl.type.simple]p4 but without taking id-expressions
 /// and class member access into account.
-QualType ASTContext::getReferenceQualifiedType(const Expr *E) const {
+QualType ASTContext::getReferenceQualifiedType(Expr const *E) const {
   // C++11 [dcl.type.simple]p4:
   //   [...]
   QualType T = E->getType();
@@ -5540,8 +5484,8 @@
     DependentDecltypeType::Profile(ID, *this, e);
 
     void *InsertPos = nullptr;
-    DependentDecltypeType *Canon
-      = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
+    DependentDecltypeType *Canon =
+        DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
     if (!Canon) {
       // Build a new, canonical decltype(expr) type.
       Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
@@ -5559,10 +5503,9 @@
 
 /// getUnaryTransformationType - We don't unique these, since the memory
 /// savings are minimal and these are rare.
-QualType ASTContext::getUnaryTransformType(QualType BaseType,
-                                           QualType UnderlyingType,
-                                           UnaryTransformType::UTTKind Kind)
-    const {
+QualType
+ASTContext::getUnaryTransformType(QualType BaseType, QualType UnderlyingType,
+                                  UnaryTransformType::UTTKind Kind) const {
   UnaryTransformType *ut = nullptr;
 
   if (BaseType->isDependentType()) {
@@ -5571,24 +5514,21 @@
     DependentUnaryTransformType::Profile(ID, getCanonicalType(BaseType), Kind);
 
     void *InsertPos = nullptr;
-    DependentUnaryTransformType *Canon
-      = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
+    DependentUnaryTransformType *Canon =
+        DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
 
     if (!Canon) {
       // Build a new, canonical __underlying_type(type) type.
       Canon = new (*this, TypeAlignment)
-             DependentUnaryTransformType(*this, getCanonicalType(BaseType),
-                                         Kind);
+          DependentUnaryTransformType(*this, getCanonicalType(BaseType), Kind);
       DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);
     }
-    ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
-                                                        QualType(), Kind,
-                                                        QualType(Canon, 0));
+    ut = new (*this, TypeAlignment)
+        UnaryTransformType(BaseType, QualType(), Kind, QualType(Canon, 0));
   } else {
     QualType CanonType = getCanonicalType(UnderlyingType);
-    ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
-                                                        UnderlyingType, Kind,
-                                                        CanonType);
+    ut = new (*this, TypeAlignment)
+        UnaryTransformType(BaseType, UnderlyingType, Kind, CanonType);
   }
   Types.push_back(ut);
   return QualType(ut, 0);
@@ -5616,7 +5556,7 @@
     return QualType(AT, 0);
 
   void *Mem = Allocate(sizeof(AutoType) +
-                       sizeof(TemplateArgument) * TypeConstraintArgs.size(),
+                           sizeof(TemplateArgument) * TypeConstraintArgs.size(),
                        TypeAlignment);
   auto *AT = new (Mem) AutoType(
       DeducedType, Keyword,
@@ -5672,7 +5612,8 @@
 
     // Get the new insert position for the node we care about.
     AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
-    assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
+    assert(!NewIP && "Shouldn't be in the map!");
+    (void)NewIP;
   }
   auto *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
   Types.push_back(New);
@@ -5701,11 +5642,11 @@
 
 /// getTagDeclType - Return the unique reference to the type for the
 /// specified TagDecl (struct/union/class/enum) decl.
-QualType ASTContext::getTagDeclType(const TagDecl *Decl) const {
+QualType ASTContext::getTagDeclType(TagDecl const *Decl) const {
   assert(Decl);
   // FIXME: What is the design on getTagDeclType when it requires casting
   // away const?  mutable?
-  return getTypeDeclType(const_cast<TagDecl*>(Decl));
+  return getTypeDeclType(const_cast<TagDecl *>(Decl));
 }
 
 /// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
@@ -5781,10 +5722,10 @@
   // qualifiers.
   T = getCanonicalType(T);
   T = getVariableArrayDecayedType(T);
-  const Type *Ty = T.getTypePtr();
+  Type const *Ty = T.getTypePtr();
   QualType Result;
   if (isa<ArrayType>(Ty)) {
-    Result = getArrayDecayedType(QualType(Ty,0));
+    Result = getArrayDecayedType(QualType(Ty, 0));
   } else if (isa<FunctionType>(Ty)) {
     Result = getPointerType(QualType(Ty, 0));
   } else {
@@ -5794,15 +5735,14 @@
   return CanQualType::CreateUnsafe(Result);
 }
 
-QualType ASTContext::getUnqualifiedArrayType(QualType type,
-                                             Qualifiers &quals) {
+QualType ASTContext::getUnqualifiedArrayType(QualType type, Qualifiers &quals) {
   SplitQualType splitType = type.getSplitUnqualifiedType();
 
   // FIXME: getSplitUnqualifiedType() actually walks all the way to
   // the unqualified desugared type and then drops it on the floor.
   // We then have to strip that sugar back off with
   // getUnqualifiedDesugaredType(), which is silly.
-  const auto *AT =
+  auto const *AT =
       dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType());
 
   // If we don't have an array, just use the results in splitType.
@@ -5827,27 +5767,24 @@
   // build the type back up.
   quals.addConsistentQualifiers(splitType.Quals);
 
-  if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
+  if (auto const *CAT = dyn_cast<ConstantArrayType>(AT)) {
     return getConstantArrayType(unqualElementType, CAT->getSize(),
                                 CAT->getSizeExpr(), CAT->getSizeModifier(), 0);
   }
 
-  if (const auto *IAT = dyn_cast<IncompleteArrayType>(AT)) {
+  if (auto const *IAT = dyn_cast<IncompleteArrayType>(AT)) {
     return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0);
   }
 
-  if (const auto *VAT = dyn_cast<VariableArrayType>(AT)) {
-    return getVariableArrayType(unqualElementType,
-                                VAT->getSizeExpr(),
-                                VAT->getSizeModifier(),
-                                VAT->getIndexTypeCVRQualifiers(),
-                                VAT->getBracketsRange());
+  if (auto const *VAT = dyn_cast<VariableArrayType>(AT)) {
+    return getVariableArrayType(
+        unqualElementType, VAT->getSizeExpr(), VAT->getSizeModifier(),
+        VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());
   }
 
-  const auto *DSAT = cast<DependentSizedArrayType>(AT);
+  auto const *DSAT = cast<DependentSizedArrayType>(AT);
   return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(),
-                                    DSAT->getSizeModifier(), 0,
-                                    SourceRange());
+                                    DSAT->getSizeModifier(), 0, SourceRange());
 }
 
 /// Attempt to unwrap two types that may both be array types with the same bound
@@ -5894,16 +5831,16 @@
 bool ASTContext::UnwrapSimilarTypes(QualType &T1, QualType &T2) {
   UnwrapSimilarArrayTypes(T1, T2);
 
-  const auto *T1PtrType = T1->getAs<PointerType>();
-  const auto *T2PtrType = T2->getAs<PointerType>();
+  auto const *T1PtrType = T1->getAs<PointerType>();
+  auto const *T2PtrType = T2->getAs<PointerType>();
   if (T1PtrType && T2PtrType) {
     T1 = T1PtrType->getPointeeType();
     T2 = T2PtrType->getPointeeType();
     return true;
   }
 
-  const auto *T1MPType = T1->getAs<MemberPointerType>();
-  const auto *T2MPType = T2->getAs<MemberPointerType>();
+  auto const *T1MPType = T1->getAs<MemberPointerType>();
+  auto const *T2MPType = T2->getAs<MemberPointerType>();
   if (T1MPType && T2MPType &&
       hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
                              QualType(T2MPType->getClass(), 0))) {
@@ -5913,8 +5850,8 @@
   }
 
   if (getLangOpts().ObjC) {
-    const auto *T1OPType = T1->getAs<ObjCObjectPointerType>();
-    const auto *T2OPType = T2->getAs<ObjCObjectPointerType>();
+    auto const *T1OPType = T1->getAs<ObjCObjectPointerType>();
+    auto const *T2OPType = T2->getAs<ObjCObjectPointerType>();
     if (T1OPType && T2OPType) {
       T1 = T1OPType->getPointeeType();
       T2 = T2OPType->getPointeeType();
@@ -5995,15 +5932,14 @@
   }
 
   case TemplateName::SubstTemplateTemplateParm: {
-    SubstTemplateTemplateParmStorage *subst
-      = Name.getAsSubstTemplateTemplateParm();
-    return DeclarationNameInfo(subst->getParameter()->getDeclName(),
-                               NameLoc);
+    SubstTemplateTemplateParmStorage *subst =
+        Name.getAsSubstTemplateTemplateParm();
+    return DeclarationNameInfo(subst->getParameter()->getDeclName(), NameLoc);
   }
 
   case TemplateName::SubstTemplateTemplateParmPack: {
-    SubstTemplateTemplateParmPackStorage *subst
-      = Name.getAsSubstTemplateTemplateParmPack();
+    SubstTemplateTemplateParmPackStorage *subst =
+        Name.getAsSubstTemplateTemplateParmPack();
     return DeclarationNameInfo(subst->getParameterPack()->getDeclName(),
                                NameLoc);
   }
@@ -6017,7 +5953,7 @@
   case TemplateName::QualifiedTemplate:
   case TemplateName::Template: {
     TemplateDecl *Template = Name.getAsTemplateDecl();
-    if (auto *TTP  = dyn_cast<TemplateTemplateParmDecl>(Template))
+    if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template))
       Template = getCanonicalTemplateTemplateParmDecl(TTP);
 
     // The canonical template name is the canonical template declaration.
@@ -6035,18 +5971,18 @@
   }
 
   case TemplateName::SubstTemplateTemplateParm: {
-    SubstTemplateTemplateParmStorage *subst
-      = Name.getAsSubstTemplateTemplateParm();
+    SubstTemplateTemplateParmStorage *subst =
+        Name.getAsSubstTemplateTemplateParm();
     return getCanonicalTemplateName(subst->getReplacement());
   }
 
   case TemplateName::SubstTemplateTemplateParmPack: {
-    SubstTemplateTemplateParmPackStorage *subst
-                                  = Name.getAsSubstTemplateTemplateParmPack();
-    TemplateTemplateParmDecl *canonParameter
-      = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
-    TemplateArgument canonArgPack
-      = getCanonicalTemplateArgument(subst->getArgumentPack());
+    SubstTemplateTemplateParmPackStorage *subst =
+        Name.getAsSubstTemplateTemplateParmPack();
+    TemplateTemplateParmDecl *canonParameter =
+        getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
+    TemplateArgument canonArgPack =
+        getCanonicalTemplateArgument(subst->getArgumentPack());
     return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
   }
   }
@@ -6061,50 +5997,50 @@
 }
 
 TemplateArgument
-ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
+ASTContext::getCanonicalTemplateArgument(TemplateArgument const &Arg) const {
   switch (Arg.getKind()) {
-    case TemplateArgument::Null:
-      return Arg;
+  case TemplateArgument::Null:
+    return Arg;
 
-    case TemplateArgument::Expression:
-      return Arg;
+  case TemplateArgument::Expression:
+    return Arg;
 
-    case TemplateArgument::Declaration: {
-      auto *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
-      return TemplateArgument(D, Arg.getParamTypeForDecl());
-    }
+  case TemplateArgument::Declaration: {
+    auto *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
+    return TemplateArgument(D, Arg.getParamTypeForDecl());
+  }
 
-    case TemplateArgument::NullPtr:
-      return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),
-                              /*isNullPtr*/true);
+  case TemplateArgument::NullPtr:
+    return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),
+                            /*isNullPtr*/ true);
 
-    case TemplateArgument::Template:
-      return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));
+  case TemplateArgument::Template:
+    return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));
 
-    case TemplateArgument::TemplateExpansion:
-      return TemplateArgument(getCanonicalTemplateName(
-                                         Arg.getAsTemplateOrTemplatePattern()),
-                              Arg.getNumTemplateExpansions());
+  case TemplateArgument::TemplateExpansion:
+    return TemplateArgument(
+        getCanonicalTemplateName(Arg.getAsTemplateOrTemplatePattern()),
+        Arg.getNumTemplateExpansions());
 
-    case TemplateArgument::Integral:
-      return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType()));
+  case TemplateArgument::Integral:
+    return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType()));
 
-    case TemplateArgument::Type:
-      return TemplateArgument(getCanonicalType(Arg.getAsType()));
+  case TemplateArgument::Type:
+    return TemplateArgument(getCanonicalType(Arg.getAsType()));
 
-    case TemplateArgument::Pack: {
-      if (Arg.pack_size() == 0)
-        return Arg;
+  case TemplateArgument::Pack: {
+    if (Arg.pack_size() == 0)
+      return Arg;
 
-      auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
-      unsigned Idx = 0;
-      for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
-                                        AEnd = Arg.pack_end();
-           A != AEnd; (void)++A, ++Idx)
-        CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
+    auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
+    unsigned Idx = 0;
+    for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
+                                         AEnd = Arg.pack_end();
+         A != AEnd; (void)++A, ++Idx)
+      CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
 
-      return TemplateArgument(llvm::makeArrayRef(CanonArgs, Arg.pack_size()));
-    }
+    return TemplateArgument(llvm::makeArrayRef(CanonArgs, Arg.pack_size()));
+  }
   }
 
   // Silence GCC warning
@@ -6119,28 +6055,28 @@
   switch (NNS->getKind()) {
   case NestedNameSpecifier::Identifier:
     // Canonicalize the prefix but keep the identifier the same.
-    return NestedNameSpecifier::Create(*this,
-                         getCanonicalNestedNameSpecifier(NNS->getPrefix()),
-                                       NNS->getAsIdentifier());
+    return NestedNameSpecifier::Create(
+        *this, getCanonicalNestedNameSpecifier(NNS->getPrefix()),
+        NNS->getAsIdentifier());
 
   case NestedNameSpecifier::Namespace:
     // A namespace is canonical; build a nested-name-specifier with
     // this namespace and no prefix.
-    return NestedNameSpecifier::Create(*this, nullptr,
-                                 NNS->getAsNamespace()->getOriginalNamespace());
+    return NestedNameSpecifier::Create(
+        *this, nullptr, NNS->getAsNamespace()->getOriginalNamespace());
 
   case NestedNameSpecifier::NamespaceAlias:
     // A namespace is canonical; build a nested-name-specifier with
     // this namespace and no prefix.
-    return NestedNameSpecifier::Create(*this, nullptr,
-                                    NNS->getAsNamespaceAlias()->getNamespace()
-                                                      ->getOriginalNamespace());
+    return NestedNameSpecifier::Create(
+        *this, nullptr,
+        NNS->getAsNamespaceAlias()->getNamespace()->getOriginalNamespace());
 
   // The difference between TypeSpec and TypeSpecWithTemplate is that the
   // latter will have the 'template' keyword when printed.
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate: {
-    const Type *T = getCanonicalType(NNS->getAsType());
+    Type const *T = getCanonicalType(NNS->getAsType());
 
     // If we have some kind of dependent-named type (e.g., "typename T::type"),
     // break it apart into its prefix and identifier, then reconsititute those
@@ -6149,11 +6085,11 @@
     // types, e.g.,
     //   typedef typename T::type T1;
     //   typedef typename T1::type T2;
-    if (const auto *DNT = T->getAs<DependentNameType>())
+    if (auto const *DNT = T->getAs<DependentNameType>())
       return NestedNameSpecifier::Create(
           *this, DNT->getQualifier(),
           const_cast<IdentifierInfo *>(DNT->getIdentifier()));
-    if (const auto *DTST = T->getAs<DependentTemplateSpecializationType>())
+    if (auto const *DTST = T->getAs<DependentTemplateSpecializationType>())
       return NestedNameSpecifier::Create(*this, DTST->getQualifier(), true,
                                          const_cast<Type *>(T));
 
@@ -6171,11 +6107,11 @@
   llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
 }
 
-const ArrayType *ASTContext::getAsArrayType(QualType T) const {
+ArrayType const *ASTContext::getAsArrayType(QualType T) const {
   // Handle the non-qualified case efficiently.
   if (!T.hasLocalQualifiers()) {
     // Handle the common positive case fast.
-    if (const auto *AT = dyn_cast<ArrayType>(T))
+    if (auto const *AT = dyn_cast<ArrayType>(T))
       return AT;
   }
 
@@ -6195,7 +6131,7 @@
   Qualifiers qs = split.Quals;
 
   // If we have a simple case, just return now.
-  const auto *ATy = dyn_cast<ArrayType>(split.Ty);
+  auto const *ATy = dyn_cast<ArrayType>(split.Ty);
   if (!ATy || qs.empty())
     return ATy;
 
@@ -6203,30 +6139,23 @@
   // qualifiers into the array element type and return a new array type.
   QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs);
 
-  if (const auto *CAT = dyn_cast<ConstantArrayType>(ATy))
-    return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
-                                                CAT->getSizeExpr(),
-                                                CAT->getSizeModifier(),
-                                           CAT->getIndexTypeCVRQualifiers()));
-  if (const auto *IAT = dyn_cast<IncompleteArrayType>(ATy))
-    return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
-                                                  IAT->getSizeModifier(),
-                                           IAT->getIndexTypeCVRQualifiers()));
-
-  if (const auto *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
-    return cast<ArrayType>(
-                     getDependentSizedArrayType(NewEltTy,
-                                                DSAT->getSizeExpr(),
-                                                DSAT->getSizeModifier(),
-                                              DSAT->getIndexTypeCVRQualifiers(),
-                                                DSAT->getBracketsRange()));
-
-  const auto *VAT = cast<VariableArrayType>(ATy);
-  return cast<ArrayType>(getVariableArrayType(NewEltTy,
-                                              VAT->getSizeExpr(),
-                                              VAT->getSizeModifier(),
-                                              VAT->getIndexTypeCVRQualifiers(),
-                                              VAT->getBracketsRange()));
+  if (auto const *CAT = dyn_cast<ConstantArrayType>(ATy))
+    return cast<ArrayType>(getConstantArrayType(
+        NewEltTy, CAT->getSize(), CAT->getSizeExpr(), CAT->getSizeModifier(),
+        CAT->getIndexTypeCVRQualifiers()));
+  if (auto const *IAT = dyn_cast<IncompleteArrayType>(ATy))
+    return cast<ArrayType>(getIncompleteArrayType(
+        NewEltTy, IAT->getSizeModifier(), IAT->getIndexTypeCVRQualifiers()));
+
+  if (auto const *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
+    return cast<ArrayType>(getDependentSizedArrayType(
+        NewEltTy, DSAT->getSizeExpr(), DSAT->getSizeModifier(),
+        DSAT->getIndexTypeCVRQualifiers(), DSAT->getBracketsRange()));
+
+  auto const *VAT = cast<VariableArrayType>(ATy);
+  return cast<ArrayType>(getVariableArrayType(
+      NewEltTy, VAT->getSizeExpr(), VAT->getSizeModifier(),
+      VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange()));
 }
 
 QualType ASTContext::getAdjustedParameterType(QualType T) const {
@@ -6265,14 +6194,14 @@
   // typedefs in the element type of the array.  This also handles propagation
   // of type qualifiers from the array type into the element type if present
   // (C99 6.7.3p8).
-  const ArrayType *PrettyArrayType = getAsArrayType(Ty);
+  ArrayType const *PrettyArrayType = getAsArrayType(Ty);
   assert(PrettyArrayType && "Not an array type!");
 
   QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
 
   // int x[restrict 4] ->  int *restrict
-  QualType Result = getQualifiedType(PtrTy,
-                                     PrettyArrayType->getIndexTypeQualifiers());
+  QualType Result =
+      getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers());
 
   // int x[_Nullable] -> int * _Nullable
   if (auto Nullability = Ty->getNullability(*this)) {
@@ -6282,7 +6211,7 @@
   return Result;
 }
 
-QualType ASTContext::getBaseElementType(const ArrayType *array) const {
+QualType ASTContext::getBaseElementType(ArrayType const *array) const {
   return getBaseElementType(array->getElementType());
 }
 
@@ -6290,8 +6219,9 @@
   Qualifiers qs;
   while (true) {
     SplitQualType split = type.getSplitDesugaredType();
-    const ArrayType *array = split.Ty->getAsArrayTypeUnsafe();
-    if (!array) break;
+    ArrayType const *array = split.Ty->getAsArrayTypeUnsafe();
+    if (!array)
+      break;
 
     type = array->getElementType();
     qs.addConsistentQualifiers(split.Quals);
@@ -6302,12 +6232,12 @@
 
 /// getConstantArrayElementCount - Returns number of constant array elements.
 uint64_t
-ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA)  const {
+ASTContext::getConstantArrayElementCount(ConstantArrayType const *CA) const {
   uint64_t ElementCount = 1;
   do {
     ElementCount *= CA->getSize().getZExtValue();
     CA = dyn_cast_or_null<ConstantArrayType>(
-      CA->getElementType()->getAsArrayTypeUnsafe());
+        CA->getElementType()->getAsArrayTypeUnsafe());
   } while (CA);
   return ElementCount;
 }
@@ -6315,19 +6245,28 @@
 /// getFloatingRank - Return a relative rank for floating point types.
 /// This routine will assert if passed a built-in type that isn't a float.
 static FloatingRank getFloatingRank(QualType T) {
-  if (const auto *CT = T->getAs<ComplexType>())
+  if (auto const *CT = T->getAs<ComplexType>())
     return getFloatingRank(CT->getElementType());
 
   switch (T->castAs<BuiltinType>()->getKind()) {
-  default: llvm_unreachable("getFloatingRank(): not a floating type");
-  case BuiltinType::Float16:    return Float16Rank;
-  case BuiltinType::Half:       return HalfRank;
-  case BuiltinType::Float:      return FloatRank;
-  case BuiltinType::Double:     return DoubleRank;
-  case BuiltinType::LongDouble: return LongDoubleRank;
-  case BuiltinType::Float128:   return Float128Rank;
-  case BuiltinType::BFloat16:   return BFloat16Rank;
-  case BuiltinType::Ibm128:     return Ibm128Rank;
+  default:
+    llvm_unreachable("getFloatingRank(): not a floating type");
+  case BuiltinType::Float16:
+    return Float16Rank;
+  case BuiltinType::Half:
+    return HalfRank;
+  case BuiltinType::Float:
+    return FloatRank;
+  case BuiltinType::Double:
+    return DoubleRank;
+  case BuiltinType::LongDouble:
+    return LongDoubleRank;
+  case BuiltinType::Float128:
+    return Float128Rank;
+  case BuiltinType::BFloat16:
+    return BFloat16Rank;
+  case BuiltinType::Ibm128:
+    return Ibm128Rank;
   }
 }
 
@@ -6340,26 +6279,40 @@
   FloatingRank EltRank = getFloatingRank(Size);
   if (Domain->isComplexType()) {
     switch (EltRank) {
-    case BFloat16Rank: llvm_unreachable("Complex bfloat16 is not supported");
+    case BFloat16Rank:
+      llvm_unreachable("Complex bfloat16 is not supported");
     case Float16Rank:
-    case HalfRank: llvm_unreachable("Complex half is not supported");
-    case Ibm128Rank: llvm_unreachable("Complex __ibm128 is not supported");
-    case FloatRank:      return FloatComplexTy;
-    case DoubleRank:     return DoubleComplexTy;
-    case LongDoubleRank: return LongDoubleComplexTy;
-    case Float128Rank:   return Float128ComplexTy;
+    case HalfRank:
+      llvm_unreachable("Complex half is not supported");
+    case Ibm128Rank:
+      llvm_unreachable("Complex __ibm128 is not supported");
+    case FloatRank:
+      return FloatComplexTy;
+    case DoubleRank:
+      return DoubleComplexTy;
+    case LongDoubleRank:
+      return LongDoubleComplexTy;
+    case Float128Rank:
+      return Float128ComplexTy;
     }
   }
 
   assert(Domain->isRealFloatingType() && "Unknown domain!");
   switch (EltRank) {
-  case Float16Rank:    return HalfTy;
-  case BFloat16Rank:   return BFloat16Ty;
-  case HalfRank:       return HalfTy;
-  case FloatRank:      return FloatTy;
-  case DoubleRank:     return DoubleTy;
-  case LongDoubleRank: return LongDoubleTy;
-  case Float128Rank:   return Float128Ty;
+  case Float16Rank:
+    return HalfTy;
+  case BFloat16Rank:
+    return BFloat16Ty;
+  case HalfRank:
+    return HalfTy;
+  case FloatRank:
+    return FloatTy;
+  case DoubleRank:
+    return DoubleTy;
+  case LongDoubleRank:
+    return LongDoubleTy;
+  case Float128Rank:
+    return Float128Ty;
   case Ibm128Rank:
     return Ibm128Ty;
   }
@@ -6390,16 +6343,17 @@
 /// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
 /// routine will assert if passed a built-in type that isn't an integer or enum,
 /// or if it is not canonicalized.
-unsigned ASTContext::getIntegerRank(const Type *T) const {
+unsigned ASTContext::getIntegerRank(Type const *T) const {
   assert(T->isCanonicalUnqualified() && "T should be canonicalized");
 
   // Results in this 'losing' to any type of the same size, but winning if
   // larger.
-  if (const auto *EIT = dyn_cast<ExtIntType>(T))
+  if (auto const *EIT = dyn_cast<ExtIntType>(T))
     return 0 + (EIT->getNumBits() << 3);
 
   switch (cast<BuiltinType>(T)->getKind()) {
-  default: llvm_unreachable("getIntegerRank(): not a built-in integer");
+  default:
+    llvm_unreachable("getIntegerRank(): not a built-in integer");
   case BuiltinType::Bool:
     return 1 + (getIntWidth(BoolTy) << 3);
   case BuiltinType::Char_S:
@@ -6488,10 +6442,10 @@
 QualType ASTContext::getPromotedIntegerType(QualType Promotable) const {
   assert(!Promotable.isNull());
   assert(Promotable->isPromotableIntegerType());
-  if (const auto *ET = Promotable->getAs<EnumType>())
+  if (auto const *ET = Promotable->getAs<EnumType>())
     return ET->getDecl()->getPromotionType();
 
-  if (const auto *BT = Promotable->getAs<BuiltinType>()) {
+  if (auto const *BT = Promotable->getAs<BuiltinType>()) {
     // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t
     // (3.9.1) can be converted to a prvalue of the first of the following
     // types that can represent all the values of its underlying type:
@@ -6505,8 +6459,9 @@
         BT->getKind() == BuiltinType::Char32) {
       bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
       uint64_t FromSize = getTypeSize(BT);
-      QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy,
-                                  LongLongTy, UnsignedLongLongTy };
+      QualType PromoteTypes[] = {IntTy,      UnsignedIntTy,
+                                 LongTy,     UnsignedLongTy,
+                                 LongLongTy, UnsignedLongLongTy};
       for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) {
         uint64_t ToSize = getTypeSize(PromoteTypes[Idx]);
         if (FromSize < ToSize ||
@@ -6535,9 +6490,9 @@
       return T.getObjCLifetime();
     if (T->isArrayType())
       T = getBaseElementType(T);
-    else if (const auto *PT = T->getAs<PointerType>())
+    else if (auto const *PT = T->getAs<PointerType>())
       T = PT->getPointeeType();
-    else if (const auto *RT = T->getAs<ReferenceType>())
+    else if (auto const *RT = T->getAs<ReferenceType>())
       T = RT->getPointeeType();
     else
       break;
@@ -6546,7 +6501,7 @@
   return Qualifiers::OCL_None;
 }
 
-static const Type *getIntegerTypeForEnum(const EnumType *ET) {
+static Type const *getIntegerTypeForEnum(EnumType const *ET) {
   // Incomplete enum types are not treated as integer types.
   // FIXME: In C++, enum types are never integer types.
   if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
@@ -6558,16 +6513,17 @@
 /// C99 6.3.1.8p1.  If LHS > RHS, return 1.  If LHS == RHS, return 0. If
 /// LHS < RHS, return -1.
 int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const {
-  const Type *LHSC = getCanonicalType(LHS).getTypePtr();
-  const Type *RHSC = getCanonicalType(RHS).getTypePtr();
+  Type const *LHSC = getCanonicalType(LHS).getTypePtr();
+  Type const *RHSC = getCanonicalType(RHS).getTypePtr();
 
   // Unwrap enums to their underlying type.
-  if (const auto *ET = dyn_cast<EnumType>(LHSC))
+  if (auto const *ET = dyn_cast<EnumType>(LHSC))
     LHSC = getIntegerTypeForEnum(ET);
-  if (const auto *ET = dyn_cast<EnumType>(RHSC))
+  if (auto const *ET = dyn_cast<EnumType>(RHSC))
     RHSC = getIntegerTypeForEnum(ET);
 
-  if (LHSC == RHSC) return 0;
+  if (LHSC == RHSC)
+    return 0;
 
   bool LHSUnsigned = LHSC->isUnsignedIntegerType();
   bool RHSUnsigned = RHSC->isUnsignedIntegerType();
@@ -6575,8 +6531,9 @@
   unsigned LHSRank = getIntegerRank(LHSC);
   unsigned RHSRank = getIntegerRank(RHSC);
 
-  if (LHSUnsigned == RHSUnsigned) {  // Both signed or both unsigned.
-    if (LHSRank == RHSRank) return 0;
+  if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
+    if (LHSRank == RHSRank)
+      return 0;
     return LHSRank > RHSRank ? 1 : -1;
   }
 
@@ -6613,7 +6570,7 @@
 
   struct {
     QualType Type;
-    const char *Name;
+    char const *Name;
   } Fields[5];
   unsigned Count = 0;
 
@@ -6646,32 +6603,31 @@
   ///      uintptr_t _length;
   ///    } __NSConstantString;
 
-  const auto CFRuntime = getLangOpts().CFRuntime;
+  auto const CFRuntime = getLangOpts().CFRuntime;
   if (static_cast<unsigned>(CFRuntime) <
       static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift)) {
-    Fields[Count++] = { getPointerType(IntTy.withConst()), "isa" };
-    Fields[Count++] = { IntTy, "flags" };
-    Fields[Count++] = { getPointerType(CharTy.withConst()), "str" };
-    Fields[Count++] = { LongTy, "length" };
+    Fields[Count++] = {getPointerType(IntTy.withConst()), "isa"};
+    Fields[Count++] = {IntTy, "flags"};
+    Fields[Count++] = {getPointerType(CharTy.withConst()), "str"};
+    Fields[Count++] = {LongTy, "length"};
   } else {
-    Fields[Count++] = { getUIntPtrType(), "_cfisa" };
-    Fields[Count++] = { getUIntPtrType(), "_swift_rc" };
-    Fields[Count++] = { getFromTargetType(Target->getUInt64Type()), "_swift_rc" };
-    Fields[Count++] = { getPointerType(CharTy.withConst()), "_ptr" };
+    Fields[Count++] = {getUIntPtrType(), "_cfisa"};
+    Fields[Count++] = {getUIntPtrType(), "_swift_rc"};
+    Fields[Count++] = {getFromTargetType(Target->getUInt64Type()), "_swift_rc"};
+    Fields[Count++] = {getPointerType(CharTy.withConst()), "_ptr"};
     if (CFRuntime == LangOptions::CoreFoundationABI::Swift4_1 ||
         CFRuntime == LangOptions::CoreFoundationABI::Swift4_2)
-      Fields[Count++] = { IntTy, "_ptr" };
+      Fields[Count++] = {IntTy, "_ptr"};
     else
-      Fields[Count++] = { getUIntPtrType(), "_ptr" };
+      Fields[Count++] = {getUIntPtrType(), "_ptr"};
   }
 
   // Create fields
   for (unsigned i = 0; i < Count; ++i) {
-    FieldDecl *Field =
-        FieldDecl::Create(*this, CFConstantStringTagDecl, SourceLocation(),
-                          SourceLocation(), &Idents.get(Fields[i].Name),
-                          Fields[i].Type, /*TInfo=*/nullptr,
-                          /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
+    FieldDecl *Field = FieldDecl::Create(
+        *this, CFConstantStringTagDecl, SourceLocation(), SourceLocation(),
+        &Idents.get(Fields[i].Name), Fields[i].Type, /*TInfo=*/nullptr,
+        /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
     Field->setAccess(AS_public);
     CFConstantStringTagDecl->addDecl(Field);
   }
@@ -6707,9 +6663,9 @@
 }
 
 void ASTContext::setCFConstantStringType(QualType T) {
-  const auto *TD = T->castAs<TypedefType>();
+  auto const *TD = T->castAs<TypedefType>();
   CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());
-  const auto *TagType =
+  auto const *TagType =
       CFConstantStringTypeDecl->getUnderlyingType()->castAs<RecordType>();
   CFConstantStringTagDecl = TagType->getDecl();
 }
@@ -6724,14 +6680,11 @@
   RD->startDefinition();
 
   QualType FieldTypes[] = {
-    UnsignedLongTy,
-    UnsignedLongTy,
+      UnsignedLongTy,
+      UnsignedLongTy,
   };
 
-  static const char *const FieldNames[] = {
-    "reserved",
-    "Size"
-  };
+  static char const *const FieldNames[] = {"reserved", "Size"};
 
   for (size_t i = 0; i < 2; ++i) {
     FieldDecl *Field = FieldDecl::Create(
@@ -6758,19 +6711,12 @@
   RD = buildImplicitRecord("__block_descriptor_withcopydispose");
   RD->startDefinition();
 
-  QualType FieldTypes[] = {
-    UnsignedLongTy,
-    UnsignedLongTy,
-    getPointerType(VoidPtrTy),
-    getPointerType(VoidPtrTy)
-  };
+  QualType FieldTypes[] = {UnsignedLongTy, UnsignedLongTy,
+                           getPointerType(VoidPtrTy),
+                           getPointerType(VoidPtrTy)};
 
-  static const char *const FieldNames[] = {
-    "reserved",
-    "Size",
-    "CopyFuncPtr",
-    "DestroyFuncPtr"
-  };
+  static char const *const FieldNames[] = {"reserved", "Size", "CopyFuncPtr",
+                                           "DestroyFuncPtr"};
 
   for (size_t i = 0; i < 4; ++i) {
     FieldDecl *Field = FieldDecl::Create(
@@ -6788,8 +6734,8 @@
   return getTagDeclType(BlockDescriptorExtendedType);
 }
 
-OpenCLTypeKind ASTContext::getOpenCLTypeKind(const Type *T) const {
-  const auto *BT = dyn_cast<BuiltinType>(T);
+OpenCLTypeKind ASTContext::getOpenCLTypeKind(Type const *T) const {
+  auto const *BT = dyn_cast<BuiltinType>(T);
 
   if (!BT) {
     if (isa<PipeType>(T))
@@ -6824,18 +6770,18 @@
   }
 }
 
-LangAS ASTContext::getOpenCLTypeAddrSpace(const Type *T) const {
+LangAS ASTContext::getOpenCLTypeAddrSpace(Type const *T) const {
   return Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T));
 }
 
 /// BlockRequiresCopying - Returns true if byref variable "D" of type "Ty"
 /// requires copy/dispose. Note that this must match the logic
 /// in buildByrefHelpers.
-bool ASTContext::BlockRequiresCopying(QualType Ty,
-                                      const VarDecl *D) {
-  if (const CXXRecordDecl *record = Ty->getAsCXXRecordDecl()) {
-    const Expr *copyExpr = getBlockVarCopyInit(D).getCopyExpr();
-    if (!copyExpr && record->hasTrivialDestructor()) return false;
+bool ASTContext::BlockRequiresCopying(QualType Ty, VarDecl const *D) {
+  if (CXXRecordDecl const *record = Ty->getAsCXXRecordDecl()) {
+    Expr const *copyExpr = getBlockVarCopyInit(D).getCopyExpr();
+    if (!copyExpr && record->hasTrivialDestructor())
+      return false;
 
     return true;
   }
@@ -6845,25 +6791,27 @@
   if (Ty.isNonTrivialToPrimitiveDestructiveMove() || Ty.isDestructedType())
     return true;
 
-  if (!Ty->isObjCRetainableType()) return false;
+  if (!Ty->isObjCRetainableType())
+    return false;
 
   Qualifiers qs = Ty.getQualifiers();
 
   // If we have lifetime, that dominates.
   if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) {
     switch (lifetime) {
-      case Qualifiers::OCL_None: llvm_unreachable("impossible");
+    case Qualifiers::OCL_None:
+      llvm_unreachable("impossible");
 
-      // These are just bits as far as the runtime is concerned.
-      case Qualifiers::OCL_ExplicitNone:
-      case Qualifiers::OCL_Autoreleasing:
-        return false;
+    // These are just bits as far as the runtime is concerned.
+    case Qualifiers::OCL_ExplicitNone:
+    case Qualifiers::OCL_Autoreleasing:
+      return false;
 
-      // These cases should have been taken care of when checking the type's
-      // non-triviality.
-      case Qualifiers::OCL_Weak:
-      case Qualifiers::OCL_Strong:
-        llvm_unreachable("impossible");
+    // These cases should have been taken care of when checking the type's
+    // non-triviality.
+    case Qualifiers::OCL_Weak:
+    case Qualifiers::OCL_Strong:
+      llvm_unreachable("impossible");
     }
     llvm_unreachable("fell out of lifetime switch!");
   }
@@ -6872,10 +6820,9 @@
 }
 
 bool ASTContext::getByrefLifetime(QualType Ty,
-                              Qualifiers::ObjCLifetime &LifeTime,
-                              bool &HasByrefExtendedLayout) const {
-  if (!getLangOpts().ObjC ||
-      getLangOpts().getGC() != LangOptions::NonGC)
+                                  Qualifiers::ObjCLifetime &LifeTime,
+                                  bool &HasByrefExtendedLayout) const {
+  if (!getLangOpts().ObjC || getLangOpts().getGC() != LangOptions::NonGC)
     return false;
 
   HasByrefExtendedLayout = false;
@@ -6895,7 +6842,7 @@
 
 CanQualType ASTContext::getNSUIntegerType() const {
   assert(Target && "Expected target to be initialized");
-  const llvm::Triple &T = Target->getTriple();
+  llvm::Triple const &T = Target->getTriple();
   // Windows is LLP64 rather than LP64
   if (T.isOSWindows() && T.isArch64Bit())
     return UnsignedLongLongTy;
@@ -6904,7 +6851,7 @@
 
 CanQualType ASTContext::getNSIntegerType() const {
   assert(Target && "Expected target to be initialized");
-  const llvm::Triple &T = Target->getTriple();
+  llvm::Triple const &T = Target->getTriple();
   // Windows is LLP64 rather than LP64
   if (T.isOSWindows() && T.isArch64Bit())
     return LongLongTy;
@@ -6921,7 +6868,7 @@
 // This returns true if a type has been typedefed to BOOL:
 // typedef <type> BOOL;
 static bool isTypeTypedefedAsBOOL(QualType T) {
-  if (const auto *TT = dyn_cast<TypedefType>(T))
+  if (auto const *TT = dyn_cast<TypedefType>(T))
     if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
       return II->isStr("BOOL");
 
@@ -6945,7 +6892,7 @@
   return sz;
 }
 
-bool ASTContext::isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const {
+bool ASTContext::isMSStaticDataMemberInlineDefinition(VarDecl const *VD) const {
   return getTargetInfo().getCXXABI().isMicrosoft() &&
          VD->isStaticDataMember() &&
          VD->getType()->isIntegralOrEnumerationType() &&
@@ -6953,7 +6900,7 @@
 }
 
 ASTContext::InlineVariableDefinitionKind
-ASTContext::getInlineVariableDefinitionKind(const VarDecl *VD) const {
+ASTContext::getInlineVariableDefinitionKind(VarDecl const *VD) const {
   if (!VD->isInline())
     return InlineVariableDefinitionKind::None;
 
@@ -6973,16 +6920,16 @@
   return InlineVariableDefinitionKind::WeakUnknown;
 }
 
-static std::string charUnitsToString(const CharUnits &CU) {
+static std::string charUnitsToString(CharUnits const &CU) {
   return llvm::itostr(CU.getQuantity());
 }
 
 /// getObjCEncodingForBlock - Return the encoded type for this block
 /// declaration.
-std::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const {
+std::string ASTContext::getObjCEncodingForBlock(BlockExpr const *Expr) const {
   std::string S;
 
-  const BlockDecl *Decl = Expr->getBlockDecl();
+  BlockDecl const *Decl = Expr->getBlockDecl();
   QualType BlockTy =
       Expr->getType()->castAs<BlockPointerType>()->getPointeeType();
   QualType BlockReturnTy = BlockTy->castAs<FunctionType>()->getReturnType();
@@ -7014,7 +6961,7 @@
   ParmOffset = PtrSize;
   for (auto PVDecl : Decl->parameters()) {
     QualType PType = PVDecl->getOriginalType();
-    if (const auto *AT =
+    if (auto const *AT =
             dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
       // Use array's original type only if it has known number of
       // elements.
@@ -7023,8 +6970,8 @@
     } else if (PType->isFunctionType())
       PType = PVDecl->getType();
     if (getLangOpts().EncodeExtendedBlockSig)
-      getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, PType,
-                                      S, true /*Extended*/);
+      getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, PType, S,
+                                        true /*Extended*/);
     else
       getObjCEncodingForType(PType, S);
     S += charUnitsToString(ParmOffset);
@@ -7035,7 +6982,7 @@
 }
 
 std::string
-ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const {
+ASTContext::getObjCEncodingForFunctionDecl(FunctionDecl const *Decl) const {
   std::string S;
   // Encode result type.
   getObjCEncodingForType(Decl->getReturnType(), S);
@@ -7057,7 +7004,7 @@
   // Argument types.
   for (auto PVDecl : Decl->parameters()) {
     QualType PType = PVDecl->getOriginalType();
-    if (const auto *AT =
+    if (auto const *AT =
             dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
       // Use array's original type only if it has known number of
       // elements.
@@ -7077,7 +7024,7 @@
 /// method parameter or return type. If Extended, include class names and
 /// block object types.
 void ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT,
-                                                   QualType T, std::string& S,
+                                                   QualType T, std::string &S,
                                                    bool Extended) const {
   // Encode type qualifer, 'in', 'inout', etc. for the parameter.
   getObjCEncodingForTypeQualifier(QT, S);
@@ -7093,7 +7040,7 @@
 
 /// getObjCEncodingForMethodDecl - Return the encoded type for this method
 /// declaration.
-std::string ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
+std::string ASTContext::getObjCEncodingForMethodDecl(ObjCMethodDecl const *Decl,
                                                      bool Extended) const {
   // FIXME: This is not very efficient.
   // Encode return type.
@@ -7108,7 +7055,8 @@
   // their size.
   CharUnits ParmOffset = 2 * PtrSize;
   for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(),
-       E = Decl->sel_param_end(); PI != E; ++PI) {
+                                            E = Decl->sel_param_end();
+       PI != E; ++PI) {
     QualType PType = (*PI)->getType();
     CharUnits sz = getObjCEncodingTypeSize(PType);
     if (sz.isZero())
@@ -7125,10 +7073,11 @@
   // Argument types.
   ParmOffset = 2 * PtrSize;
   for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(),
-       E = Decl->sel_param_end(); PI != E; ++PI) {
-    const ParmVarDecl *PVDecl = *PI;
+                                            E = Decl->sel_param_end();
+       PI != E; ++PI) {
+    ParmVarDecl const *PVDecl = *PI;
     QualType PType = PVDecl->getOriginalType();
-    if (const auto *AT =
+    if (auto const *AT =
             dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
       // Use array's original type only if it has known number of
       // elements.
@@ -7136,8 +7085,8 @@
         PType = PVDecl->getType();
     } else if (PType->isFunctionType())
       PType = PVDecl->getType();
-    getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(),
-                                      PType, S, Extended);
+    getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(), PType, S,
+                                      Extended);
     S += charUnitsToString(ParmOffset);
     ParmOffset += getObjCEncodingTypeSize(PType);
   }
@@ -7145,18 +7094,16 @@
   return S;
 }
 
-ObjCPropertyImplDecl *
-ASTContext::getObjCPropertyImplDeclForPropertyDecl(
-                                      const ObjCPropertyDecl *PD,
-                                      const Decl *Container) const {
+ObjCPropertyImplDecl *ASTContext::getObjCPropertyImplDeclForPropertyDecl(
+    ObjCPropertyDecl const *PD, Decl const *Container) const {
   if (!Container)
     return nullptr;
-  if (const auto *CID = dyn_cast<ObjCCategoryImplDecl>(Container)) {
+  if (auto const *CID = dyn_cast<ObjCCategoryImplDecl>(Container)) {
     for (auto *PID : CID->property_impls())
       if (PID->getPropertyDecl() == PD)
         return PID;
   } else {
-    const auto *OID = cast<ObjCImplementationDecl>(Container);
+    auto const *OID = cast<ObjCImplementationDecl>(Container);
     for (auto *PID : OID->property_impls())
       if (PID->getPropertyDecl() == PD)
         return PID;
@@ -7190,15 +7137,16 @@
 /// };
 /// @endcode
 std::string
-ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
-                                           const Decl *Container) const {
+ASTContext::getObjCEncodingForPropertyDecl(ObjCPropertyDecl const *PD,
+                                           Decl const *Container) const {
   // Collect information from the property implementation decl(s).
   bool Dynamic = false;
   ObjCPropertyImplDecl *SynthesizePID = nullptr;
 
   if (ObjCPropertyImplDecl *PropertyImpDecl =
-      getObjCPropertyImplDeclForPropertyDecl(PD, Container)) {
-    if (PropertyImpDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
+          getObjCPropertyImplDeclForPropertyDecl(PD, Container)) {
+    if (PropertyImpDecl->getPropertyImplementation() ==
+        ObjCPropertyImplDecl::Dynamic)
       Dynamic = true;
     else
       SynthesizePID = PropertyImpDecl;
@@ -7222,10 +7170,17 @@
       S += ",W";
   } else {
     switch (PD->getSetterKind()) {
-    case ObjCPropertyDecl::Assign: break;
-    case ObjCPropertyDecl::Copy:   S += ",C"; break;
-    case ObjCPropertyDecl::Retain: S += ",&"; break;
-    case ObjCPropertyDecl::Weak:   S += ",W"; break;
+    case ObjCPropertyDecl::Assign:
+      break;
+    case ObjCPropertyDecl::Copy:
+      S += ",C";
+      break;
+    case ObjCPropertyDecl::Retain:
+      S += ",&";
+      break;
+    case ObjCPropertyDecl::Weak:
+      S += ",W";
+      break;
     }
   }
 
@@ -7248,7 +7203,7 @@
   }
 
   if (SynthesizePID) {
-    const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
+    ObjCIvarDecl const *OID = SynthesizePID->getPropertyIvarDecl();
     S += ",V";
     S += OID->getNameAsString();
   }
@@ -7261,20 +7216,20 @@
 /// Another legacy compatibility encoding: 32-bit longs are encoded as
 /// 'l' or 'L' , but not always.  For typedefs, we need to use
 /// 'i' or 'I' instead if encoding a struct field, or a pointer!
-void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const {
+void ASTContext::getLegacyIntegralTypeEncoding(QualType &PointeeTy) const {
   if (isa<TypedefType>(PointeeTy.getTypePtr())) {
-    if (const auto *BT = PointeeTy->getAs<BuiltinType>()) {
+    if (auto const *BT = PointeeTy->getAs<BuiltinType>()) {
       if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32)
         PointeeTy = UnsignedIntTy;
-      else
-        if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32)
-          PointeeTy = IntTy;
+      else if (BT->getKind() == BuiltinType::Long &&
+               getIntWidth(PointeeTy) == 32)
+        PointeeTy = IntTy;
     }
   }
 }
 
-void ASTContext::getObjCEncodingForType(QualType T, std::string& S,
-                                        const FieldDecl *Field,
+void ASTContext::getObjCEncodingForType(QualType T, std::string &S,
+                                        FieldDecl const *Field,
                                         QualType *NotEncodedT) const {
   // We follow the behavior of gcc, expanding structures which are
   // directly pointed to, and expanding embedded structures. Note that
@@ -7289,7 +7244,7 @@
 }
 
 void ASTContext::getObjCEncodingForPropertyType(QualType T,
-                                                std::string& S) const {
+                                                std::string &S) const {
   // Encode result type.
   // GCC has some special rules regarding encoding of properties which
   // closely resembles encoding of ivars.
@@ -7302,114 +7257,126 @@
                              /*Field=*/nullptr);
 }
 
-static char getObjCEncodingForPrimitiveType(const ASTContext *C,
-                                            const BuiltinType *BT) {
-    BuiltinType::Kind kind = BT->getKind();
-    switch (kind) {
-    case BuiltinType::Void:       return 'v';
-    case BuiltinType::Bool:       return 'B';
-    case BuiltinType::Char8:
-    case BuiltinType::Char_U:
-    case BuiltinType::UChar:      return 'C';
-    case BuiltinType::Char16:
-    case BuiltinType::UShort:     return 'S';
-    case BuiltinType::Char32:
-    case BuiltinType::UInt:       return 'I';
-    case BuiltinType::ULong:
-        return C->getTargetInfo().getLongWidth() == 32 ? 'L' : 'Q';
-    case BuiltinType::UInt128:    return 'T';
-    case BuiltinType::ULongLong:  return 'Q';
-    case BuiltinType::Char_S:
-    case BuiltinType::SChar:      return 'c';
-    case BuiltinType::Short:      return 's';
-    case BuiltinType::WChar_S:
-    case BuiltinType::WChar_U:
-    case BuiltinType::Int:        return 'i';
-    case BuiltinType::Long:
-      return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
-    case BuiltinType::LongLong:   return 'q';
-    case BuiltinType::Int128:     return 't';
-    case BuiltinType::Float:      return 'f';
-    case BuiltinType::Double:     return 'd';
-    case BuiltinType::LongDouble: return 'D';
-    case BuiltinType::NullPtr:    return '*'; // like char*
+static char getObjCEncodingForPrimitiveType(ASTContext const *C,
+                                            BuiltinType const *BT) {
+  BuiltinType::Kind kind = BT->getKind();
+  switch (kind) {
+  case BuiltinType::Void:
+    return 'v';
+  case BuiltinType::Bool:
+    return 'B';
+  case BuiltinType::Char8:
+  case BuiltinType::Char_U:
+  case BuiltinType::UChar:
+    return 'C';
+  case BuiltinType::Char16:
+  case BuiltinType::UShort:
+    return 'S';
+  case BuiltinType::Char32:
+  case BuiltinType::UInt:
+    return 'I';
+  case BuiltinType::ULong:
+    return C->getTargetInfo().getLongWidth() == 32 ? 'L' : 'Q';
+  case BuiltinType::UInt128:
+    return 'T';
+  case BuiltinType::ULongLong:
+    return 'Q';
+  case BuiltinType::Char_S:
+  case BuiltinType::SChar:
+    return 'c';
+  case BuiltinType::Short:
+    return 's';
+  case BuiltinType::WChar_S:
+  case BuiltinType::WChar_U:
+  case BuiltinType::Int:
+    return 'i';
+  case BuiltinType::Long:
+    return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
+  case BuiltinType::LongLong:
+    return 'q';
+  case BuiltinType::Int128:
+    return 't';
+  case BuiltinType::Float:
+    return 'f';
+  case BuiltinType::Double:
+    return 'd';
+  case BuiltinType::LongDouble:
+    return 'D';
+  case BuiltinType::NullPtr:
+    return '*'; // like char*
 
-    case BuiltinType::BFloat16:
-    case BuiltinType::Float16:
-    case BuiltinType::Float128:
-    case BuiltinType::Ibm128:
-    case BuiltinType::Half:
-    case BuiltinType::ShortAccum:
-    case BuiltinType::Accum:
-    case BuiltinType::LongAccum:
-    case BuiltinType::UShortAccum:
-    case BuiltinType::UAccum:
-    case BuiltinType::ULongAccum:
-    case BuiltinType::ShortFract:
-    case BuiltinType::Fract:
-    case BuiltinType::LongFract:
-    case BuiltinType::UShortFract:
-    case BuiltinType::UFract:
-    case BuiltinType::ULongFract:
-    case BuiltinType::SatShortAccum:
-    case BuiltinType::SatAccum:
-    case BuiltinType::SatLongAccum:
-    case BuiltinType::SatUShortAccum:
-    case BuiltinType::SatUAccum:
-    case BuiltinType::SatULongAccum:
-    case BuiltinType::SatShortFract:
-    case BuiltinType::SatFract:
-    case BuiltinType::SatLongFract:
-    case BuiltinType::SatUShortFract:
-    case BuiltinType::SatUFract:
-    case BuiltinType::SatULongFract:
-      // FIXME: potentially need @encodes for these!
-      return ' ';
+  case BuiltinType::BFloat16:
+  case BuiltinType::Float16:
+  case BuiltinType::Float128:
+  case BuiltinType::Ibm128:
+  case BuiltinType::Half:
+  case BuiltinType::ShortAccum:
+  case BuiltinType::Accum:
+  case BuiltinType::LongAccum:
+  case BuiltinType::UShortAccum:
+  case BuiltinType::UAccum:
+  case BuiltinType::ULongAccum:
+  case BuiltinType::ShortFract:
+  case BuiltinType::Fract:
+  case BuiltinType::LongFract:
+  case BuiltinType::UShortFract:
+  case BuiltinType::UFract:
+  case BuiltinType::ULongFract:
+  case BuiltinType::SatShortAccum:
+  case BuiltinType::SatAccum:
+  case BuiltinType::SatLongAccum:
+  case BuiltinType::SatUShortAccum:
+  case BuiltinType::SatUAccum:
+  case BuiltinType::SatULongAccum:
+  case BuiltinType::SatShortFract:
+  case BuiltinType::SatFract:
+  case BuiltinType::SatLongFract:
+  case BuiltinType::SatUShortFract:
+  case BuiltinType::SatUFract:
+  case BuiltinType::SatULongFract:
+    // FIXME: potentially need @encodes for these!
+    return ' ';
 
-#define SVE_TYPE(Name, Id, SingletonId) \
-    case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
-      {
-        DiagnosticsEngine &Diags = C->getDiagnostics();
-        unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-                                                "cannot yet @encode type %0");
-        Diags.Report(DiagID) << BT->getName(C->getPrintingPolicy());
-        return ' ';
-      }
+    {
+      DiagnosticsEngine &Diags = C->getDiagnostics();
+      unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
+                                              "cannot yet @encode type %0");
+      Diags.Report(DiagID) << BT->getName(C->getPrintingPolicy());
+      return ' ';
+    }
 
-    case BuiltinType::ObjCId:
-    case BuiltinType::ObjCClass:
-    case BuiltinType::ObjCSel:
-      llvm_unreachable("@encoding ObjC primitive type");
+  case BuiltinType::ObjCId:
+  case BuiltinType::ObjCClass:
+  case BuiltinType::ObjCSel:
+    llvm_unreachable("@encoding ObjC primitive type");
 
     // OpenCL and placeholder types don't need @encodings.
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-    case BuiltinType::Id:
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
+  case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-    case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
 #include "clang/Basic/OpenCLExtensionTypes.def"
-    case BuiltinType::OCLEvent:
-    case BuiltinType::OCLClkEvent:
-    case BuiltinType::OCLQueue:
-    case BuiltinType::OCLReserveID:
-    case BuiltinType::OCLSampler:
-    case BuiltinType::Dependent:
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-    case BuiltinType::Id:
+  case BuiltinType::OCLEvent:
+  case BuiltinType::OCLClkEvent:
+  case BuiltinType::OCLQueue:
+  case BuiltinType::OCLReserveID:
+  case BuiltinType::OCLSampler:
+  case BuiltinType::Dependent:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define BUILTIN_TYPE(KIND, ID)
-#define PLACEHOLDER_TYPE(KIND, ID) \
-    case BuiltinType::KIND:
+#define PLACEHOLDER_TYPE(KIND, ID) case BuiltinType::KIND:
 #include "clang/AST/BuiltinTypes.def"
-      llvm_unreachable("invalid builtin type for @encode");
-    }
-    llvm_unreachable("invalid BuiltinType::Kind value");
+    llvm_unreachable("invalid builtin type for @encode");
+  }
+  llvm_unreachable("invalid BuiltinType::Kind value");
 }
 
-static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) {
+static char ObjCEncodingForEnumType(ASTContext const *C, EnumType const *ET) {
   EnumDecl *Enum = ET->getDecl();
 
   // The encoding of an non-fixed enum type is always 'i', regardless of size.
@@ -7417,12 +7384,12 @@
     return 'i';
 
   // The encoding of a fixed enum type matches its fixed underlying type.
-  const auto *BT = Enum->getIntegerType()->castAs<BuiltinType>();
+  auto const *BT = Enum->getIntegerType()->castAs<BuiltinType>();
   return getObjCEncodingForPrimitiveType(C, BT);
 }
 
-static void EncodeBitField(const ASTContext *Ctx, std::string& S,
-                           QualType T, const FieldDecl *FD) {
+static void EncodeBitField(ASTContext const *Ctx, std::string &S, QualType T,
+                           FieldDecl const *FD) {
   assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl");
   S += 'b';
   // The NeXT runtime encodes bit fields as b followed by the number of bits.
@@ -7443,21 +7410,21 @@
   if (Ctx->getLangOpts().ObjCRuntime.isGNUFamily()) {
     uint64_t Offset;
 
-    if (const auto *IVD = dyn_cast<ObjCIvarDecl>(FD)) {
+    if (auto const *IVD = dyn_cast<ObjCIvarDecl>(FD)) {
       Offset = Ctx->lookupFieldBitOffset(IVD->getContainingInterface(), nullptr,
                                          IVD);
     } else {
-      const RecordDecl *RD = FD->getParent();
-      const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD);
+      RecordDecl const *RD = FD->getParent();
+      ASTRecordLayout const &RL = Ctx->getASTRecordLayout(RD);
       Offset = RL.getFieldOffset(FD->getFieldIndex());
     }
 
     S += llvm::utostr(Offset);
 
-    if (const auto *ET = T->getAs<EnumType>())
+    if (auto const *ET = T->getAs<EnumType>())
       S += ObjCEncodingForEnumType(Ctx, ET);
     else {
-      const auto *BT = T->castAs<BuiltinType>();
+      auto const *BT = T->castAs<BuiltinType>();
       S += getObjCEncodingForPrimitiveType(Ctx, BT);
     }
   }
@@ -7466,7 +7433,7 @@
 
 // Helper function for determining whether the encoded type string would include
 // a template specialization type.
-static bool hasTemplateSpecializationInEncodedString(const Type *T,
+static bool hasTemplateSpecializationInEncodedString(Type const *T,
                                                      bool VisitBasesAndFields) {
   T = T->getBaseElementTypeUnsafe();
 
@@ -7501,7 +7468,7 @@
 // FIXME: Use SmallString for accumulating string.
 void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string &S,
                                             const ObjCEncOptions Options,
-                                            const FieldDecl *FD,
+                                            FieldDecl const *FD,
                                             QualType *NotEncodedT) const {
   CanQualType CT = getCanonicalType(T);
   switch (CT->getTypeClass()) {
@@ -7509,7 +7476,7 @@
   case Type::Enum:
     if (FD && FD->isBitField())
       return EncodeBitField(this, S, T, FD);
-    if (const auto *BT = dyn_cast<BuiltinType>(CT))
+    if (auto const *BT = dyn_cast<BuiltinType>(CT))
       S += getObjCEncodingForPrimitiveType(this, BT);
     else
       S += ObjCEncodingForEnumType(this, cast<EnumType>(CT));
@@ -7535,7 +7502,7 @@
   case Type::RValueReference: {
     QualType PointeeTy;
     if (isa<PointerType>(CT)) {
-      const auto *PT = T->castAs<PointerType>();
+      auto const *PT = T->castAs<PointerType>();
       if (PT->isObjCSelType()) {
         S += ':';
         return;
@@ -7569,7 +7536,7 @@
       // combinations need to be rearranged.
       // Rewrite "in const" from "nr" to "rn"
       if (StringRef(S).endswith("nr"))
-        S.replace(S.end()-2, S.end(), "rn");
+        S.replace(S.end() - 2, S.end(), "rn");
     }
 
     if (PointeeTy->isCharType()) {
@@ -7579,7 +7546,7 @@
         S += '*';
         return;
       }
-    } else if (const auto *RTy = PointeeTy->getAs<RecordType>()) {
+    } else if (auto const *RTy = PointeeTy->getAs<RecordType>()) {
       // GCC binary compat: Need to convert "struct objc_class *" to "#".
       if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
         S += '#';
@@ -7615,7 +7582,7 @@
   case Type::ConstantArray:
   case Type::IncompleteArray:
   case Type::VariableArray: {
-    const auto *AT = cast<ArrayType>(CT);
+    auto const *AT = cast<ArrayType>(CT);
 
     if (isa<IncompleteArrayType>(AT) && !Options.IsStructField()) {
       // Incomplete arrays are encoded as a pointer to the array element.
@@ -7627,10 +7594,11 @@
     } else {
       S += '[';
 
-      if (const auto *CAT = dyn_cast<ConstantArrayType>(AT))
+      if (auto const *CAT = dyn_cast<ConstantArrayType>(AT))
         S += llvm::utostr(CAT->getSize().getZExtValue());
       else {
-        //Variable length arrays are encoded as a regular array with 0 elements.
+        // Variable length arrays are encoded as a regular array with 0
+        // elements.
         assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) &&
                "Unknown array type!");
         S += '0';
@@ -7654,10 +7622,10 @@
     RecordDecl *RDecl = cast<RecordType>(CT)->getDecl();
     S += RDecl->isUnion() ? '(' : '{';
     // Anonymous structures print as '?'
-    if (const IdentifierInfo *II = RDecl->getIdentifier()) {
+    if (IdentifierInfo const *II = RDecl->getIdentifier()) {
       S += II->getName();
-      if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
-        const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
+      if (auto const *Spec = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
+        TemplateArgumentList const &TemplateArgs = Spec->getTemplateArgs();
         llvm::raw_string_ostream OS(S);
         printTemplateArgumentList(OS, TemplateArgs.asArray(),
                                   getPrintingPolicy());
@@ -7670,7 +7638,7 @@
       if (!RDecl->isUnion()) {
         getObjCEncodingForStructureImpl(RDecl, S, FD, true, NotEncodedT);
       } else {
-        for (const auto *Field : RDecl->fields()) {
+        for (auto const *Field : RDecl->fields()) {
           if (FD) {
             S += '"';
             S += Field->getNameAsString();
@@ -7698,10 +7666,10 @@
   }
 
   case Type::BlockPointer: {
-    const auto *BT = T->castAs<BlockPointerType>();
+    auto const *BT = T->castAs<BlockPointerType>();
     S += "@?"; // Unlike a pointer-to-function, which is "^?".
     if (Options.EncodeBlockParameters()) {
-      const auto *FT = BT->getPointeeType()->castAs<FunctionType>();
+      auto const *FT = BT->getPointeeType()->castAs<FunctionType>();
 
       S += '<';
       // Block return type
@@ -7710,8 +7678,8 @@
       // Block self
       S += "@?";
       // Block parameters
-      if (const auto *FPT = dyn_cast<FunctionProtoType>(FT)) {
-        for (const auto &I : FPT->param_types())
+      if (auto const *FPT = dyn_cast<FunctionProtoType>(FT)) {
+        for (auto const &I : FPT->param_types())
           getObjCEncodingForTypeImpl(I, S, Options.forComponentType(), FD,
                                      NotEncodedT);
       }
@@ -7726,8 +7694,7 @@
     if (Ty->isObjCIdType()) {
       S += "{objc_object=}";
       return;
-    }
-    else if (Ty->isObjCClassType()) {
+    } else if (Ty->isObjCClassType()) {
       S += "{objc_class=}";
       return;
     }
@@ -7743,10 +7710,10 @@
     S += OI->getObjCRuntimeNameAsString();
     if (Options.ExpandStructures()) {
       S += '=';
-      SmallVector<const ObjCIvarDecl*, 32> Ivars;
+      SmallVector<ObjCIvarDecl const *, 32> Ivars;
       DeepCollectObjCIvars(OI, true, Ivars);
       for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
-        const FieldDecl *Field = Ivars[i];
+        FieldDecl const *Field = Ivars[i];
         if (Field->isBitField())
           getObjCEncodingForTypeImpl(Field->getType(), S,
                                      ObjCEncOptions().setExpandStructures(),
@@ -7762,7 +7729,7 @@
   }
 
   case Type::ObjCObjectPointer: {
-    const auto *OPT = T->castAs<ObjCObjectPointerType>();
+    auto const *OPT = T->castAs<ObjCObjectPointerType>();
     if (OPT->isObjCIdType()) {
       S += '@';
       return;
@@ -7787,7 +7754,7 @@
         // Note that we do extended encoding of protocol qualifer list
         // Only when doing ivar or property encoding.
         S += '"';
-        for (const auto *I : OPT->quals()) {
+        for (auto const *I : OPT->quals()) {
           S += '<';
           S += I->getObjCRuntimeNameAsString();
           S += '>';
@@ -7802,7 +7769,7 @@
         (FD || Options.EncodingProperty() || Options.EncodeClassNames())) {
       S += '"';
       S += OPT->getInterfaceDecl()->getObjCRuntimeNameAsString();
-      for (const auto *I : OPT->quals()) {
+      for (auto const *I : OPT->quals()) {
         S += '<';
         S += I->getObjCRuntimeNameAsString();
         S += '>';
@@ -7816,10 +7783,10 @@
   // FIXME: we should do better than that.  'M' is available.
   case Type::MemberPointer:
   // This matches gcc's encoding, even though technically it is insufficient.
-  //FIXME. We should do a better job than gcc.
+  // FIXME. We should do a better job than gcc.
   case Type::Vector:
   case Type::ExtVector:
-  // Until we have a coherent encoding of these three types, issue warning.
+    // Until we have a coherent encoding of these three types, issue warning.
     if (NotEncodedT)
       *NotEncodedT = T;
     return;
@@ -7839,12 +7806,9 @@
   case Type::ExtInt:
 #define ABSTRACT_TYPE(KIND, BASE)
 #define TYPE(KIND, BASE)
-#define DEPENDENT_TYPE(KIND, BASE) \
-  case Type::KIND:
-#define NON_CANONICAL_TYPE(KIND, BASE) \
-  case Type::KIND:
-#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \
-  case Type::KIND:
+#define DEPENDENT_TYPE(KIND, BASE) case Type::KIND:
+#define NON_CANONICAL_TYPE(KIND, BASE) case Type::KIND:
+#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) case Type::KIND:
 #include "clang/AST/TypeNodes.inc"
     llvm_unreachable("@encode for dependent type!");
   }
@@ -7853,7 +7817,7 @@
 
 void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl,
                                                  std::string &S,
-                                                 const FieldDecl *FD,
+                                                 FieldDecl const *FD,
                                                  bool includeVBases,
                                                  QualType *NotEncodedT) const {
   assert(RDecl && "Expected non-null RecordDecl");
@@ -7861,12 +7825,12 @@
   if (!RDecl->getDefinition() || RDecl->getDefinition()->isInvalidDecl())
     return;
 
-  const auto *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
+  auto const *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
   std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;
-  const ASTRecordLayout &layout = getASTRecordLayout(RDecl);
+  ASTRecordLayout const &layout = getASTRecordLayout(RDecl);
 
   if (CXXRec) {
-    for (const auto &BI : CXXRec->bases()) {
+    for (auto const &BI : CXXRec->bases()) {
       if (!BI.isVirtual()) {
         CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
         if (base->isEmpty())
@@ -7889,7 +7853,7 @@
   }
 
   if (CXXRec && includeVBases) {
-    for (const auto &BI : CXXRec->vbases()) {
+    for (auto const &BI : CXXRec->vbases()) {
       CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
       if (base->isEmpty())
         continue;
@@ -7911,15 +7875,16 @@
 #ifndef NDEBUG
   uint64_t CurOffs = 0;
 #endif
-  std::multimap<uint64_t, NamedDecl *>::iterator
-    CurLayObj = FieldOrBaseOffsets.begin();
+  std::multimap<uint64_t, NamedDecl *>::iterator CurLayObj =
+      FieldOrBaseOffsets.begin();
 
   if (CXXRec && CXXRec->isDynamicClass() &&
       (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
     if (FD) {
       S += "\"_vptr$";
       std::string recname = CXXRec->getNameAsString();
-      if (recname.empty()) recname = "?";
+      if (recname.empty())
+        recname = "?";
       S += recname;
       S += '"';
     }
@@ -7961,14 +7926,14 @@
       // in the initial structure. Note that this differs from gcc which
       // expands virtual bases each time one is encountered in the hierarchy,
       // making the encoding type bigger than it really is.
-      getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false,
+      getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/ false,
                                       NotEncodedT);
       assert(!base->isEmpty());
 #ifndef NDEBUG
       CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize());
 #endif
     } else {
-      const auto *field = cast<FieldDecl>(dcl);
+      auto const *field = cast<FieldDecl>(dcl);
       if (FD) {
         S += '"';
         S += field->getNameAsString();
@@ -7995,7 +7960,7 @@
 }
 
 void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
-                                                 std::string& S) const {
+                                                 std::string &S) const {
   if (QT & Decl::OBJC_TQ_In)
     S += 'n';
   if (QT & Decl::OBJC_TQ_Inout)
@@ -8038,13 +8003,11 @@
 
 ObjCInterfaceDecl *ASTContext::getObjCProtocolDecl() const {
   if (!ObjCProtocolClassDecl) {
-    ObjCProtocolClassDecl
-      = ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(),
-                                  SourceLocation(),
-                                  &Idents.get("Protocol"),
+    ObjCProtocolClassDecl =
+        ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(),
+                                  SourceLocation(), &Idents.get("Protocol"),
                                   /*typeParamList=*/nullptr,
-                                  /*PrevDecl=*/nullptr,
-                                  SourceLocation(), true);
+                                  /*PrevDecl=*/nullptr, SourceLocation(), true);
   }
 
   return ObjCProtocolClassDecl;
@@ -8054,29 +8017,29 @@
 // __builtin_va_list Construction Functions
 //===----------------------------------------------------------------------===//
 
-static TypedefDecl *CreateCharPtrNamedVaListDecl(const ASTContext *Context,
+static TypedefDecl *CreateCharPtrNamedVaListDecl(ASTContext const *Context,
                                                  StringRef Name) {
   // typedef char* __builtin[_ms]_va_list;
   QualType T = Context->getPointerType(Context->CharTy);
   return Context->buildImplicitTypedef(T, Name);
 }
 
-static TypedefDecl *CreateMSVaListDecl(const ASTContext *Context) {
+static TypedefDecl *CreateMSVaListDecl(ASTContext const *Context) {
   return CreateCharPtrNamedVaListDecl(Context, "__builtin_ms_va_list");
 }
 
-static TypedefDecl *CreateCharPtrBuiltinVaListDecl(const ASTContext *Context) {
+static TypedefDecl *CreateCharPtrBuiltinVaListDecl(ASTContext const *Context) {
   return CreateCharPtrNamedVaListDecl(Context, "__builtin_va_list");
 }
 
-static TypedefDecl *CreateVoidPtrBuiltinVaListDecl(const ASTContext *Context) {
+static TypedefDecl *CreateVoidPtrBuiltinVaListDecl(ASTContext const *Context) {
   // typedef void* __builtin_va_list;
   QualType T = Context->getPointerType(Context->VoidTy);
   return Context->buildImplicitTypedef(T, "__builtin_va_list");
 }
 
 static TypedefDecl *
-CreateAArch64ABIBuiltinVaListDecl(const ASTContext *Context) {
+CreateAArch64ABIBuiltinVaListDecl(ASTContext const *Context) {
   RecordDecl *VaListTagDecl = Context->buildImplicitRecord("__va_list");
   // namespace std { struct __va_list {
   // Note that we create the namespace even in C. This is intentional so that
@@ -8097,7 +8060,7 @@
 
   const size_t NumFields = 5;
   QualType FieldTypes[NumFields];
-  const char *FieldNames[NumFields];
+  char const *FieldNames[NumFields];
 
   // void *__stack;
   FieldTypes[0] = Context->getPointerType(Context->VoidTy);
@@ -8121,15 +8084,12 @@
 
   // Create fields
   for (unsigned i = 0; i < NumFields; ++i) {
-    FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
-                                         VaListTagDecl,
-                                         SourceLocation(),
-                                         SourceLocation(),
-                                         &Context->Idents.get(FieldNames[i]),
-                                         FieldTypes[i], /*TInfo=*/nullptr,
-                                         /*BitWidth=*/nullptr,
-                                         /*Mutable=*/false,
-                                         ICIS_NoInit);
+    FieldDecl *Field = FieldDecl::Create(
+        const_cast<ASTContext &>(*Context), VaListTagDecl, SourceLocation(),
+        SourceLocation(), &Context->Idents.get(FieldNames[i]), FieldTypes[i],
+        /*TInfo=*/nullptr,
+        /*BitWidth=*/nullptr,
+        /*Mutable=*/false, ICIS_NoInit);
     Field->setAccess(AS_public);
     VaListTagDecl->addDecl(Field);
   }
@@ -8141,7 +8101,7 @@
   return Context->buildImplicitTypedef(VaListTagType, "__builtin_va_list");
 }
 
-static TypedefDecl *CreatePowerABIBuiltinVaListDecl(const ASTContext *Context) {
+static TypedefDecl *CreatePowerABIBuiltinVaListDecl(ASTContext const *Context) {
   // typedef struct __va_list_tag {
   RecordDecl *VaListTagDecl;
 
@@ -8150,7 +8110,7 @@
 
   const size_t NumFields = 5;
   QualType FieldTypes[NumFields];
-  const char *FieldNames[NumFields];
+  char const *FieldNames[NumFields];
 
   //   unsigned char gpr;
   FieldTypes[0] = Context->UnsignedCharTy;
@@ -8174,14 +8134,11 @@
 
   // Create fields
   for (unsigned i = 0; i < NumFields; ++i) {
-    FieldDecl *Field = FieldDecl::Create(*Context, VaListTagDecl,
-                                         SourceLocation(),
-                                         SourceLocation(),
-                                         &Context->Idents.get(FieldNames[i]),
-                                         FieldTypes[i], /*TInfo=*/nullptr,
-                                         /*BitWidth=*/nullptr,
-                                         /*Mutable=*/false,
-                                         ICIS_NoInit);
+    FieldDecl *Field = FieldDecl::Create(
+        *Context, VaListTagDecl, SourceLocation(), SourceLocation(),
+        &Context->Idents.get(FieldNames[i]), FieldTypes[i], /*TInfo=*/nullptr,
+        /*BitWidth=*/nullptr,
+        /*Mutable=*/false, ICIS_NoInit);
     Field->setAccess(AS_public);
     VaListTagDecl->addDecl(Field);
   }
@@ -8193,19 +8150,17 @@
   TypedefDecl *VaListTagTypedefDecl =
       Context->buildImplicitTypedef(VaListTagType, "__va_list_tag");
 
-  QualType VaListTagTypedefType =
-    Context->getTypedefType(VaListTagTypedefDecl);
+  QualType VaListTagTypedefType = Context->getTypedefType(VaListTagTypedefDecl);
 
   // typedef __va_list_tag __builtin_va_list[1];
   llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
-  QualType VaListTagArrayType
-    = Context->getConstantArrayType(VaListTagTypedefType,
-                                    Size, nullptr, ArrayType::Normal, 0);
+  QualType VaListTagArrayType = Context->getConstantArrayType(
+      VaListTagTypedefType, Size, nullptr, ArrayType::Normal, 0);
   return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
 }
 
 static TypedefDecl *
-CreateX86_64ABIBuiltinVaListDecl(const ASTContext *Context) {
+CreateX86_64ABIBuiltinVaListDecl(ASTContext const *Context) {
   // struct __va_list_tag {
   RecordDecl *VaListTagDecl;
   VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
@@ -8213,7 +8168,7 @@
 
   const size_t NumFields = 4;
   QualType FieldTypes[NumFields];
-  const char *FieldNames[NumFields];
+  char const *FieldNames[NumFields];
 
   //   unsigned gp_offset;
   FieldTypes[0] = Context->UnsignedIntTy;
@@ -8233,15 +8188,12 @@
 
   // Create fields
   for (unsigned i = 0; i < NumFields; ++i) {
-    FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
-                                         VaListTagDecl,
-                                         SourceLocation(),
-                                         SourceLocation(),
-                                         &Context->Idents.get(FieldNames[i]),
-                                         FieldTypes[i], /*TInfo=*/nullptr,
-                                         /*BitWidth=*/nullptr,
-                                         /*Mutable=*/false,
-                                         ICIS_NoInit);
+    FieldDecl *Field = FieldDecl::Create(
+        const_cast<ASTContext &>(*Context), VaListTagDecl, SourceLocation(),
+        SourceLocation(), &Context->Idents.get(FieldNames[i]), FieldTypes[i],
+        /*TInfo=*/nullptr,
+        /*BitWidth=*/nullptr,
+        /*Mutable=*/false, ICIS_NoInit);
     Field->setAccess(AS_public);
     VaListTagDecl->addDecl(Field);
   }
@@ -8258,7 +8210,7 @@
   return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
 }
 
-static TypedefDecl *CreatePNaClABIBuiltinVaListDecl(const ASTContext *Context) {
+static TypedefDecl *CreatePNaClABIBuiltinVaListDecl(ASTContext const *Context) {
   // typedef int __builtin_va_list[4];
   llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 4);
   QualType IntArrayType = Context->getConstantArrayType(
@@ -8266,8 +8218,7 @@
   return Context->buildImplicitTypedef(IntArrayType, "__builtin_va_list");
 }
 
-static TypedefDecl *
-CreateAAPCSABIBuiltinVaListDecl(const ASTContext *Context) {
+static TypedefDecl *CreateAAPCSABIBuiltinVaListDecl(ASTContext const *Context) {
   // struct __va_list
   RecordDecl *VaListDecl = Context->buildImplicitRecord("__va_list");
   if (Context->getLangOpts().CPlusPlus) {
@@ -8275,7 +8226,7 @@
     NamespaceDecl *NS;
     NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
                                Context->getTranslationUnitDecl(),
-                               /*Inline*/false, SourceLocation(),
+                               /*Inline*/ false, SourceLocation(),
                                SourceLocation(), &Context->Idents.get("std"),
                                /*PrevDecl*/ nullptr);
     NS->setImplicit();
@@ -8285,16 +8236,13 @@
   VaListDecl->startDefinition();
 
   // void * __ap;
-  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
-                                       VaListDecl,
-                                       SourceLocation(),
-                                       SourceLocation(),
-                                       &Context->Idents.get("__ap"),
-                                       Context->getPointerType(Context->VoidTy),
-                                       /*TInfo=*/nullptr,
-                                       /*BitWidth=*/nullptr,
-                                       /*Mutable=*/false,
-                                       ICIS_NoInit);
+  FieldDecl *Field = FieldDecl::Create(
+      const_cast<ASTContext &>(*Context), VaListDecl, SourceLocation(),
+      SourceLocation(), &Context->Idents.get("__ap"),
+      Context->getPointerType(Context->VoidTy),
+      /*TInfo=*/nullptr,
+      /*BitWidth=*/nullptr,
+      /*Mutable=*/false, ICIS_NoInit);
   Field->setAccess(AS_public);
   VaListDecl->addDecl(Field);
 
@@ -8307,8 +8255,7 @@
   return Context->buildImplicitTypedef(T, "__builtin_va_list");
 }
 
-static TypedefDecl *
-CreateSystemZBuiltinVaListDecl(const ASTContext *Context) {
+static TypedefDecl *CreateSystemZBuiltinVaListDecl(ASTContext const *Context) {
   // struct __va_list_tag {
   RecordDecl *VaListTagDecl;
   VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
@@ -8316,7 +8263,7 @@
 
   const size_t NumFields = 4;
   QualType FieldTypes[NumFields];
-  const char *FieldNames[NumFields];
+  char const *FieldNames[NumFields];
 
   //   long __gpr;
   FieldTypes[0] = Context->LongTy;
@@ -8336,15 +8283,12 @@
 
   // Create fields
   for (unsigned i = 0; i < NumFields; ++i) {
-    FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
-                                         VaListTagDecl,
-                                         SourceLocation(),
-                                         SourceLocation(),
-                                         &Context->Idents.get(FieldNames[i]),
-                                         FieldTypes[i], /*TInfo=*/nullptr,
-                                         /*BitWidth=*/nullptr,
-                                         /*Mutable=*/false,
-                                         ICIS_NoInit);
+    FieldDecl *Field = FieldDecl::Create(
+        const_cast<ASTContext &>(*Context), VaListTagDecl, SourceLocation(),
+        SourceLocation(), &Context->Idents.get(FieldNames[i]), FieldTypes[i],
+        /*TInfo=*/nullptr,
+        /*BitWidth=*/nullptr,
+        /*Mutable=*/false, ICIS_NoInit);
     Field->setAccess(AS_public);
     VaListTagDecl->addDecl(Field);
   }
@@ -8362,7 +8306,7 @@
   return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
 }
 
-static TypedefDecl *CreateHexagonBuiltinVaListDecl(const ASTContext *Context) {
+static TypedefDecl *CreateHexagonBuiltinVaListDecl(ASTContext const *Context) {
   // typedef struct __va_list_tag {
   RecordDecl *VaListTagDecl;
   VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
@@ -8370,7 +8314,7 @@
 
   const size_t NumFields = 3;
   QualType FieldTypes[NumFields];
-  const char *FieldNames[NumFields];
+  char const *FieldNames[NumFields];
 
   //   void *CurrentSavedRegisterArea;
   FieldTypes[0] = Context->getPointerType(Context->VoidTy);
@@ -8413,7 +8357,7 @@
   return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
 }
 
-static TypedefDecl *CreateVaListDecl(const ASTContext *Context,
+static TypedefDecl *CreateVaListDecl(ASTContext const *Context,
                                      TargetInfo::BuiltinVaListKind Kind) {
   switch (Kind) {
   case TargetInfo::CharPtrBuiltinVaList:
@@ -8464,7 +8408,7 @@
   return BuiltinMSVaListDecl;
 }
 
-bool ASTContext::canBuiltinBeRedeclared(const FunctionDecl *FD) const {
+bool ASTContext::canBuiltinBeRedeclared(FunctionDecl const *FD) const {
   return BuiltinInfo.canBeRedeclared(FD->getBuiltinID());
 }
 
@@ -8484,14 +8428,13 @@
   assert(size > 1 && "set is not overloaded!");
 
   void *memory = Allocate(sizeof(OverloadedTemplateStorage) +
-                          size * sizeof(FunctionTemplateDecl*));
+                          size * sizeof(FunctionTemplateDecl *));
   auto *OT = new (memory) OverloadedTemplateStorage(size);
 
   NamedDecl **Storage = OT->getStorage();
   for (UnresolvedSetIterator I = Begin; I != End; ++I) {
     NamedDecl *D = *I;
-    assert(isa<FunctionTemplateDecl>(D) ||
-           isa<UnresolvedUsingValueDecl>(D) ||
+    assert(isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl>(D) ||
            (isa<UsingShadowDecl>(D) &&
             isa<FunctionTemplateDecl>(D->getUnderlyingDecl())));
     *Storage++ = D;
@@ -8521,7 +8464,7 @@
 
   void *InsertPos = nullptr;
   QualifiedTemplateName *QTN =
-    QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
+      QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
   if (!QTN) {
     QTN = new (*this, alignof(QualifiedTemplateName))
         QualifiedTemplateName(NNS, TemplateKeyword, Template);
@@ -8535,7 +8478,7 @@
 /// template name such as \c MetaFun::template apply.
 TemplateName
 ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
-                                     const IdentifierInfo *Name) const {
+                                     IdentifierInfo const *Name) const {
   assert((!NNS || NNS->isDependent()) &&
          "Nested name specifier must be dependent");
 
@@ -8544,7 +8487,7 @@
 
   void *InsertPos = nullptr;
   DependentTemplateName *QTN =
-    DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
+      DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
 
   if (QTN)
     return TemplateName(QTN);
@@ -8558,7 +8501,7 @@
     QTN = new (*this, alignof(DependentTemplateName))
         DependentTemplateName(NNS, Name, Canon);
     DependentTemplateName *CheckQTN =
-      DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
+        DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
     assert(!CheckQTN && "Dependent type name canonicalization broken");
     (void)CheckQTN;
   }
@@ -8579,8 +8522,8 @@
   DependentTemplateName::Profile(ID, NNS, Operator);
 
   void *InsertPos = nullptr;
-  DependentTemplateName *QTN
-    = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
+  DependentTemplateName *QTN =
+      DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
 
   if (QTN)
     return TemplateName(QTN);
@@ -8594,8 +8537,8 @@
     QTN = new (*this, alignof(DependentTemplateName))
         DependentTemplateName(NNS, Operator, Canon);
 
-    DependentTemplateName *CheckQTN
-      = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
+    DependentTemplateName *CheckQTN =
+        DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
     assert(!CheckQTN && "Dependent template name canonicalization broken");
     (void)CheckQTN;
   }
@@ -8611,8 +8554,8 @@
   SubstTemplateTemplateParmStorage::Profile(ID, param, replacement);
 
   void *insertPos = nullptr;
-  SubstTemplateTemplateParmStorage *subst
-    = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);
+  SubstTemplateTemplateParmStorage *subst =
+      SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);
 
   if (!subst) {
     subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement);
@@ -8622,21 +8565,19 @@
   return TemplateName(subst);
 }
 
-TemplateName
-ASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param,
-                                       const TemplateArgument &ArgPack) const {
+TemplateName ASTContext::getSubstTemplateTemplateParmPack(
+    TemplateTemplateParmDecl *Param, TemplateArgument const &ArgPack) const {
   auto &Self = const_cast<ASTContext &>(*this);
   llvm::FoldingSetNodeID ID;
   SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack);
 
   void *InsertPos = nullptr;
-  SubstTemplateTemplateParmPackStorage *Subst
-    = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);
+  SubstTemplateTemplateParmPackStorage *Subst =
+      SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!Subst) {
-    Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param,
-                                                           ArgPack.pack_size(),
-                                                         ArgPack.pack_begin());
+    Subst = new (*this) SubstTemplateTemplateParmPackStorage(
+        Param, ArgPack.pack_size(), ArgPack.pack_begin());
     SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
   }
 
@@ -8648,17 +8589,28 @@
 /// is actually a value of type @c TargetInfo::IntType.
 CanQualType ASTContext::getFromTargetType(unsigned Type) const {
   switch (Type) {
-  case TargetInfo::NoInt: return {};
-  case TargetInfo::SignedChar: return SignedCharTy;
-  case TargetInfo::UnsignedChar: return UnsignedCharTy;
-  case TargetInfo::SignedShort: return ShortTy;
-  case TargetInfo::UnsignedShort: return UnsignedShortTy;
-  case TargetInfo::SignedInt: return IntTy;
-  case TargetInfo::UnsignedInt: return UnsignedIntTy;
-  case TargetInfo::SignedLong: return LongTy;
-  case TargetInfo::UnsignedLong: return UnsignedLongTy;
-  case TargetInfo::SignedLongLong: return LongLongTy;
-  case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy;
+  case TargetInfo::NoInt:
+    return {};
+  case TargetInfo::SignedChar:
+    return SignedCharTy;
+  case TargetInfo::UnsignedChar:
+    return UnsignedCharTy;
+  case TargetInfo::SignedShort:
+    return ShortTy;
+  case TargetInfo::UnsignedShort:
+    return UnsignedShortTy;
+  case TargetInfo::SignedInt:
+    return IntTy;
+  case TargetInfo::UnsignedInt:
+    return UnsignedIntTy;
+  case TargetInfo::SignedLong:
+    return LongTy;
+  case TargetInfo::UnsignedLong:
+    return UnsignedLongTy;
+  case TargetInfo::SignedLongLong:
+    return LongLongTy;
+  case TargetInfo::UnsignedLongLong:
+    return UnsignedLongLongTy;
   }
 
   llvm_unreachable("Unhandled TargetInfo::IntType value");
@@ -8691,7 +8643,7 @@
     // pointer.
 #ifndef NDEBUG
     QualType CT = Ty->getCanonicalTypeInternal();
-    while (const auto *AT = dyn_cast<ArrayType>(CT))
+    while (auto const *AT = dyn_cast<ArrayType>(CT))
       CT = AT->getElementType();
     assert(CT->isAnyPointerType() || CT->isBlockPointerType());
 #endif
@@ -8705,8 +8657,7 @@
 
 /// areCompatVectorTypes - Return true if the two specified vector types are
 /// compatible.
-static bool areCompatVectorTypes(const VectorType *LHS,
-                                 const VectorType *RHS) {
+static bool areCompatVectorTypes(VectorType const *LHS, VectorType const *RHS) {
   assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified());
   return LHS->getElementType() == RHS->getElementType() &&
          LHS->getNumElements() == RHS->getNumElements();
@@ -8714,8 +8665,8 @@
 
 /// areCompatMatrixTypes - Return true if the two specified matrix types are
 /// compatible.
-static bool areCompatMatrixTypes(const ConstantMatrixType *LHS,
-                                 const ConstantMatrixType *RHS) {
+static bool areCompatMatrixTypes(ConstantMatrixType const *LHS,
+                                 ConstantMatrixType const *RHS) {
   assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified());
   return LHS->getElementType() == RHS->getElementType() &&
          LHS->getNumRows() == RHS->getNumRows() &&
@@ -8732,8 +8683,8 @@
 
   // Treat Neon vector types and most AltiVec vector types as if they are the
   // equivalent GCC vector types.
-  const auto *First = FirstVec->castAs<VectorType>();
-  const auto *Second = SecondVec->castAs<VectorType>();
+  auto const *First = FirstVec->castAs<VectorType>();
+  auto const *Second = SecondVec->castAs<VectorType>();
   if (First->getNumElements() == Second->getNumElements() &&
       hasSameType(First->getElementType(), Second->getElementType()) &&
       First->getVectorKind() != VectorType::AltiVecPixel &&
@@ -8750,7 +8701,7 @@
 }
 
 /// getSVETypeSize - Return SVE vector or predicate register size.
-static uint64_t getSVETypeSize(ASTContext &Context, const BuiltinType *Ty) {
+static uint64_t getSVETypeSize(ASTContext &Context, BuiltinType const *Ty) {
   assert(Ty->isVLSTBuiltinType() && "Invalid SVE Type");
   return Ty->getKind() == BuiltinType::SveBool
              ? Context.getLangOpts().ArmSveVectorBits / Context.getCharWidth()
@@ -8841,19 +8792,19 @@
 bool ASTContext::hasDirectOwnershipQualifier(QualType Ty) const {
   while (true) {
     // __strong id
-    if (const AttributedType *Attr = dyn_cast<AttributedType>(Ty)) {
+    if (AttributedType const *Attr = dyn_cast<AttributedType>(Ty)) {
       if (Attr->getAttrKind() == attr::ObjCOwnership)
         return true;
 
       Ty = Attr->getModifiedType();
 
-    // X *__strong (...)
-    } else if (const ParenType *Paren = dyn_cast<ParenType>(Ty)) {
+      // X *__strong (...)
+    } else if (ParenType const *Paren = dyn_cast<ParenType>(Ty)) {
       Ty = Paren->getInnerType();
 
-    // We do not want to look through typedefs, typeof(expr),
-    // typeof(type), or any other way that the type is somehow
-    // abstracted.
+      // We do not want to look through typedefs, typeof(expr),
+      // typeof(type), or any other way that the type is somehow
+      // abstracted.
     } else {
       return false;
     }
@@ -8866,9 +8817,8 @@
 
 /// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
 /// inheritance hierarchy of 'rProto'.
-bool
-ASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
-                                           ObjCProtocolDecl *rProto) const {
+bool ASTContext::ProtocolCompatibleWithProtocol(
+    ObjCProtocolDecl *lProto, ObjCProtocolDecl *rProto) const {
   if (declaresSameEntity(lProto, rProto))
     return true;
   for (auto *PI : rProto->protocols())
@@ -8880,7 +8830,7 @@
 /// ObjCQualifiedClassTypesAreCompatible - compare  Class<pr,...> and
 /// Class<pr1, ...>.
 bool ASTContext::ObjCQualifiedClassTypesAreCompatible(
-    const ObjCObjectPointerType *lhs, const ObjCObjectPointerType *rhs) {
+    ObjCObjectPointerType const *lhs, ObjCObjectPointerType const *rhs) {
   for (auto *lhsProto : lhs->quals()) {
     bool match = false;
     for (auto *rhsProto : rhs->quals()) {
@@ -8898,7 +8848,7 @@
 /// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
 /// ObjCQualifiedIDType.
 bool ASTContext::ObjCQualifiedIdTypesAreCompatible(
-    const ObjCObjectPointerType *lhs, const ObjCObjectPointerType *rhs,
+    ObjCObjectPointerType const *lhs, ObjCObjectPointerType const *rhs,
     bool compare) {
   // Allow id<P..> and an 'id' in all cases.
   if (lhs->isObjCIdType() || rhs->isObjCIdType())
@@ -8983,7 +8933,8 @@
     }
 
     // Static class's protocols, or its super class or category protocols
-    // must be found, direct or indirect in rhs's qualifier list or it is a mismatch.
+    // must be found, direct or indirect in rhs's qualifier list or it is a
+    // mismatch.
     if (ObjCInterfaceDecl *lhsID = lhs->getInterfaceDecl()) {
       llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
       CollectInheritedProtocols(lhsID, LHSInheritedProtocols);
@@ -9013,10 +8964,10 @@
 /// canAssignObjCInterfaces - Return true if the two interface types are
 /// compatible for assignment from RHS to LHS.  This handles validation of any
 /// protocol qualifiers on the LHS or RHS.
-bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
-                                         const ObjCObjectPointerType *RHSOPT) {
-  const ObjCObjectType* LHS = LHSOPT->getObjectType();
-  const ObjCObjectType* RHS = RHSOPT->getObjectType();
+bool ASTContext::canAssignObjCInterfaces(ObjCObjectPointerType const *LHSOPT,
+                                         ObjCObjectPointerType const *RHSOPT) {
+  ObjCObjectType const *LHS = LHSOPT->getObjectType();
+  ObjCObjectType const *RHS = RHSOPT->getObjectType();
 
   // If either type represents the built-in 'id' type, return true.
   if (LHS->isObjCUnqualifiedId() || RHS->isObjCUnqualifiedId())
@@ -9067,9 +9018,8 @@
 /// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is
 /// not OK. For the return type, the opposite is not OK.
 bool ASTContext::canAssignObjCInterfacesInBlockPointer(
-                                         const ObjCObjectPointerType *LHSOPT,
-                                         const ObjCObjectPointerType *RHSOPT,
-                                         bool BlockReturnType) {
+    ObjCObjectPointerType const *LHSOPT, ObjCObjectPointerType const *RHSOPT,
+    bool BlockReturnType) {
 
   // Function object that propagates a successful result or handles
   // __kindof types.
@@ -9084,9 +9034,8 @@
     // Strip off __kindof and protocol qualifiers, then check whether
     // we can assign the other way.
     return canAssignObjCInterfacesInBlockPointer(
-             RHSOPT->stripObjCKindOfTypeAndQuals(*this),
-             LHSOPT->stripObjCKindOfTypeAndQuals(*this),
-             BlockReturnType);
+        RHSOPT->stripObjCKindOfTypeAndQuals(*this),
+        LHSOPT->stripObjCKindOfTypeAndQuals(*this), BlockReturnType);
   };
 
   if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType())
@@ -9110,16 +9059,15 @@
           (BlockReturnType ? RHSOPT : LHSOPT), false));
   }
 
-  const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
-  const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
-  if (LHS && RHS)  { // We have 2 user-defined types.
+  ObjCInterfaceType const *LHS = LHSOPT->getInterfaceType();
+  ObjCInterfaceType const *RHS = RHSOPT->getInterfaceType();
+  if (LHS && RHS) { // We have 2 user-defined types.
     if (LHS != RHS) {
       if (LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
         return finish(BlockReturnType);
       if (RHS->getDecl()->isSuperClassOf(LHS->getDecl()))
         return finish(!BlockReturnType);
-    }
-    else
+    } else
       return true;
   }
   return false;
@@ -9127,8 +9075,8 @@
 
 /// Comparison routine for Objective-C protocols to be used with
 /// llvm::array_pod_sort.
-static int compareObjCProtocolsByName(ObjCProtocolDecl * const *lhs,
-                                      ObjCProtocolDecl * const *rhs) {
+static int compareObjCProtocolsByName(ObjCProtocolDecl *const *lhs,
+                                      ObjCProtocolDecl *const *rhs) {
   return (*lhs)->getName().compare((*rhs)->getName());
 }
 
@@ -9137,15 +9085,13 @@
 /// the given common base.
 /// It is used to build composite qualifier list of the composite type of
 /// the conditional expression involving two objective-c pointer objects.
-static
-void getIntersectionOfProtocols(ASTContext &Context,
-                                const ObjCInterfaceDecl *CommonBase,
-                                const ObjCObjectPointerType *LHSOPT,
-                                const ObjCObjectPointerType *RHSOPT,
-      SmallVectorImpl<ObjCProtocolDecl *> &IntersectionSet) {
-
-  const ObjCObjectType* LHS = LHSOPT->getObjectType();
-  const ObjCObjectType* RHS = RHSOPT->getObjectType();
+static void getIntersectionOfProtocols(
+    ASTContext &Context, ObjCInterfaceDecl const *CommonBase,
+    ObjCObjectPointerType const *LHSOPT, ObjCObjectPointerType const *RHSOPT,
+    SmallVectorImpl<ObjCProtocolDecl *> &IntersectionSet) {
+
+  ObjCObjectType const *LHS = LHSOPT->getObjectType();
+  ObjCObjectType const *RHS = RHSOPT->getObjectType();
   assert(LHS->getInterface() && "LHS must have an interface base");
   assert(RHS->getInterface() && "RHS must have an interface base");
 
@@ -9185,12 +9131,11 @@
   // Remove any implied protocols from the list of inherited protocols.
   if (!ImpliedProtocols.empty()) {
     IntersectionSet.erase(
-      std::remove_if(IntersectionSet.begin(),
-                     IntersectionSet.end(),
-                     [&](ObjCProtocolDecl *proto) -> bool {
-                       return ImpliedProtocols.count(proto) > 0;
-                     }),
-      IntersectionSet.end());
+        std::remove_if(IntersectionSet.begin(), IntersectionSet.end(),
+                       [&](ObjCProtocolDecl *proto) -> bool {
+                         return ImpliedProtocols.count(proto) > 0;
+                       }),
+        IntersectionSet.end());
   }
 
   // Sort the remaining protocols by name.
@@ -9202,14 +9147,14 @@
 static bool canAssignObjCObjectTypes(ASTContext &ctx, QualType lhs,
                                      QualType rhs) {
   // Common case: two object pointers.
-  const auto *lhsOPT = lhs->getAs<ObjCObjectPointerType>();
-  const auto *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
+  auto const *lhsOPT = lhs->getAs<ObjCObjectPointerType>();
+  auto const *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
   if (lhsOPT && rhsOPT)
     return ctx.canAssignObjCInterfaces(lhsOPT, rhsOPT);
 
   // Two block pointers.
-  const auto *lhsBlock = lhs->getAs<BlockPointerType>();
-  const auto *rhsBlock = rhs->getAs<BlockPointerType>();
+  auto const *lhsBlock = lhs->getAs<BlockPointerType>();
+  auto const *rhsBlock = rhs->getAs<BlockPointerType>();
   if (lhsBlock && rhsBlock)
     return ctx.typesAreBlockPointerCompatible(lhs, rhs);
 
@@ -9223,11 +9168,9 @@
 }
 
 // Check that the given Objective-C type argument lists are equivalent.
-static bool sameObjCTypeArgs(ASTContext &ctx,
-                             const ObjCInterfaceDecl *iface,
+static bool sameObjCTypeArgs(ASTContext &ctx, ObjCInterfaceDecl const *iface,
                              ArrayRef<QualType> lhsArgs,
-                             ArrayRef<QualType> rhsArgs,
-                             bool stripKindOf) {
+                             ArrayRef<QualType> rhsArgs, bool stripKindOf) {
   if (lhsArgs.size() != rhsArgs.size())
     return false;
 
@@ -9260,13 +9203,13 @@
   return true;
 }
 
-QualType ASTContext::areCommonBaseCompatible(
-           const ObjCObjectPointerType *Lptr,
-           const ObjCObjectPointerType *Rptr) {
-  const ObjCObjectType *LHS = Lptr->getObjectType();
-  const ObjCObjectType *RHS = Rptr->getObjectType();
-  const ObjCInterfaceDecl* LDecl = LHS->getInterface();
-  const ObjCInterfaceDecl* RDecl = RHS->getInterface();
+QualType
+ASTContext::areCommonBaseCompatible(ObjCObjectPointerType const *Lptr,
+                                    ObjCObjectPointerType const *Rptr) {
+  ObjCObjectType const *LHS = Lptr->getObjectType();
+  ObjCObjectType const *RHS = Rptr->getObjectType();
+  ObjCInterfaceDecl const *LDecl = LHS->getInterface();
+  ObjCInterfaceDecl const *RDecl = RHS->getInterface();
 
   if (!LDecl || !RDecl)
     return {};
@@ -9278,8 +9221,8 @@
 
   // Follow the left-hand side up the class hierarchy until we either hit a
   // root or find the RHS. Record the ancestors in case we don't find it.
-  llvm::SmallDenseMap<const ObjCInterfaceDecl *, const ObjCObjectType *, 4>
-    LHSAncestors;
+  llvm::SmallDenseMap<ObjCInterfaceDecl const *, ObjCObjectType const *, 4>
+      LHSAncestors;
   while (true) {
     // Record this ancestor. We'll need this if the common type isn't in the
     // path from the LHS to the root.
@@ -9291,8 +9234,8 @@
       bool anyChanges = false;
       if (LHS->isSpecialized() && RHS->isSpecialized()) {
         // Both have type arguments, compare them.
-        if (!sameObjCTypeArgs(*this, LHS->getInterface(),
-                              LHS->getTypeArgs(), RHS->getTypeArgs(),
+        if (!sameObjCTypeArgs(*this, LHS->getInterface(), LHS->getTypeArgs(),
+                              RHS->getTypeArgs(),
                               /*stripKindOf=*/true))
           return {};
       } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
@@ -9342,8 +9285,8 @@
       bool anyChanges = false;
       if (LHS->isSpecialized() && RHS->isSpecialized()) {
         // Both have type arguments, compare them.
-        if (!sameObjCTypeArgs(*this, LHS->getInterface(),
-                              LHS->getTypeArgs(), RHS->getTypeArgs(),
+        if (!sameObjCTypeArgs(*this, LHS->getInterface(), LHS->getTypeArgs(),
+                              RHS->getTypeArgs(),
                               /*stripKindOf=*/true))
           return {};
       } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
@@ -9383,8 +9326,8 @@
   return {};
 }
 
-bool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS,
-                                         const ObjCObjectType *RHS) {
+bool ASTContext::canAssignObjCInterfaces(ObjCObjectType const *LHS,
+                                         ObjCObjectType const *RHS) {
   assert(LHS->getInterface() && "LHS is not an interface type");
   assert(RHS->getInterface() && "RHS is not an interface type");
 
@@ -9404,16 +9347,17 @@
     // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok.
     // But not SuperObj<P1,P2,P3> = lhs<P1,P2>.
     llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols;
-    CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols);
-    // Also, if RHS has explicit quelifiers, include them for comparing with LHS's
-    // qualifiers.
+    CollectInheritedProtocols(RHS->getInterface(),
+                              SuperClassInheritedProtocols);
+    // Also, if RHS has explicit quelifiers, include them for comparing with
+    // LHS's qualifiers.
     for (auto *RHSPI : RHS->quals())
       CollectInheritedProtocols(RHSPI, SuperClassInheritedProtocols);
     // If there is no protocols associated with RHS, it is not a match.
     if (SuperClassInheritedProtocols.empty())
       return false;
 
-    for (const auto *LHSProto : LHS->quals()) {
+    for (auto const *LHSProto : LHS->quals()) {
       bool SuperImplementsProtocol = false;
       for (auto *SuperClassProto : SuperClassInheritedProtocols)
         if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {
@@ -9429,14 +9373,14 @@
   if (LHS->isSpecialized()) {
     // Follow the superclass chain until we've matched the LHS class in the
     // hierarchy. This substitutes type arguments through.
-    const ObjCObjectType *RHSSuper = RHS;
+    ObjCObjectType const *RHSSuper = RHS;
     while (!declaresSameEntity(RHSSuper->getInterface(), LHSInterface))
       RHSSuper = RHSSuper->getSuperClassType()->castAs<ObjCObjectType>();
 
     // If the RHS is specializd, compare type arguments.
     if (RHSSuper->isSpecialized() &&
-        !sameObjCTypeArgs(*this, LHS->getInterface(),
-                          LHS->getTypeArgs(), RHSSuper->getTypeArgs(),
+        !sameObjCTypeArgs(*this, LHS->getInterface(), LHS->getTypeArgs(),
+                          RHSSuper->getTypeArgs(),
                           /*stripKindOf=*/true)) {
       return false;
     }
@@ -9447,8 +9391,8 @@
 
 bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) {
   // get the "pointed to" types
-  const auto *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
-  const auto *RHSOPT = RHS->getAs<ObjCObjectPointerType>();
+  auto const *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
+  auto const *RHSOPT = RHS->getAs<ObjCObjectPointerType>();
 
   if (!LHSOPT || !RHSOPT)
     return false;
@@ -9489,10 +9433,10 @@
 QualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType,
                                                bool OfBlockPointer,
                                                bool Unqualified) {
-  if (const RecordType *UT = T->getAsUnionType()) {
+  if (RecordType const *UT = T->getAsUnionType()) {
     RecordDecl *UD = UT->getDecl();
     if (UD->hasAttr<TransparentUnionAttr>()) {
-      for (const auto *I : UD->fields()) {
+      for (auto const *I : UD->fields()) {
         QualType ET = I->getType().getUnqualifiedType();
         QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified);
         if (!MT.isNull())
@@ -9512,13 +9456,13 @@
   // GNU extension: two types are compatible if they appear as a function
   // argument, one of the types is a transparent union type and the other
   // type is compatible with a union member
-  QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer,
-                                              Unqualified);
+  QualType lmerge =
+      mergeTransparentUnionType(lhs, rhs, OfBlockPointer, Unqualified);
   if (!lmerge.isNull())
     return lmerge;
 
-  QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer,
-                                              Unqualified);
+  QualType rmerge =
+      mergeTransparentUnionType(rhs, lhs, OfBlockPointer, Unqualified);
   if (!rmerge.isNull())
     return rmerge;
 
@@ -9528,10 +9472,10 @@
 QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs,
                                         bool OfBlockPointer, bool Unqualified,
                                         bool AllowCXX) {
-  const auto *lbase = lhs->castAs<FunctionType>();
-  const auto *rbase = rhs->castAs<FunctionType>();
-  const auto *lproto = dyn_cast<FunctionProtoType>(lbase);
-  const auto *rproto = dyn_cast<FunctionProtoType>(rbase);
+  auto const *lbase = lhs->castAs<FunctionType>();
+  auto const *rbase = rhs->castAs<FunctionType>();
+  auto const *lproto = dyn_cast<FunctionProtoType>(lbase);
+  auto const *rproto = dyn_cast<FunctionProtoType>(rbase);
   bool allLTypes = true;
   bool allRTypes = true;
 
@@ -9544,8 +9488,7 @@
     if (!UnqualifiedResult)
       UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers());
     retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true);
-  }
-  else
+  } else
     retType = mergeTypes(lbase->getReturnType(), rbase->getReturnType(), false,
                          Unqualified);
   if (retType.isNull())
@@ -9569,7 +9512,8 @@
   // FIXME: double check this
   // FIXME: should we error if lbase->getRegParmAttr() != 0 &&
   //                           rbase->getRegParmAttr() != 0 &&
-  //                           lbase->getRegParmAttr() != rbase->getRegParmAttr()?
+  //                           lbase->getRegParmAttr() !=
+  //                           rbase->getRegParmAttr()?
   FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo();
   FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo();
 
@@ -9651,8 +9595,10 @@
         allRTypes = false;
     }
 
-    if (allLTypes) return lhs;
-    if (allRTypes) return rhs;
+    if (allLTypes)
+      return lhs;
+    if (allRTypes)
+      return rhs;
 
     FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo();
     EPI.ExtInfo = einfo;
@@ -9661,10 +9607,12 @@
     return getFunctionType(retType, types, EPI);
   }
 
-  if (lproto) allRTypes = false;
-  if (rproto) allLTypes = false;
+  if (lproto)
+    allRTypes = false;
+  if (rproto)
+    allLTypes = false;
 
-  const FunctionProtoType *proto = lproto ? lproto : rproto;
+  FunctionProtoType const *proto = lproto ? lproto : rproto;
   if (proto) {
     assert((AllowCXX || !proto->hasExceptionSpec()) && "C++ shouldn't be here");
     if (proto->isVariadic())
@@ -9679,7 +9627,7 @@
 
       // Look at the converted type of enum types, since that is the type used
       // to pass enum values.
-      if (const auto *Enum = paramTy->getAs<EnumType>()) {
+      if (auto const *Enum = paramTy->getAs<EnumType>()) {
         paramTy = Enum->getDecl()->getIntegerType();
         if (paramTy.isNull())
           return {};
@@ -9690,21 +9638,25 @@
         return {};
     }
 
-    if (allLTypes) return lhs;
-    if (allRTypes) return rhs;
+    if (allLTypes)
+      return lhs;
+    if (allRTypes)
+      return rhs;
 
     FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo();
     EPI.ExtInfo = einfo;
     return getFunctionType(retType, proto->getParamTypes(), EPI);
   }
 
-  if (allLTypes) return lhs;
-  if (allRTypes) return rhs;
+  if (allLTypes)
+    return lhs;
+  if (allRTypes)
+    return rhs;
   return getFunctionNoProtoType(retType, einfo);
 }
 
 /// Given that we have an enum type and a non-enum type, try to merge them.
-static QualType mergeEnumWithInteger(ASTContext &Context, const EnumType *ET,
+static QualType mergeEnumWithInteger(ASTContext &Context, EnumType const *ET,
                                      QualType other, bool isBlockReturnType) {
   // C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
   // a signed integer type, or an unsigned integer type.
@@ -9725,8 +9677,7 @@
   return {};
 }
 
-QualType ASTContext::mergeTypes(QualType LHS, QualType RHS,
-                                bool OfBlockPointer,
+QualType ASTContext::mergeTypes(QualType LHS, QualType RHS, bool OfBlockPointer,
                                 bool Unqualified, bool BlockReturnType) {
   // For C++ we will not reach this code with reference types (see below),
   // for OpenMP variant call overloading we might.
@@ -9749,8 +9700,7 @@
     RHS = RHS.getUnqualifiedType();
   }
 
-  QualType LHSCan = getCanonicalType(LHS),
-           RHSCan = getCanonicalType(RHS);
+  QualType LHSCan = getCanonicalType(LHS), RHSCan = getCanonicalType(RHS);
 
   // If two types are identical, they are compatible.
   if (LHSCan == RHSCan)
@@ -9796,8 +9746,10 @@
 
   // We want to consider the two function types to be the same for these
   // comparisons, just force one to the other.
-  if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
-  if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
+  if (LHSClass == Type::FunctionProto)
+    LHSClass = Type::FunctionNoProto;
+  if (RHSClass == Type::FunctionProto)
+    RHSClass = Type::FunctionNoProto;
 
   // Same as above for arrays
   if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
@@ -9806,27 +9758,31 @@
     RHSClass = Type::ConstantArray;
 
   // ObjCInterfaces are just specialized ObjCObjects.
-  if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
-  if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
+  if (LHSClass == Type::ObjCInterface)
+    LHSClass = Type::ObjCObject;
+  if (RHSClass == Type::ObjCInterface)
+    RHSClass = Type::ObjCObject;
 
   // Canonicalize ExtVector -> Vector.
-  if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
-  if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
+  if (LHSClass == Type::ExtVector)
+    LHSClass = Type::Vector;
+  if (RHSClass == Type::ExtVector)
+    RHSClass = Type::Vector;
 
   // If the canonical type classes don't match.
   if (LHSClass != RHSClass) {
     // Note that we only have special rules for turning block enum
     // returns into block int returns, not vice-versa.
-    if (const auto *ETy = LHS->getAs<EnumType>()) {
+    if (auto const *ETy = LHS->getAs<EnumType>()) {
       return mergeEnumWithInteger(*this, ETy, RHS, false);
     }
-    if (const EnumType* ETy = RHS->getAs<EnumType>()) {
+    if (EnumType const *ETy = RHS->getAs<EnumType>()) {
       return mergeEnumWithInteger(*this, ETy, LHS, BlockReturnType);
     }
     // allow block pointer type to match an 'id' type.
     if (OfBlockPointer && !BlockReturnType) {
-       if (LHS->isObjCIdType() && RHS->isBlockPointerType())
-         return LHS;
+      if (LHS->isObjCIdType() && RHS->isBlockPointerType())
+        return LHS;
       if (RHS->isObjCIdType() && LHS->isBlockPointerType())
         return RHS;
     }
@@ -9858,8 +9814,7 @@
   case Type::ExtVector:
     llvm_unreachable("Types are eliminated above");
 
-  case Type::Pointer:
-  {
+  case Type::Pointer: {
     // Merge two pointer types, while trying to preserve typedef info
     QualType LHSPointee = LHS->castAs<PointerType>()->getPointeeType();
     QualType RHSPointee = RHS->castAs<PointerType>()->getPointeeType();
@@ -9867,8 +9822,8 @@
       LHSPointee = LHSPointee.getUnqualifiedType();
       RHSPointee = RHSPointee.getUnqualifiedType();
     }
-    QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false,
-                                     Unqualified);
+    QualType ResultType =
+        mergeTypes(LHSPointee, RHSPointee, false, Unqualified);
     if (ResultType.isNull())
       return {};
     if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
@@ -9877,8 +9832,7 @@
       return RHS;
     return getPointerType(ResultType);
   }
-  case Type::BlockPointer:
-  {
+  case Type::BlockPointer: {
     // Merge two block pointer types, while trying to preserve typedef info
     QualType LHSPointee = LHS->castAs<BlockPointerType>()->getPointeeType();
     QualType RHSPointee = RHS->castAs<BlockPointerType>()->getPointeeType();
@@ -9900,8 +9854,8 @@
       RHSPointee =
           QualType(RHSPointee.getTypePtr(), RHSPteeQual.getAsOpaqueValue());
     }
-    QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer,
-                                     Unqualified);
+    QualType ResultType =
+        mergeTypes(LHSPointee, RHSPointee, OfBlockPointer, Unqualified);
     if (ResultType.isNull())
       return {};
     if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
@@ -9910,8 +9864,7 @@
       return RHS;
     return getBlockPointerType(ResultType);
   }
-  case Type::Atomic:
-  {
+  case Type::Atomic: {
     // Merge two pointer types, while trying to preserve typedef info
     QualType LHSValue = LHS->castAs<AtomicType>()->getValueType();
     QualType RHSValue = RHS->castAs<AtomicType>()->getValueType();
@@ -9919,8 +9872,7 @@
       LHSValue = LHSValue.getUnqualifiedType();
       RHSValue = RHSValue.getUnqualifiedType();
     }
-    QualType ResultType = mergeTypes(LHSValue, RHSValue, false,
-                                     Unqualified);
+    QualType ResultType = mergeTypes(LHSValue, RHSValue, false, Unqualified);
     if (ResultType.isNull())
       return {};
     if (getCanonicalType(LHSValue) == getCanonicalType(ResultType))
@@ -9929,10 +9881,9 @@
       return RHS;
     return getAtomicType(ResultType);
   }
-  case Type::ConstantArray:
-  {
-    const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
-    const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
+  case Type::ConstantArray: {
+    ConstantArrayType const *LCAT = getAsConstantArrayType(LHS);
+    ConstantArrayType const *RCAT = getAsConstantArrayType(RHS);
     if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
       return {};
 
@@ -9947,15 +9898,15 @@
     if (ResultType.isNull())
       return {};
 
-    const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
-    const VariableArrayType* RVAT = getAsVariableArrayType(RHS);
+    VariableArrayType const *LVAT = getAsVariableArrayType(LHS);
+    VariableArrayType const *RVAT = getAsVariableArrayType(RHS);
 
     // If either side is a variable array, and both are complete, check whether
     // the current dimension is definite.
     if (LVAT || RVAT) {
-      auto SizeFetch = [this](const VariableArrayType* VAT,
-          const ConstantArrayType* CAT)
-          -> std::pair<bool,llvm::APInt> {
+      auto SizeFetch =
+          [this](VariableArrayType const *VAT,
+                 ConstantArrayType const *CAT) -> std::pair<bool, llvm::APInt> {
         if (VAT) {
           Optional<llvm::APSInt> TheInt;
           Expr *E = VAT->getSizeExpr();
@@ -10004,10 +9955,12 @@
       // has to be different.
       return RHS;
     }
-    if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
-    if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
-    return getIncompleteArrayType(ResultType,
-                                  ArrayType::ArraySizeModifier(), 0);
+    if (getCanonicalType(LHSElem) == getCanonicalType(ResultType))
+      return LHS;
+    if (getCanonicalType(RHSElem) == getCanonicalType(ResultType))
+      return RHS;
+    return getIncompleteArrayType(ResultType, ArrayType::ArraySizeModifier(),
+                                  0);
   }
   case Type::FunctionNoProto:
     return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified);
@@ -10058,7 +10011,7 @@
     return {};
   case Type::ExtInt: {
     // Merge two ext-int types, while trying to preserve typedef info.
-    bool LHSUnsigned  = LHS->castAs<ExtIntType>()->isUnsigned();
+    bool LHSUnsigned = LHS->castAs<ExtIntType>()->isUnsigned();
     bool RHSUnsigned = RHS->castAs<ExtIntType>()->isUnsigned();
     unsigned LHSBits = LHS->castAs<ExtIntType>()->getNumBits();
     unsigned RHSBits = RHS->castAs<ExtIntType>()->getNumBits();
@@ -10077,7 +10030,7 @@
 }
 
 bool ASTContext::mergeExtParameterInfo(
-    const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType,
+    FunctionProtoType const *FirstFnType, FunctionProtoType const *SecondFnType,
     bool &CanUseFirst, bool &CanUseSecond,
     SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &NewParamInfos) {
   assert(NewParamInfos.empty() && "param info list not empty");
@@ -10123,7 +10076,7 @@
   return true;
 }
 
-void ASTContext::ResetObjCLayout(const ObjCContainerDecl *CD) {
+void ASTContext::ResetObjCLayout(ObjCContainerDecl const *CD) {
   ObjCLayouts[CD] = nullptr;
 }
 
@@ -10131,8 +10084,7 @@
 /// 'RHS' attributes and returns the merged version; including for function
 /// return types.
 QualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) {
-  QualType LHSCan = getCanonicalType(LHS),
-  RHSCan = getCanonicalType(RHS);
+  QualType LHSCan = getCanonicalType(LHS), RHSCan = getCanonicalType(RHS);
   // If two types are identical, they are compatible.
   if (LHSCan == RHSCan)
     return LHS;
@@ -10144,14 +10096,14 @@
     QualType NewReturnType =
         cast<FunctionType>(LHSCan.getTypePtr())->getReturnType();
     QualType ResReturnType =
-      mergeObjCGCQualifiers(NewReturnType, OldReturnType);
+        mergeObjCGCQualifiers(NewReturnType, OldReturnType);
     if (ResReturnType.isNull())
       return {};
     if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
       // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo();
       // In either case, use OldReturnType to build the new function type.
-      const auto *F = LHS->castAs<FunctionType>();
-      if (const auto *FPT = cast<FunctionProtoType>(F)) {
+      auto const *F = LHS->castAs<FunctionType>();
+      if (auto const *FPT = cast<FunctionProtoType>(F)) {
         FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
         EPI.ExtInfo = getFunctionExtInfo(LHS);
         QualType ResultType =
@@ -10207,11 +10159,11 @@
 //===----------------------------------------------------------------------===//
 
 unsigned ASTContext::getIntWidth(QualType T) const {
-  if (const auto *ET = T->getAs<EnumType>())
+  if (auto const *ET = T->getAs<EnumType>())
     T = ET->getDecl()->getIntegerType();
   if (T->isBooleanType())
     return 1;
-  if(const auto *EIT = T->getAs<ExtIntType>())
+  if (auto const *EIT = T->getAs<ExtIntType>())
     return EIT->getNumBits();
   // For builtin types, just use the standard type sizing method
   return (unsigned)getTypeSize(T);
@@ -10222,17 +10174,17 @@
          "Unexpected type");
 
   // Turn <4 x signed int> -> <4 x unsigned int>
-  if (const auto *VTy = T->getAs<VectorType>())
+  if (auto const *VTy = T->getAs<VectorType>())
     return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()),
                          VTy->getNumElements(), VTy->getVectorKind());
 
   // For _ExtInt, return an unsigned _ExtInt with same width.
-  if (const auto *EITy = T->getAs<ExtIntType>())
+  if (auto const *EITy = T->getAs<ExtIntType>())
     return getExtIntType(/*IsUnsigned=*/true, EITy->getNumBits());
 
   // For enums, get the underlying integer type of the enum, and let the general
   // integer type signchanging code handle it.
-  if (const auto *ETy = T->getAs<EnumType>())
+  if (auto const *ETy = T->getAs<EnumType>())
     T = ETy->getDecl()->getIntegerType();
 
   switch (T->castAs<BuiltinType>()->getKind()) {
@@ -10290,17 +10242,17 @@
          "Unexpected type");
 
   // Turn <4 x unsigned int> -> <4 x signed int>
-  if (const auto *VTy = T->getAs<VectorType>())
+  if (auto const *VTy = T->getAs<VectorType>())
     return getVectorType(getCorrespondingSignedType(VTy->getElementType()),
                          VTy->getNumElements(), VTy->getVectorKind());
 
   // For _ExtInt, return a signed _ExtInt with same width.
-  if (const auto *EITy = T->getAs<ExtIntType>())
+  if (auto const *EITy = T->getAs<ExtIntType>())
     return getExtIntType(/*IsUnsigned=*/false, EITy->getNumBits());
 
   // For enums, get the underlying integer type of the enum, and let the general
   // integer type signchanging code handle it.
-  if (const auto *ETy = T->getAs<EnumType>())
+  if (auto const *ETy = T->getAs<EnumType>())
     T = ETy->getDecl()->getIntegerType();
 
   switch (T->castAs<BuiltinType>()->getKind()) {
@@ -10354,7 +10306,7 @@
 
 ASTMutationListener::~ASTMutationListener() = default;
 
-void ASTMutationListener::DeducedReturnType(const FunctionDecl *FD,
+void ASTMutationListener::DeducedReturnType(FunctionDecl const *FD,
                                             QualType ReturnType) {}
 
 //===----------------------------------------------------------------------===//
@@ -10369,10 +10321,9 @@
 ///
 /// RequiresICE is filled in on return to indicate whether the value is required
 /// to be an Integer Constant Expression.
-static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context,
+static QualType DecodeTypeFromStr(char const *&Str, ASTContext const &Context,
                                   ASTContext::GetBuiltinTypeError &Error,
-                                  bool &RequiresICE,
-                                  bool AllowTypeModifiers) {
+                                  bool &RequiresICE, bool AllowTypeModifiers) {
   // Modifiers.
   int HowLong = 0;
   bool Signed = false, Unsigned = false;
@@ -10380,12 +10331,15 @@
 
   // Read the prefixed modifiers first.
   bool Done = false;
-  #ifndef NDEBUG
+#ifndef NDEBUG
   bool IsSpecial = false;
-  #endif
+#endif
   while (!Done) {
     switch (*Str++) {
-    default: Done = true; --Str; break;
+    default:
+      Done = true;
+      --Str;
+      break;
     case 'I':
       RequiresICE = true;
       break;
@@ -10408,9 +10362,9 @@
       // 'N' behaves like 'L' for all non LP64 targets and 'int' otherwise.
       assert(!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
       assert(HowLong == 0 && "Can't use both 'L' and 'N' modifiers!");
-      #ifndef NDEBUG
+#ifndef NDEBUG
       IsSpecial = true;
-      #endif
+#endif
       if (Context.getTargetInfo().getLongWidth() == 32)
         ++HowLong;
       break;
@@ -10418,9 +10372,9 @@
       // This modifier represents int64 type.
       assert(!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
       assert(HowLong == 0 && "Can't use both 'L' and 'W' modifiers!");
-      #ifndef NDEBUG
+#ifndef NDEBUG
       IsSpecial = true;
-      #endif
+#endif
       switch (Context.getTargetInfo().getInt64Type()) {
       default:
         llvm_unreachable("Unexpected integer type");
@@ -10436,9 +10390,9 @@
       // This modifier represents int32 type.
       assert(!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
       assert(HowLong == 0 && "Can't use both 'L' and 'Z' modifiers!");
-      #ifndef NDEBUG
+#ifndef NDEBUG
       IsSpecial = true;
-      #endif
+#endif
       switch (Context.getTargetInfo().getIntTypeByWidth(32, true)) {
       default:
         llvm_unreachable("Unexpected integer type");
@@ -10456,9 +10410,9 @@
     case 'O':
       assert(!IsSpecial && "Can't use two 'N', 'W', 'Z' or 'O' modifiers!");
       assert(HowLong == 0 && "Can't use both 'L' and 'O' modifiers!");
-      #ifndef NDEBUG
+#ifndef NDEBUG
       IsSpecial = true;
-      #endif
+#endif
       if (Context.getLangOpts().OpenCL)
         HowLong = 1;
       else
@@ -10471,7 +10425,8 @@
 
   // Read the base type.
   switch (*Str++) {
-  default: llvm_unreachable("Unknown builtin type letter!");
+  default:
+    llvm_unreachable("Unknown builtin type letter!");
   case 'x':
     assert(HowLong == 0 && !Signed && !Unsigned &&
            "Bad modifiers used with 'x'!");
@@ -10537,11 +10492,11 @@
     assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!");
     Type = Context.BoolTy;
     break;
-  case 'z':  // size_t.
+  case 'z': // size_t.
     assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!");
     Type = Context.getSizeType();
     break;
-  case 'w':  // wchar_t.
+  case 'w': // wchar_t.
     assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'w'!");
     Type = Context.getWideCharType();
     break;
@@ -10583,8 +10538,8 @@
     assert(End != Str && "Missing vector size");
     Str = End;
 
-    QualType ElementType = DecodeTypeFromStr(Str, Context, Error,
-                                             RequiresICE, false);
+    QualType ElementType =
+        DecodeTypeFromStr(Str, Context, Error, RequiresICE, false);
     assert(!RequiresICE && "Can't require vector ICE");
 
     Type = Context.getScalableVectorType(ElementType, NumElements);
@@ -10596,8 +10551,8 @@
     assert(End != Str && "Missing vector size");
     Str = End;
 
-    QualType ElementType = DecodeTypeFromStr(Str, Context, Error,
-                                             RequiresICE, false);
+    QualType ElementType =
+        DecodeTypeFromStr(Str, Context, Error, RequiresICE, false);
     assert(!RequiresICE && "Can't require vector ICE");
 
     // TODO: No way to make AltiVec vectors in builtins yet.
@@ -10613,14 +10568,14 @@
 
     Str = End;
 
-    QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
-                                             false);
+    QualType ElementType =
+        DecodeTypeFromStr(Str, Context, Error, RequiresICE, false);
     Type = Context.getExtVectorType(ElementType, NumElements);
     break;
   }
   case 'X': {
-    QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
-                                             false);
+    QualType ElementType =
+        DecodeTypeFromStr(Str, Context, Error, RequiresICE, false);
     assert(!RequiresICE && "Can't require complex ICE");
     Type = Context.getComplexType(ElementType);
     break;
@@ -10664,7 +10619,10 @@
   Done = !AllowTypeModifiers;
   while (!Done) {
     switch (char c = *Str++) {
-    default: Done = true; --Str; break;
+    default:
+      Done = true;
+      --Str;
+      break;
     case '*':
     case '&': {
       // Both pointers and references can have their pointee types
@@ -10674,8 +10632,7 @@
       if (End != Str) {
         // Note AddrSpace == 0 is not the same as an unspecified address space.
         Type = Context.getAddrSpaceQualType(
-          Type,
-          Context.getLangASForBuiltinAddressSpace(AddrSpace));
+            Type, Context.getLangASForBuiltinAddressSpace(AddrSpace));
         Str = End;
       }
       if (c == '*')
@@ -10709,17 +10666,16 @@
 // descriptor decoding to define builtins mixing target-dependent and target-
 // independent types. This function allows decoding one type descriptor with
 // default decoding.
-QualType ASTContext::DecodeTypeStr(const char *&Str, const ASTContext &Context,
+QualType ASTContext::DecodeTypeStr(char const *&Str, ASTContext const &Context,
                                    GetBuiltinTypeError &Error, bool &RequireICE,
                                    bool AllowTypeModifiers) const {
   return DecodeTypeFromStr(Str, Context, Error, RequireICE, AllowTypeModifiers);
 }
 
 /// GetBuiltinType - Return the type for the specified builtin.
-QualType ASTContext::GetBuiltinType(unsigned Id,
-                                    GetBuiltinTypeError &Error,
+QualType ASTContext::GetBuiltinType(unsigned Id, GetBuiltinTypeError &Error,
                                     unsigned *IntegerConstantArgs) const {
-  const char *TypeStr = BuiltinInfo.getTypeString(Id);
+  char const *TypeStr = BuiltinInfo.getTypeString(Id);
   if (TypeStr[0] == '\0') {
     Error = GE_Missing_type;
     return {};
@@ -10729,8 +10685,8 @@
 
   bool RequiresICE = false;
   Error = GE_None;
-  QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error,
-                                       RequiresICE, true);
+  QualType ResType =
+      DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true);
   if (Error != GE_None)
     return {};
 
@@ -10763,8 +10719,8 @@
 
   FunctionType::ExtInfo EI(getDefaultCallingConvention(
       Variadic, /*IsCXXMethod=*/false, /*IsBuiltin=*/true));
-  if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true);
-
+  if (BuiltinInfo.isNoReturn(Id))
+    EI = EI.withNoReturn(true);
 
   // We really shouldn't be making a no-proto type here.
   if (ArgTypes.empty() && Variadic && !getLangOpts().CPlusPlus)
@@ -10780,14 +10736,14 @@
   return getFunctionType(ResType, ArgTypes, EPI);
 }
 
-static GVALinkage basicGVALinkageForFunction(const ASTContext &Context,
-                                             const FunctionDecl *FD) {
+static GVALinkage basicGVALinkageForFunction(ASTContext const &Context,
+                                             FunctionDecl const *FD) {
   if (!FD->isExternallyVisible())
     return GVA_Internal;
 
   // Non-user-provided functions get emitted as weak definitions with every
   // use, no matter whether they've been explicitly instantiated etc.
-  if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
+  if (auto const *MD = dyn_cast<CXXMethodDecl>(FD))
     if (!MD->isUserProvided())
       return GVA_DiscardableODR;
 
@@ -10842,8 +10798,8 @@
   return GVA_DiscardableODR;
 }
 
-static GVALinkage adjustGVALinkageForAttributes(const ASTContext &Context,
-                                                const Decl *D, GVALinkage L) {
+static GVALinkage adjustGVALinkageForAttributes(ASTContext const &Context,
+                                                Decl const *D, GVALinkage L) {
   // See http://msdn.microsoft.com/en-us/library/xa0d9ste.aspx
   // dllexport/dllimport on inline functions.
   if (D->hasAttr<DLLImportAttr>()) {
@@ -10873,7 +10829,7 @@
 /// Adjust the GVALinkage for a declaration based on what an external AST source
 /// knows about whether there can be other definitions of this declaration.
 static GVALinkage
-adjustGVALinkageForExternalDefinitionKind(const ASTContext &Ctx, const Decl *D,
+adjustGVALinkageForExternalDefinitionKind(ASTContext const &Ctx, Decl const *D,
                                           GVALinkage L) {
   ExternalASTSource *Source = Ctx.getExternalSource();
   if (!Source)
@@ -10895,19 +10851,20 @@
   return L;
 }
 
-GVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) const {
-  return adjustGVALinkageForExternalDefinitionKind(*this, FD,
-           adjustGVALinkageForAttributes(*this, FD,
-             basicGVALinkageForFunction(*this, FD)));
+GVALinkage ASTContext::GetGVALinkageForFunction(FunctionDecl const *FD) const {
+  return adjustGVALinkageForExternalDefinitionKind(
+      *this, FD,
+      adjustGVALinkageForAttributes(*this, FD,
+                                    basicGVALinkageForFunction(*this, FD)));
 }
 
-static GVALinkage basicGVALinkageForVariable(const ASTContext &Context,
-                                             const VarDecl *VD) {
+static GVALinkage basicGVALinkageForVariable(ASTContext const &Context,
+                                             VarDecl const *VD) {
   if (!VD->isExternallyVisible())
     return GVA_Internal;
 
   if (VD->isStaticLocal()) {
-    const DeclContext *LexicalContext = VD->getParentFunctionOrMethod();
+    DeclContext const *LexicalContext = VD->getParentFunctionOrMethod();
     while (LexicalContext && !isa<FunctionDecl>(LexicalContext))
       LexicalContext = LexicalContext->getLexicalParent();
 
@@ -10978,14 +10935,15 @@
   llvm_unreachable("Invalid Linkage!");
 }
 
-GVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) {
-  return adjustGVALinkageForExternalDefinitionKind(*this, VD,
-           adjustGVALinkageForAttributes(*this, VD,
-             basicGVALinkageForVariable(*this, VD)));
+GVALinkage ASTContext::GetGVALinkageForVariable(VarDecl const *VD) {
+  return adjustGVALinkageForExternalDefinitionKind(
+      *this, VD,
+      adjustGVALinkageForAttributes(*this, VD,
+                                    basicGVALinkageForVariable(*this, VD)));
 }
 
-bool ASTContext::DeclMustBeEmitted(const Decl *D) {
-  if (const auto *VD = dyn_cast<VarDecl>(D)) {
+bool ASTContext::DeclMustBeEmitted(Decl const *D) {
+  if (auto const *VD = dyn_cast<VarDecl>(D)) {
     if (!VD->isFileVarDecl())
       return false;
     // Global named register variables (GNU extension) are never emitted.
@@ -10994,7 +10952,7 @@
     if (VD->getDescribedVarTemplate() ||
         isa<VarTemplatePartialSpecializationDecl>(VD))
       return false;
-  } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
+  } else if (auto const *FD = dyn_cast<FunctionDecl>(D)) {
     // We never need to emit an uninstantiated function template.
     if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
       return false;
@@ -11027,7 +10985,7 @@
   if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>())
     return true;
 
-  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
+  if (auto const *FD = dyn_cast<FunctionDecl>(D)) {
     // Forward declarations aren't required.
     if (!FD->doesThisDeclarationHaveABody())
       return FD->doesDeclarationForceExternallyVisibleDefinition();
@@ -11039,10 +10997,10 @@
     // The key function for a class is required.  This rule only comes
     // into play when inline functions can be key functions, though.
     if (getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
-      if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
-        const CXXRecordDecl *RD = MD->getParent();
+      if (auto const *MD = dyn_cast<CXXMethodDecl>(FD)) {
+        CXXRecordDecl const *RD = MD->getParent();
         if (MD->isOutOfLine() && RD->isDynamicClass()) {
-          const CXXMethodDecl *KeyFunc = getCurrentKeyFunction(RD);
+          CXXMethodDecl const *KeyFunc = getCurrentKeyFunction(RD);
           if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl())
             return true;
         }
@@ -11057,7 +11015,7 @@
     return !isDiscardableGVALinkage(Linkage);
   }
 
-  const auto *VD = cast<VarDecl>(D);
+  auto const *VD = cast<VarDecl>(D);
   assert(VD->isFileVarDecl() && "Expected file scoped var");
 
   // If the decl is marked as `declare target to`, it should be emitted for the
@@ -11091,9 +11049,9 @@
 
   // Likewise, variables with tuple-like bindings are required if their
   // bindings have side-effects.
-  if (const auto *DD = dyn_cast<DecompositionDecl>(VD))
-    for (const auto *BD : DD->bindings())
-      if (const auto *BindingVD = BD->getHoldingVar())
+  if (auto const *DD = dyn_cast<DecompositionDecl>(VD))
+    for (auto const *BD : DD->bindings())
+      if (auto const *BindingVD = BD->getHoldingVar())
         if (DeclMustBeEmitted(BindingVD))
           return true;
 
@@ -11101,10 +11059,10 @@
 }
 
 void ASTContext::forEachMultiversionedFunctionVersion(
-    const FunctionDecl *FD,
+    FunctionDecl const *FD,
     llvm::function_ref<void(FunctionDecl *)> Pred) const {
   assert(FD->isMultiVersion() && "Only valid for multiversioned functions");
-  llvm::SmallDenseSet<const FunctionDecl*, 4> SeenDecls;
+  llvm::SmallDenseSet<FunctionDecl const *, 4> SeenDecls;
   FD = FD->getMostRecentDecl();
   // FIXME: The order of traversal here matters and depends on the order of
   // lookup results, which happens to be (mostly) oldest-to-newest, but we
@@ -11158,7 +11116,7 @@
   return Target->getDefaultCallingConv();
 }
 
-bool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const {
+bool ASTContext::isNearlyEmpty(CXXRecordDecl const *RD) const {
   // Pass through to the C++ ABI object
   return ABI->isNearlyEmpty(RD);
 }
@@ -11178,7 +11136,7 @@
   return VTContext.get();
 }
 
-MangleContext *ASTContext::createMangleContext(const TargetInfo *T) {
+MangleContext *ASTContext::createMangleContext(TargetInfo const *T) {
   if (!T)
     T = Target;
   switch (T->getCXXABI().getKind()) {
@@ -11199,7 +11157,7 @@
   llvm_unreachable("Unsupported ABI");
 }
 
-MangleContext *ASTContext::createDeviceMangleContext(const TargetInfo &T) {
+MangleContext *ASTContext::createDeviceMangleContext(TargetInfo const &T) {
   assert(T.getCXXABI().getKind() != TargetCXXABI::Microsoft &&
          "Device mangle context does not support Microsoft mangling.");
   switch (T.getCXXABI().getKind()) {
@@ -11215,7 +11173,7 @@
   case TargetCXXABI::XL:
     return ItaniumMangleContext::create(
         *this, getDiagnostics(),
-        [](ASTContext &, const NamedDecl *ND) -> llvm::Optional<unsigned> {
+        [](ASTContext &, NamedDecl const *ND) -> llvm::Optional<unsigned> {
           if (const auto *RD = dyn_cast<CXXRecordDecl>(ND))
             return RD->getDeviceLambdaManglingNumber();
           return llvm::None;
@@ -11282,29 +11240,29 @@
   llvm_unreachable("Unhandled TargetInfo::RealType value");
 }
 
-void ASTContext::setManglingNumber(const NamedDecl *ND, unsigned Number) {
+void ASTContext::setManglingNumber(NamedDecl const *ND, unsigned Number) {
   if (Number > 1)
     MangleNumbers[ND] = Number;
 }
 
-unsigned ASTContext::getManglingNumber(const NamedDecl *ND) const {
+unsigned ASTContext::getManglingNumber(NamedDecl const *ND) const {
   auto I = MangleNumbers.find(ND);
   return I != MangleNumbers.end() ? I->second : 1;
 }
 
-void ASTContext::setStaticLocalNumber(const VarDecl *VD, unsigned Number) {
+void ASTContext::setStaticLocalNumber(VarDecl const *VD, unsigned Number) {
   if (Number > 1)
     StaticLocalNumbers[VD] = Number;
 }
 
-unsigned ASTContext::getStaticLocalNumber(const VarDecl *VD) const {
+unsigned ASTContext::getStaticLocalNumber(VarDecl const *VD) const {
   auto I = StaticLocalNumbers.find(VD);
   return I != StaticLocalNumbers.end() ? I->second : 1;
 }
 
 MangleNumberingContext &
-ASTContext::getManglingNumberContext(const DeclContext *DC) {
-  assert(LangOpts.CPlusPlus);  // We don't need mangling numbers for plain C.
+ASTContext::getManglingNumberContext(DeclContext const *DC) {
+  assert(LangOpts.CPlusPlus); // We don't need mangling numbers for plain C.
   std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
   if (!MCtx)
     MCtx = createMangleNumberingContext();
@@ -11312,7 +11270,7 @@
 }
 
 MangleNumberingContext &
-ASTContext::getManglingNumberContext(NeedExtraManglingDecl_t, const Decl *D) {
+ASTContext::getManglingNumberContext(NeedExtraManglingDecl_t, Decl const *D) {
   assert(LangOpts.CPlusPlus); // We don't need mangling numbers for plain C.
   std::unique_ptr<MangleNumberingContext> &MCtx =
       ExtraMangleNumberingContexts[D];
@@ -11326,7 +11284,7 @@
   return ABI->createMangleNumberingContext();
 }
 
-const CXXConstructorDecl *
+CXXConstructorDecl const *
 ASTContext::getCopyConstructorForExceptionObject(CXXRecordDecl *RD) {
   return ABI->getCopyConstructorForExceptionObject(
       cast<CXXRecordDecl>(RD->getFirstDecl()));
@@ -11345,7 +11303,7 @@
 }
 
 TypedefNameDecl *
-ASTContext::getTypedefNameForUnnamedTagDecl(const TagDecl *TD) {
+ASTContext::getTypedefNameForUnnamedTagDecl(TagDecl const *TD) {
   return ABI->getTypedefNameForUnnamedTagDecl(TD);
 }
 
@@ -11354,15 +11312,15 @@
   return ABI->addDeclaratorForUnnamedTagDecl(TD, DD);
 }
 
-DeclaratorDecl *ASTContext::getDeclaratorForUnnamedTagDecl(const TagDecl *TD) {
+DeclaratorDecl *ASTContext::getDeclaratorForUnnamedTagDecl(TagDecl const *TD) {
   return ABI->getDeclaratorForUnnamedTagDecl(TD);
 }
 
-void ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) {
+void ASTContext::setParameterIndex(ParmVarDecl const *D, unsigned int index) {
   ParamIndices[D] = index;
 }
 
-unsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const {
+unsigned ASTContext::getParameterIndex(ParmVarDecl const *D) const {
   ParameterIndexTable::const_iterator I = ParamIndices.find(D);
   assert(I != ParamIndices.end() &&
          "ParmIndices lacks entry set by ParmVarDecl");
@@ -11394,8 +11352,7 @@
   return Result;
 }
 
-MSGuidDecl *
-ASTContext::getMSGuidDecl(MSGuidDecl::Parts Parts) const {
+MSGuidDecl *ASTContext::getMSGuidDecl(MSGuidDecl::Parts Parts) const {
   assert(MSGuidTagDecl && "building MS GUID without MS extensions?");
 
   llvm::FoldingSetNodeID ID;
@@ -11412,7 +11369,7 @@
 }
 
 TemplateParamObjectDecl *
-ASTContext::getTemplateParamObjectDecl(QualType T, const APValue &V) const {
+ASTContext::getTemplateParamObjectDecl(QualType T, APValue const &V) const {
   assert(T->isRecordType() && "template param object of unexpected type");
 
   // C++ [temp.param]p8:
@@ -11432,8 +11389,8 @@
   return New;
 }
 
-bool ASTContext::AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const {
-  const llvm::Triple &T = getTargetInfo().getTriple();
+bool ASTContext::AtomicUsesUnsupportedLibcall(AtomicExpr const *E) const {
+  llvm::Triple const &T = getTargetInfo().getTriple();
   if (!T.isOSDarwin())
     return false;
 
@@ -11450,15 +11407,13 @@
   return (Size != Align || toBits(sizeChars) > MaxInlineWidthInBits);
 }
 
-bool
-ASTContext::ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl,
-                                const ObjCMethodDecl *MethodImpl) {
+bool ASTContext::ObjCMethodsAreEqual(ObjCMethodDecl const *MethodDecl,
+                                     ObjCMethodDecl const *MethodImpl) {
   // No point trying to match an unavailable/deprecated mothod.
-  if (MethodDecl->hasAttr<UnavailableAttr>()
-      || MethodDecl->hasAttr<DeprecatedAttr>())
+  if (MethodDecl->hasAttr<UnavailableAttr>() ||
+      MethodDecl->hasAttr<DeprecatedAttr>())
     return false;
-  if (MethodDecl->getObjCDeclQualifier() !=
-      MethodImpl->getObjCDeclQualifier())
+  if (MethodDecl->getObjCDeclQualifier() != MethodImpl->getObjCDeclQualifier())
     return false;
   if (!hasSameType(MethodDecl->getReturnType(), MethodImpl->getReturnType()))
     return false;
@@ -11467,11 +11422,12 @@
     return false;
 
   for (ObjCMethodDecl::param_const_iterator IM = MethodImpl->param_begin(),
-       IF = MethodDecl->param_begin(), EM = MethodImpl->param_end(),
-       EF = MethodDecl->param_end();
+                                            IF = MethodDecl->param_begin(),
+                                            EM = MethodImpl->param_end(),
+                                            EF = MethodDecl->param_end();
        IM != EM && IF != EF; ++IM, ++IF) {
-    const ParmVarDecl *DeclVar = (*IF);
-    const ParmVarDecl *ImplVar = (*IM);
+    ParmVarDecl const *DeclVar = (*IF);
+    ParmVarDecl const *ImplVar = (*IM);
     if (ImplVar->getObjCDeclQualifier() != DeclVar->getObjCDeclQualifier())
       return false;
     if (!hasSameType(DeclVar->getType(), ImplVar->getType()))
@@ -11501,35 +11457,36 @@
 QualType ASTContext::getCorrespondingSaturatedType(QualType Ty) const {
   assert(Ty->isFixedPointType());
 
-  if (Ty->isSaturatedFixedPointType()) return Ty;
+  if (Ty->isSaturatedFixedPointType())
+    return Ty;
 
   switch (Ty->castAs<BuiltinType>()->getKind()) {
-    default:
-      llvm_unreachable("Not a fixed point type!");
-    case BuiltinType::ShortAccum:
-      return SatShortAccumTy;
-    case BuiltinType::Accum:
-      return SatAccumTy;
-    case BuiltinType::LongAccum:
-      return SatLongAccumTy;
-    case BuiltinType::UShortAccum:
-      return SatUnsignedShortAccumTy;
-    case BuiltinType::UAccum:
-      return SatUnsignedAccumTy;
-    case BuiltinType::ULongAccum:
-      return SatUnsignedLongAccumTy;
-    case BuiltinType::ShortFract:
-      return SatShortFractTy;
-    case BuiltinType::Fract:
-      return SatFractTy;
-    case BuiltinType::LongFract:
-      return SatLongFractTy;
-    case BuiltinType::UShortFract:
-      return SatUnsignedShortFractTy;
-    case BuiltinType::UFract:
-      return SatUnsignedFractTy;
-    case BuiltinType::ULongFract:
-      return SatUnsignedLongFractTy;
+  default:
+    llvm_unreachable("Not a fixed point type!");
+  case BuiltinType::ShortAccum:
+    return SatShortAccumTy;
+  case BuiltinType::Accum:
+    return SatAccumTy;
+  case BuiltinType::LongAccum:
+    return SatLongAccumTy;
+  case BuiltinType::UShortAccum:
+    return SatUnsignedShortAccumTy;
+  case BuiltinType::UAccum:
+    return SatUnsignedAccumTy;
+  case BuiltinType::ULongAccum:
+    return SatUnsignedLongAccumTy;
+  case BuiltinType::ShortFract:
+    return SatShortFractTy;
+  case BuiltinType::Fract:
+    return SatFractTy;
+  case BuiltinType::LongFract:
+    return SatLongFractTy;
+  case BuiltinType::UShortFract:
+    return SatUnsignedShortFractTy;
+  case BuiltinType::UFract:
+    return SatUnsignedFractTy;
+  case BuiltinType::ULongFract:
+    return SatUnsignedLongFractTy;
   }
 }
 
@@ -11545,97 +11502,96 @@
 
 // Explicitly instantiate this in case a Redeclarable<T> is used from a TU that
 // doesn't include ASTContext.h
-template
-clang::LazyGenerationalUpdatePtr<
-    const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::ValueType
-clang::LazyGenerationalUpdatePtr<
-    const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::makeValue(
-        const clang::ASTContext &Ctx, Decl *Value);
+template clang::LazyGenerationalUpdatePtr<
+    Decl const *, Decl *, &ExternalASTSource::CompleteRedeclChain>::ValueType
+clang::LazyGenerationalUpdatePtr<Decl const *, Decl *,
+                                 &ExternalASTSource::CompleteRedeclChain>::
+    makeValue(clang::ASTContext const &Ctx, Decl *Value);
 
 unsigned char ASTContext::getFixedPointScale(QualType Ty) const {
   assert(Ty->isFixedPointType());
 
-  const TargetInfo &Target = getTargetInfo();
+  TargetInfo const &Target = getTargetInfo();
   switch (Ty->castAs<BuiltinType>()->getKind()) {
-    default:
-      llvm_unreachable("Not a fixed point type!");
-    case BuiltinType::ShortAccum:
-    case BuiltinType::SatShortAccum:
-      return Target.getShortAccumScale();
-    case BuiltinType::Accum:
-    case BuiltinType::SatAccum:
-      return Target.getAccumScale();
-    case BuiltinType::LongAccum:
-    case BuiltinType::SatLongAccum:
-      return Target.getLongAccumScale();
-    case BuiltinType::UShortAccum:
-    case BuiltinType::SatUShortAccum:
-      return Target.getUnsignedShortAccumScale();
-    case BuiltinType::UAccum:
-    case BuiltinType::SatUAccum:
-      return Target.getUnsignedAccumScale();
-    case BuiltinType::ULongAccum:
-    case BuiltinType::SatULongAccum:
-      return Target.getUnsignedLongAccumScale();
-    case BuiltinType::ShortFract:
-    case BuiltinType::SatShortFract:
-      return Target.getShortFractScale();
-    case BuiltinType::Fract:
-    case BuiltinType::SatFract:
-      return Target.getFractScale();
-    case BuiltinType::LongFract:
-    case BuiltinType::SatLongFract:
-      return Target.getLongFractScale();
-    case BuiltinType::UShortFract:
-    case BuiltinType::SatUShortFract:
-      return Target.getUnsignedShortFractScale();
-    case BuiltinType::UFract:
-    case BuiltinType::SatUFract:
-      return Target.getUnsignedFractScale();
-    case BuiltinType::ULongFract:
-    case BuiltinType::SatULongFract:
-      return Target.getUnsignedLongFractScale();
+  default:
+    llvm_unreachable("Not a fixed point type!");
+  case BuiltinType::ShortAccum:
+  case BuiltinType::SatShortAccum:
+    return Target.getShortAccumScale();
+  case BuiltinType::Accum:
+  case BuiltinType::SatAccum:
+    return Target.getAccumScale();
+  case BuiltinType::LongAccum:
+  case BuiltinType::SatLongAccum:
+    return Target.getLongAccumScale();
+  case BuiltinType::UShortAccum:
+  case BuiltinType::SatUShortAccum:
+    return Target.getUnsignedShortAccumScale();
+  case BuiltinType::UAccum:
+  case BuiltinType::SatUAccum:
+    return Target.getUnsignedAccumScale();
+  case BuiltinType::ULongAccum:
+  case BuiltinType::SatULongAccum:
+    return Target.getUnsignedLongAccumScale();
+  case BuiltinType::ShortFract:
+  case BuiltinType::SatShortFract:
+    return Target.getShortFractScale();
+  case BuiltinType::Fract:
+  case BuiltinType::SatFract:
+    return Target.getFractScale();
+  case BuiltinType::LongFract:
+  case BuiltinType::SatLongFract:
+    return Target.getLongFractScale();
+  case BuiltinType::UShortFract:
+  case BuiltinType::SatUShortFract:
+    return Target.getUnsignedShortFractScale();
+  case BuiltinType::UFract:
+  case BuiltinType::SatUFract:
+    return Target.getUnsignedFractScale();
+  case BuiltinType::ULongFract:
+  case BuiltinType::SatULongFract:
+    return Target.getUnsignedLongFractScale();
   }
 }
 
 unsigned char ASTContext::getFixedPointIBits(QualType Ty) const {
   assert(Ty->isFixedPointType());
 
-  const TargetInfo &Target = getTargetInfo();
+  TargetInfo const &Target = getTargetInfo();
   switch (Ty->castAs<BuiltinType>()->getKind()) {
-    default:
-      llvm_unreachable("Not a fixed point type!");
-    case BuiltinType::ShortAccum:
-    case BuiltinType::SatShortAccum:
-      return Target.getShortAccumIBits();
-    case BuiltinType::Accum:
-    case BuiltinType::SatAccum:
-      return Target.getAccumIBits();
-    case BuiltinType::LongAccum:
-    case BuiltinType::SatLongAccum:
-      return Target.getLongAccumIBits();
-    case BuiltinType::UShortAccum:
-    case BuiltinType::SatUShortAccum:
-      return Target.getUnsignedShortAccumIBits();
-    case BuiltinType::UAccum:
-    case BuiltinType::SatUAccum:
-      return Target.getUnsignedAccumIBits();
-    case BuiltinType::ULongAccum:
-    case BuiltinType::SatULongAccum:
-      return Target.getUnsignedLongAccumIBits();
-    case BuiltinType::ShortFract:
-    case BuiltinType::SatShortFract:
-    case BuiltinType::Fract:
-    case BuiltinType::SatFract:
-    case BuiltinType::LongFract:
-    case BuiltinType::SatLongFract:
-    case BuiltinType::UShortFract:
-    case BuiltinType::SatUShortFract:
-    case BuiltinType::UFract:
-    case BuiltinType::SatUFract:
-    case BuiltinType::ULongFract:
-    case BuiltinType::SatULongFract:
-      return 0;
+  default:
+    llvm_unreachable("Not a fixed point type!");
+  case BuiltinType::ShortAccum:
+  case BuiltinType::SatShortAccum:
+    return Target.getShortAccumIBits();
+  case BuiltinType::Accum:
+  case BuiltinType::SatAccum:
+    return Target.getAccumIBits();
+  case BuiltinType::LongAccum:
+  case BuiltinType::SatLongAccum:
+    return Target.getLongAccumIBits();
+  case BuiltinType::UShortAccum:
+  case BuiltinType::SatUShortAccum:
+    return Target.getUnsignedShortAccumIBits();
+  case BuiltinType::UAccum:
+  case BuiltinType::SatUAccum:
+    return Target.getUnsignedAccumIBits();
+  case BuiltinType::ULongAccum:
+  case BuiltinType::SatULongAccum:
+    return Target.getUnsignedLongAccumIBits();
+  case BuiltinType::ShortFract:
+  case BuiltinType::SatShortFract:
+  case BuiltinType::Fract:
+  case BuiltinType::SatFract:
+  case BuiltinType::LongFract:
+  case BuiltinType::SatLongFract:
+  case BuiltinType::UShortFract:
+  case BuiltinType::SatUShortFract:
+  case BuiltinType::UFract:
+  case BuiltinType::SatUFract:
+  case BuiltinType::ULongFract:
+  case BuiltinType::SatULongFract:
+    return 0;
   }
 }
 
@@ -11700,13 +11656,13 @@
 }
 
 ParsedTargetAttr
-ASTContext::filterFunctionTargetAttrs(const TargetAttr *TD) const {
+ASTContext::filterFunctionTargetAttrs(TargetAttr const *TD) const {
   assert(TD != nullptr);
   ParsedTargetAttr ParsedAttr = TD->parse();
 
   ParsedAttr.Features.erase(
       llvm::remove_if(ParsedAttr.Features,
-                      [&](const std::string &Feat) {
+                      [&](std::string const &Feat) {
                         return !Target->isValidFeatureName(
                             StringRef{Feat}.substr(1));
                       }),
@@ -11715,7 +11671,7 @@
 }
 
 void ASTContext::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
-                                       const FunctionDecl *FD) const {
+                                       FunctionDecl const *FD) const {
   if (FD)
     getFunctionFeatureMap(FeatureMap, GlobalDecl().getWithDecl(FD));
   else
@@ -11729,8 +11685,8 @@
 void ASTContext::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
                                        GlobalDecl GD) const {
   StringRef TargetCPU = Target->getTargetOpts().CPU;
-  const FunctionDecl *FD = GD.getDecl()->getAsFunction();
-  if (const auto *TD = FD->getAttr<TargetAttr>()) {
+  FunctionDecl const *FD = GD.getDecl()->getAsFunction();
+  if (auto const *TD = FD->getAttr<TargetAttr>()) {
     ParsedTargetAttr ParsedAttr = filterFunctionTargetAttrs(TD);
 
     // Make a copy of the features as passed on the command line into the
@@ -11750,7 +11706,7 @@
     // the attribute.
     Target->initFeatureMap(FeatureMap, getDiagnostics(), TargetCPU,
                            ParsedAttr.Features);
-  } else if (const auto *SD = FD->getAttr<CPUSpecificAttr>()) {
+  } else if (auto const *SD = FD->getAttr<CPUSpecificAttr>()) {
     llvm::SmallVector<StringRef, 32> FeaturesTmp;
     Target->getCPUSpecificCPUDispatchFeatures(
         SD->getCPUName(GD.getMultiVersionIndex())->getName(), FeaturesTmp);
@@ -11766,15 +11722,15 @@
   return *OMPTraitInfoVector.back();
 }
 
-const StreamingDiagnostic &clang::
-operator<<(const StreamingDiagnostic &DB,
-           const ASTContext::SectionInfo &Section) {
+StreamingDiagnostic const &
+clang::operator<<(StreamingDiagnostic const &DB,
+                  ASTContext::SectionInfo const &Section) {
   if (Section.Decl)
     return DB << Section.Decl;
   return DB << "a prior #pragma section";
 }
 
-bool ASTContext::mayExternalizeStaticVar(const Decl *D) const {
+bool ASTContext::mayExternalizeStaticVar(Decl const *D) const {
   bool IsStaticVar =
       isa<VarDecl>(D) && cast<VarDecl>(D)->getStorageClass() == SC_Static;
   bool IsExplicitDeviceVar = (D->hasAttr<CUDADeviceAttr>() &&
@@ -11783,11 +11739,10 @@
                               !D->getAttr<CUDAConstantAttr>()->isImplicit());
   // CUDA/HIP: static managed variables need to be externalized since it is
   // a declaration in IR, therefore cannot have internal linkage.
-  return IsStaticVar &&
-         (D->hasAttr<HIPManagedAttr>() || IsExplicitDeviceVar);
+  return IsStaticVar && (D->hasAttr<HIPManagedAttr>() || IsExplicitDeviceVar);
 }
 
-bool ASTContext::shouldExternalizeStaticVar(const Decl *D) const {
+bool ASTContext::shouldExternalizeStaticVar(Decl const *D) const {
   return mayExternalizeStaticVar(D) &&
          (D->hasAttr<HIPManagedAttr>() ||
           CUDADeviceVarODRUsedByHost.count(cast<VarDecl>(D)));
@@ -11804,18 +11759,18 @@
 
 // Get the closest named parent, so we can order the sycl naming decls somewhere
 // that mangling is meaningful.
-static const DeclContext *GetNamedParent(const CXXRecordDecl *RD) {
-  const DeclContext *DC = RD->getDeclContext();
+static DeclContext const *GetNamedParent(CXXRecordDecl const *RD) {
+  DeclContext const *DC = RD->getDeclContext();
 
   while (!isa<NamedDecl, TranslationUnitDecl>(DC))
     DC = DC->getParent();
   return DC;
 }
 
-void ASTContext::AddSYCLKernelNamingDecl(const CXXRecordDecl *RD) {
+void ASTContext::AddSYCLKernelNamingDecl(CXXRecordDecl const *RD) {
   assert(getLangOpts().isSYCL() && "Only valid for SYCL programs");
   RD = RD->getCanonicalDecl();
-  const DeclContext *DC = GetNamedParent(RD);
+  DeclContext const *DC = GetNamedParent(RD);
 
   assert(RD->getLocation().isValid() &&
          "Invalid location on kernel naming decl");
@@ -11823,13 +11778,13 @@
   (void)SYCLKernelNamingTypes[DC].insert(RD);
 }
 
-bool ASTContext::IsSYCLKernelNamingDecl(const NamedDecl *ND) const {
+bool ASTContext::IsSYCLKernelNamingDecl(NamedDecl const *ND) const {
   assert(getLangOpts().isSYCL() && "Only valid for SYCL programs");
-  const auto *RD = dyn_cast<CXXRecordDecl>(ND);
+  auto const *RD = dyn_cast<CXXRecordDecl>(ND);
   if (!RD)
     return false;
   RD = RD->getCanonicalDecl();
-  const DeclContext *DC = GetNamedParent(RD);
+  DeclContext const *DC = GetNamedParent(RD);
 
   auto Itr = SYCLKernelNamingTypes.find(DC);
 
@@ -11842,8 +11797,8 @@
 // Filters the Decls list to those that share the lambda mangling with the
 // passed RD.
 void ASTContext::FilterSYCLKernelNamingDecls(
-    const CXXRecordDecl *RD,
-    llvm::SmallVectorImpl<const CXXRecordDecl *> &Decls) {
+    CXXRecordDecl const *RD,
+    llvm::SmallVectorImpl<CXXRecordDecl const *> &Decls) {
 
   if (!SYCLKernelFilterContext)
     SYCLKernelFilterContext.reset(
@@ -11853,7 +11808,7 @@
   llvm::raw_svector_ostream Out(LambdaSig);
   SYCLKernelFilterContext->mangleLambdaSig(RD, Out);
 
-  llvm::erase_if(Decls, [this, &LambdaSig](const CXXRecordDecl *LocalRD) {
+  llvm::erase_if(Decls, [this, &LambdaSig](CXXRecordDecl const *LocalRD) {
     llvm::SmallString<128> LocalLambdaSig;
     llvm::raw_svector_ostream LocalOut(LocalLambdaSig);
     SYCLKernelFilterContext->mangleLambdaSig(LocalRD, LocalOut);
@@ -11861,24 +11816,24 @@
   });
 }
 
-unsigned ASTContext::GetSYCLKernelNamingIndex(const NamedDecl *ND) {
+unsigned ASTContext::GetSYCLKernelNamingIndex(NamedDecl const *ND) {
   assert(getLangOpts().isSYCL() && "Only valid for SYCL programs");
   assert(IsSYCLKernelNamingDecl(ND) &&
          "Lambda not involved in mangling asked for a naming index?");
 
-  const CXXRecordDecl *RD = cast<CXXRecordDecl>(ND)->getCanonicalDecl();
-  const DeclContext *DC = GetNamedParent(RD);
+  CXXRecordDecl const *RD = cast<CXXRecordDecl>(ND)->getCanonicalDecl();
+  DeclContext const *DC = GetNamedParent(RD);
 
   auto Itr = SYCLKernelNamingTypes.find(DC);
   assert(Itr != SYCLKernelNamingTypes.end() && "Not a valid DeclContext?");
 
-  const llvm::SmallPtrSet<const CXXRecordDecl *, 4> &Set = Itr->getSecond();
+  llvm::SmallPtrSet<const CXXRecordDecl *, 4> const &Set = Itr->getSecond();
 
-  llvm::SmallVector<const CXXRecordDecl *> Decls{Set.begin(), Set.end()};
+  llvm::SmallVector<CXXRecordDecl const *> Decls{Set.begin(), Set.end()};
 
   FilterSYCLKernelNamingDecls(RD, Decls);
 
-  llvm::sort(Decls, [](const CXXRecordDecl *LHS, const CXXRecordDecl *RHS) {
+  llvm::sort(Decls, [](CXXRecordDecl const *LHS, CXXRecordDecl const *RHS) {
     return LHS->getLambdaManglingNumber() < RHS->getLambdaManglingNumber();
   });
 
Index: clang/lib/AST/ASTDiagnostic.cpp
===================================================================
--- clang/lib/AST/ASTDiagnostic.cpp
+++ clang/lib/AST/ASTDiagnostic.cpp
@@ -30,41 +30,41 @@
   QualifierCollector QC;
 
   while (true) {
-    const Type *Ty = QC.strip(QT);
+    Type const *Ty = QC.strip(QT);
 
     // Don't aka just because we saw an elaborated type...
-    if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(Ty)) {
+    if (ElaboratedType const *ET = dyn_cast<ElaboratedType>(Ty)) {
       QT = ET->desugar();
       continue;
     }
     // ... or a paren type ...
-    if (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
+    if (ParenType const *PT = dyn_cast<ParenType>(Ty)) {
       QT = PT->desugar();
       continue;
     }
     // ... or a macro defined type ...
-    if (const MacroQualifiedType *MDT = dyn_cast<MacroQualifiedType>(Ty)) {
+    if (MacroQualifiedType const *MDT = dyn_cast<MacroQualifiedType>(Ty)) {
       QT = MDT->desugar();
       continue;
     }
     // ...or a substituted template type parameter ...
-    if (const SubstTemplateTypeParmType *ST =
-          dyn_cast<SubstTemplateTypeParmType>(Ty)) {
+    if (SubstTemplateTypeParmType const *ST =
+            dyn_cast<SubstTemplateTypeParmType>(Ty)) {
       QT = ST->desugar();
       continue;
     }
     // ...or an attributed type...
-    if (const AttributedType *AT = dyn_cast<AttributedType>(Ty)) {
+    if (AttributedType const *AT = dyn_cast<AttributedType>(Ty)) {
       QT = AT->desugar();
       continue;
     }
     // ...or an adjusted type...
-    if (const AdjustedType *AT = dyn_cast<AdjustedType>(Ty)) {
+    if (AdjustedType const *AT = dyn_cast<AdjustedType>(Ty)) {
       QT = AT->desugar();
       continue;
     }
     // ... or an auto type.
-    if (const AutoType *AT = dyn_cast<AutoType>(Ty)) {
+    if (AutoType const *AT = dyn_cast<AutoType>(Ty)) {
       if (!AT->isSugared())
         break;
       QT = AT->desugar();
@@ -73,7 +73,7 @@
 
     // Desugar FunctionType if return type or any parameter type should be
     // desugared. Preserve nullability attribute on desugared types.
-    if (const FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
+    if (FunctionType const *FT = dyn_cast<FunctionType>(Ty)) {
       bool DesugarReturn = false;
       QualType SugarRT = FT->getReturnType();
       QualType RT = Desugar(Context, SugarRT, DesugarReturn);
@@ -84,7 +84,7 @@
 
       bool DesugarArgument = false;
       SmallVector<QualType, 4> Args;
-      const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT);
+      FunctionProtoType const *FPT = dyn_cast<FunctionProtoType>(FT);
       if (FPT) {
         for (QualType SugarPT : FPT->param_types()) {
           QualType PT = Desugar(Context, SugarPT, DesugarArgument);
@@ -107,13 +107,13 @@
 
     // Desugar template specializations if any template argument should be
     // desugared.
-    if (const TemplateSpecializationType *TST =
+    if (TemplateSpecializationType const *TST =
             dyn_cast<TemplateSpecializationType>(Ty)) {
       if (!TST->isTypeAlias()) {
         bool DesugarArgument = false;
         SmallVector<TemplateArgument, 4> Args;
         for (unsigned I = 0, N = TST->getNumArgs(); I != N; ++I) {
-          const TemplateArgument &Arg = TST->getArg(I);
+          TemplateArgument const &Arg = TST->getArg(I);
           if (Arg.getKind() == TemplateArgument::Type)
             Args.push_back(Desugar(Context, Arg.getAsType(), DesugarArgument));
           else
@@ -122,18 +122,18 @@
 
         if (DesugarArgument) {
           ShouldAKA = true;
-          QT = Context.getTemplateSpecializationType(
-              TST->getTemplateName(), Args, QT);
+          QT = Context.getTemplateSpecializationType(TST->getTemplateName(),
+                                                     Args, QT);
         }
         break;
       }
     }
 
     // Don't desugar magic Objective-C types.
-    if (QualType(Ty,0) == Context.getObjCIdType() ||
-        QualType(Ty,0) == Context.getObjCClassType() ||
-        QualType(Ty,0) == Context.getObjCSelType() ||
-        QualType(Ty,0) == Context.getObjCProtoType())
+    if (QualType(Ty, 0) == Context.getObjCIdType() ||
+        QualType(Ty, 0) == Context.getObjCClassType() ||
+        QualType(Ty, 0) == Context.getObjCSelType() ||
+        QualType(Ty, 0) == Context.getObjCProtoType())
       break;
 
     // Don't desugar va_list.
@@ -146,15 +146,15 @@
     bool IsSugar = false;
     switch (Ty->getTypeClass()) {
 #define ABSTRACT_TYPE(Class, Base)
-#define TYPE(Class, Base) \
-case Type::Class: { \
-const Class##Type *CTy = cast<Class##Type>(Ty); \
-if (CTy->isSugared()) { \
-IsSugar = true; \
-Underlying = CTy->desugar(); \
-} \
-break; \
-}
+#define TYPE(Class, Base)                                                      \
+  case Type::Class: {                                                          \
+    const Class##Type *CTy = cast<Class##Type>(Ty);                            \
+    if (CTy->isSugared()) {                                                    \
+      IsSugar = true;                                                          \
+      Underlying = CTy->desugar();                                             \
+    }                                                                          \
+    break;                                                                     \
+  }
 #include "clang/AST/TypeNodes.inc"
     }
 
@@ -168,8 +168,8 @@
       break;
 
     // Don't desugar through the primary typedef of an anonymous type.
-    if (const TagType *UTT = Underlying->getAs<TagType>())
-      if (const TypedefType *QTT = dyn_cast<TypedefType>(QT))
+    if (TagType const *UTT = Underlying->getAs<TagType>())
+      if (TypedefType const *QTT = dyn_cast<TypedefType>(QT))
         if (UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())
           break;
 
@@ -180,25 +180,25 @@
 
   // If we have a pointer-like type, desugar the pointee as well.
   // FIXME: Handle other pointer-like types.
-  if (const PointerType *Ty = QT->getAs<PointerType>()) {
-    QT = Context.getPointerType(Desugar(Context, Ty->getPointeeType(),
-                                        ShouldAKA));
-  } else if (const auto *Ty = QT->getAs<ObjCObjectPointerType>()) {
-    QT = Context.getObjCObjectPointerType(Desugar(Context, Ty->getPointeeType(),
-                                                  ShouldAKA));
-  } else if (const LValueReferenceType *Ty = QT->getAs<LValueReferenceType>()) {
-    QT = Context.getLValueReferenceType(Desugar(Context, Ty->getPointeeType(),
-                                                ShouldAKA));
-  } else if (const RValueReferenceType *Ty = QT->getAs<RValueReferenceType>()) {
-    QT = Context.getRValueReferenceType(Desugar(Context, Ty->getPointeeType(),
-                                                ShouldAKA));
-  } else if (const auto *Ty = QT->getAs<ObjCObjectType>()) {
+  if (PointerType const *Ty = QT->getAs<PointerType>()) {
+    QT = Context.getPointerType(
+        Desugar(Context, Ty->getPointeeType(), ShouldAKA));
+  } else if (auto const *Ty = QT->getAs<ObjCObjectPointerType>()) {
+    QT = Context.getObjCObjectPointerType(
+        Desugar(Context, Ty->getPointeeType(), ShouldAKA));
+  } else if (LValueReferenceType const *Ty = QT->getAs<LValueReferenceType>()) {
+    QT = Context.getLValueReferenceType(
+        Desugar(Context, Ty->getPointeeType(), ShouldAKA));
+  } else if (RValueReferenceType const *Ty = QT->getAs<RValueReferenceType>()) {
+    QT = Context.getRValueReferenceType(
+        Desugar(Context, Ty->getPointeeType(), ShouldAKA));
+  } else if (auto const *Ty = QT->getAs<ObjCObjectType>()) {
     if (Ty->getBaseType().getTypePtr() != Ty && !ShouldAKA) {
       QualType BaseType = Desugar(Context, Ty->getBaseType(), ShouldAKA);
-      QT = Context.getObjCObjectType(BaseType, Ty->getTypeArgsAsWritten(),
-                                     llvm::makeArrayRef(Ty->qual_begin(),
-                                                        Ty->getNumProtocols()),
-                                     Ty->isKindOfTypeAsWritten());
+      QT = Context.getObjCObjectType(
+          BaseType, Ty->getTypeArgsAsWritten(),
+          llvm::makeArrayRef(Ty->qual_begin(), Ty->getNumProtocols()),
+          Ty->isKindOfTypeAsWritten());
     }
   }
 
@@ -229,10 +229,10 @@
 /// \param Ty the type to print
 /// \param QualTypeVals pointer values to QualTypes which are used in the
 /// diagnostic message
-static std::string
-ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty,
-                            ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
-                            ArrayRef<intptr_t> QualTypeVals) {
+static std::string ConvertTypeToDiagnosticString(
+    ASTContext &Context, QualType Ty,
+    ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
+    ArrayRef<intptr_t> QualTypeVals) {
   // FIXME: Playing with std::string is really slow.
   bool ForceAKA = false;
   QualType CanTy = Ty.getCanonicalType();
@@ -241,27 +241,27 @@
 
   for (unsigned I = 0, E = QualTypeVals.size(); I != E; ++I) {
     QualType CompareTy =
-        QualType::getFromOpaquePtr(reinterpret_cast<void*>(QualTypeVals[I]));
+        QualType::getFromOpaquePtr(reinterpret_cast<void *>(QualTypeVals[I]));
     if (CompareTy.isNull())
       continue;
     if (CompareTy == Ty)
-      continue;  // Same types
+      continue; // Same types
     QualType CompareCanTy = CompareTy.getCanonicalType();
     if (CompareCanTy == CanTy)
-      continue;  // Same canonical types
+      continue; // Same canonical types
     std::string CompareS = CompareTy.getAsString(Context.getPrintingPolicy());
     bool ShouldAKA = false;
     QualType CompareDesugar = Desugar(Context, CompareTy, ShouldAKA);
     std::string CompareDesugarStr =
         CompareDesugar.getAsString(Context.getPrintingPolicy());
     if (CompareS != S && CompareDesugarStr != S)
-      continue;  // The type string is different than the comparison string
-                 // and the desugared comparison string.
+      continue; // The type string is different than the comparison string
+                // and the desugared comparison string.
     std::string CompareCanS =
         CompareCanTy.getAsString(Context.getPrintingPolicy());
 
     if (CompareCanS == CanS)
-      continue;  // No new info from canonical type
+      continue; // No new info from canonical type
 
     ForceAKA = true;
     break;
@@ -273,7 +273,7 @@
   for (unsigned i = 0, e = PrevArgs.size(); i != e; ++i) {
     // TODO: Handle ak_declcontext case.
     if (PrevArgs[i].first == DiagnosticsEngine::ak_qualtype) {
-      void *Ptr = (void*)PrevArgs[i].second;
+      void *Ptr = (void *)PrevArgs[i].second;
       QualType PrevTy(QualType::getFromOpaquePtr(Ptr));
       if (PrevTy == Ty) {
         Repeated = true;
@@ -301,10 +301,10 @@
     // Give some additional info on vector types. These are either not desugared
     // or displaying complex __attribute__ expressions so add details of the
     // type and element count.
-    if (const auto *VTy = Ty->getAs<VectorType>()) {
+    if (auto const *VTy = Ty->getAs<VectorType>()) {
       std::string DecoratedString;
       llvm::raw_string_ostream OS(DecoratedString);
-      const char *Values = VTy->getNumElements() > 1 ? "values" : "value";
+      char const *Values = VTy->getNumElements() > 1 ? "values" : "value";
       OS << "'" << S << "' (vector of " << VTy->getNumElements() << " '"
          << VTy->getElementType().getAsString(Context.getPrintingPolicy())
          << "' " << Values << ")";
@@ -322,165 +322,161 @@
                                    bool ShowColors, raw_ostream &OS);
 
 void clang::FormatASTNodeDiagnosticArgument(
-    DiagnosticsEngine::ArgumentKind Kind,
-    intptr_t Val,
-    StringRef Modifier,
-    StringRef Argument,
-    ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
-    SmallVectorImpl<char> &Output,
-    void *Cookie,
+    DiagnosticsEngine::ArgumentKind Kind, intptr_t Val, StringRef Modifier,
+    StringRef Argument, ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
+    SmallVectorImpl<char> &Output, void *Cookie,
     ArrayRef<intptr_t> QualTypeVals) {
-  ASTContext &Context = *static_cast<ASTContext*>(Cookie);
+  ASTContext &Context = *static_cast<ASTContext *>(Cookie);
 
   size_t OldEnd = Output.size();
   llvm::raw_svector_ostream OS(Output);
   bool NeedQuotes = true;
 
   switch (Kind) {
-    default: llvm_unreachable("unknown ArgumentKind");
-    case DiagnosticsEngine::ak_addrspace: {
-      assert(Modifier.empty() && Argument.empty() &&
-             "Invalid modifier for Qualfiers argument");
-
-      auto S = Qualifiers::getAddrSpaceAsString(static_cast<LangAS>(Val));
-      if (S.empty()) {
-        OS << (Context.getLangOpts().OpenCL ? "default" : "generic");
-        OS << " address space";
-      } else {
-        OS << "address space";
-        OS << " '" << S << "'";
-      }
+  default:
+    llvm_unreachable("unknown ArgumentKind");
+  case DiagnosticsEngine::ak_addrspace: {
+    assert(Modifier.empty() && Argument.empty() &&
+           "Invalid modifier for Qualfiers argument");
+
+    auto S = Qualifiers::getAddrSpaceAsString(static_cast<LangAS>(Val));
+    if (S.empty()) {
+      OS << (Context.getLangOpts().OpenCL ? "default" : "generic");
+      OS << " address space";
+    } else {
+      OS << "address space";
+      OS << " '" << S << "'";
+    }
+    NeedQuotes = false;
+    break;
+  }
+  case DiagnosticsEngine::ak_qual: {
+    assert(Modifier.empty() && Argument.empty() &&
+           "Invalid modifier for Qualfiers argument");
+
+    Qualifiers Q(Qualifiers::fromOpaqueValue(Val));
+    auto S = Q.getAsString();
+    if (S.empty()) {
+      OS << "unqualified";
       NeedQuotes = false;
-      break;
+    } else {
+      OS << S;
     }
-    case DiagnosticsEngine::ak_qual: {
-      assert(Modifier.empty() && Argument.empty() &&
-             "Invalid modifier for Qualfiers argument");
-
-      Qualifiers Q(Qualifiers::fromOpaqueValue(Val));
-      auto S = Q.getAsString();
-      if (S.empty()) {
-        OS << "unqualified";
-        NeedQuotes = false;
-      } else {
-        OS << S;
-      }
+    break;
+  }
+  case DiagnosticsEngine::ak_qualtype_pair: {
+    TemplateDiffTypes &TDT = *reinterpret_cast<TemplateDiffTypes *>(Val);
+    QualType FromType =
+        QualType::getFromOpaquePtr(reinterpret_cast<void *>(TDT.FromType));
+    QualType ToType =
+        QualType::getFromOpaquePtr(reinterpret_cast<void *>(TDT.ToType));
+
+    if (FormatTemplateTypeDiff(Context, FromType, ToType, TDT.PrintTree,
+                               TDT.PrintFromType, TDT.ElideType, TDT.ShowColors,
+                               OS)) {
+      NeedQuotes = !TDT.PrintTree;
+      TDT.TemplateDiffUsed = true;
       break;
     }
-    case DiagnosticsEngine::ak_qualtype_pair: {
-      TemplateDiffTypes &TDT = *reinterpret_cast<TemplateDiffTypes*>(Val);
-      QualType FromType =
-          QualType::getFromOpaquePtr(reinterpret_cast<void*>(TDT.FromType));
-      QualType ToType =
-          QualType::getFromOpaquePtr(reinterpret_cast<void*>(TDT.ToType));
-
-      if (FormatTemplateTypeDiff(Context, FromType, ToType, TDT.PrintTree,
-                                 TDT.PrintFromType, TDT.ElideType,
-                                 TDT.ShowColors, OS)) {
-        NeedQuotes = !TDT.PrintTree;
-        TDT.TemplateDiffUsed = true;
-        break;
-      }
 
-      // Don't fall-back during tree printing.  The caller will handle
-      // this case.
-      if (TDT.PrintTree)
-        return;
+    // Don't fall-back during tree printing.  The caller will handle
+    // this case.
+    if (TDT.PrintTree)
+      return;
 
-      // Attempting to do a template diff on non-templates.  Set the variables
-      // and continue with regular type printing of the appropriate type.
-      Val = TDT.PrintFromType ? TDT.FromType : TDT.ToType;
-      Modifier = StringRef();
-      Argument = StringRef();
-      // Fall through
-      LLVM_FALLTHROUGH;
-    }
-    case DiagnosticsEngine::ak_qualtype: {
+    // Attempting to do a template diff on non-templates.  Set the variables
+    // and continue with regular type printing of the appropriate type.
+    Val = TDT.PrintFromType ? TDT.FromType : TDT.ToType;
+    Modifier = StringRef();
+    Argument = StringRef();
+    // Fall through
+    LLVM_FALLTHROUGH;
+  }
+  case DiagnosticsEngine::ak_qualtype: {
+    assert(Modifier.empty() && Argument.empty() &&
+           "Invalid modifier for QualType argument");
+
+    QualType Ty(QualType::getFromOpaquePtr(reinterpret_cast<void *>(Val)));
+    OS << ConvertTypeToDiagnosticString(Context, Ty, PrevArgs, QualTypeVals);
+    NeedQuotes = false;
+    break;
+  }
+  case DiagnosticsEngine::ak_declarationname: {
+    if (Modifier == "objcclass" && Argument.empty())
+      OS << '+';
+    else if (Modifier == "objcinstance" && Argument.empty())
+      OS << '-';
+    else
       assert(Modifier.empty() && Argument.empty() &&
-             "Invalid modifier for QualType argument");
+             "Invalid modifier for DeclarationName argument");
 
-      QualType Ty(QualType::getFromOpaquePtr(reinterpret_cast<void*>(Val)));
-      OS << ConvertTypeToDiagnosticString(Context, Ty, PrevArgs, QualTypeVals);
-      NeedQuotes = false;
-      break;
+    OS << DeclarationName::getFromOpaqueInteger(Val);
+    break;
+  }
+  case DiagnosticsEngine::ak_nameddecl: {
+    bool Qualified;
+    if (Modifier == "q" && Argument.empty())
+      Qualified = true;
+    else {
+      assert(Modifier.empty() && Argument.empty() &&
+             "Invalid modifier for NamedDecl* argument");
+      Qualified = false;
     }
-    case DiagnosticsEngine::ak_declarationname: {
-      if (Modifier == "objcclass" && Argument.empty())
-        OS << '+';
-      else if (Modifier == "objcinstance" && Argument.empty())
-        OS << '-';
+    NamedDecl const *ND = reinterpret_cast<NamedDecl const *>(Val);
+    ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), Qualified);
+    break;
+  }
+  case DiagnosticsEngine::ak_nestednamespec: {
+    NestedNameSpecifier *NNS = reinterpret_cast<NestedNameSpecifier *>(Val);
+    NNS->print(OS, Context.getPrintingPolicy());
+    NeedQuotes = false;
+    break;
+  }
+  case DiagnosticsEngine::ak_declcontext: {
+    DeclContext *DC = reinterpret_cast<DeclContext *>(Val);
+    assert(DC && "Should never have a null declaration context");
+    NeedQuotes = false;
+
+    // FIXME: Get the strings for DeclContext from some localized place
+    if (DC->isTranslationUnit()) {
+      if (Context.getLangOpts().CPlusPlus)
+        OS << "the global namespace";
       else
-        assert(Modifier.empty() && Argument.empty() &&
-               "Invalid modifier for DeclarationName argument");
-
-      OS << DeclarationName::getFromOpaqueInteger(Val);
-      break;
-    }
-    case DiagnosticsEngine::ak_nameddecl: {
-      bool Qualified;
-      if (Modifier == "q" && Argument.empty())
-        Qualified = true;
-      else {
-        assert(Modifier.empty() && Argument.empty() &&
-               "Invalid modifier for NamedDecl* argument");
-        Qualified = false;
-      }
-      const NamedDecl *ND = reinterpret_cast<const NamedDecl*>(Val);
-      ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), Qualified);
-      break;
-    }
-    case DiagnosticsEngine::ak_nestednamespec: {
-      NestedNameSpecifier *NNS = reinterpret_cast<NestedNameSpecifier*>(Val);
-      NNS->print(OS, Context.getPrintingPolicy());
-      NeedQuotes = false;
-      break;
-    }
-    case DiagnosticsEngine::ak_declcontext: {
-      DeclContext *DC = reinterpret_cast<DeclContext *> (Val);
-      assert(DC && "Should never have a null declaration context");
-      NeedQuotes = false;
-
-      // FIXME: Get the strings for DeclContext from some localized place
-      if (DC->isTranslationUnit()) {
-        if (Context.getLangOpts().CPlusPlus)
-          OS << "the global namespace";
-        else
-          OS << "the global scope";
-      } else if (DC->isClosure()) {
-        OS << "block literal";
-      } else if (isLambdaCallOperator(DC)) {
-        OS << "lambda expression";
-      } else if (TypeDecl *Type = dyn_cast<TypeDecl>(DC)) {
-        OS << ConvertTypeToDiagnosticString(Context,
-                                            Context.getTypeDeclType(Type),
-                                            PrevArgs, QualTypeVals);
-      } else {
-        assert(isa<NamedDecl>(DC) && "Expected a NamedDecl");
-        NamedDecl *ND = cast<NamedDecl>(DC);
-        if (isa<NamespaceDecl>(ND))
-          OS << "namespace ";
-        else if (isa<ObjCMethodDecl>(ND))
-          OS << "method ";
-        else if (isa<FunctionDecl>(ND))
-          OS << "function ";
-
-        OS << '\'';
-        ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), true);
-        OS << '\'';
-      }
-      break;
-    }
-    case DiagnosticsEngine::ak_attr: {
-      const Attr *At = reinterpret_cast<Attr *>(Val);
-      assert(At && "Received null Attr object!");
-      OS << '\'' << At->getSpelling() << '\'';
-      NeedQuotes = false;
-      break;
+        OS << "the global scope";
+    } else if (DC->isClosure()) {
+      OS << "block literal";
+    } else if (isLambdaCallOperator(DC)) {
+      OS << "lambda expression";
+    } else if (TypeDecl *Type = dyn_cast<TypeDecl>(DC)) {
+      OS << ConvertTypeToDiagnosticString(
+          Context, Context.getTypeDeclType(Type), PrevArgs, QualTypeVals);
+    } else {
+      assert(isa<NamedDecl>(DC) && "Expected a NamedDecl");
+      NamedDecl *ND = cast<NamedDecl>(DC);
+      if (isa<NamespaceDecl>(ND))
+        OS << "namespace ";
+      else if (isa<ObjCMethodDecl>(ND))
+        OS << "method ";
+      else if (isa<FunctionDecl>(ND))
+        OS << "function ";
+
+      OS << '\'';
+      ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), true);
+      OS << '\'';
     }
+    break;
+  }
+  case DiagnosticsEngine::ak_attr: {
+    Attr const *At = reinterpret_cast<Attr *>(Val);
+    assert(At && "Received null Attr object!");
+    OS << '\'' << At->getSpelling() << '\'';
+    NeedQuotes = false;
+    break;
+  }
   }
 
   if (NeedQuotes) {
-    Output.insert(Output.begin()+OldEnd, '\'');
+    Output.insert(Output.begin() + OldEnd, '\'');
     Output.push_back('\'');
   }
 }
@@ -648,7 +644,7 @@
       SetDefault(FromDefault, ToDefault);
     }
 
-    void SetIntegerDiff(const llvm::APSInt &FromInt, const llvm::APSInt &ToInt,
+    void SetIntegerDiff(llvm::APSInt const &FromInt, llvm::APSInt const &ToInt,
                         bool IsValidFromInt, bool IsValidToInt,
                         QualType FromIntType, QualType ToIntType,
                         Expr *FromExpr, Expr *ToExpr, bool FromDefault,
@@ -685,7 +681,7 @@
 
     void SetFromDeclarationAndToIntegerDiff(
         ValueDecl *FromValueDecl, bool FromAddressOf, bool FromNullPtr,
-        Expr *FromExpr, const llvm::APSInt &ToInt, bool IsValidToInt,
+        Expr *FromExpr, llvm::APSInt const &ToInt, bool IsValidToInt,
         QualType ToIntType, Expr *ToExpr, bool FromDefault, bool ToDefault) {
       assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
       FlatTree[CurrentNode].Kind = FromDeclarationAndToInteger;
@@ -701,7 +697,7 @@
     }
 
     void SetFromIntegerAndToDeclarationDiff(
-        const llvm::APSInt &FromInt, bool IsValidFromInt, QualType FromIntType,
+        llvm::APSInt const &FromInt, bool IsValidFromInt, QualType FromIntType,
         Expr *FromExpr, ValueDecl *ToValueDecl, bool ToAddressOf,
         bool ToNullPtr, Expr *ToExpr, bool FromDefault, bool ToDefault) {
       assert(FlatTree[CurrentNode].Kind == Invalid && "Node is not empty.");
@@ -719,20 +715,17 @@
 
     /// SetDefault - Sets FromDefault and ToDefault flags of the current node.
     void SetDefault(bool FromDefault, bool ToDefault) {
-      assert((!FromDefault || !ToDefault) && "Both arguments cannot be default.");
+      assert((!FromDefault || !ToDefault) &&
+             "Both arguments cannot be default.");
       FlatTree[CurrentNode].FromArgInfo.IsDefault = FromDefault;
       FlatTree[CurrentNode].ToArgInfo.IsDefault = ToDefault;
     }
 
     /// SetSame - Sets the same flag of the current node.
-    void SetSame(bool Same) {
-      FlatTree[CurrentNode].Same = Same;
-    }
+    void SetSame(bool Same) { FlatTree[CurrentNode].Same = Same; }
 
     /// SetKind - Sets the current node's type.
-    void SetKind(DiffKind Kind) {
-      FlatTree[CurrentNode].Kind = Kind;
-    }
+    void SetKind(DiffKind Kind) { FlatTree[CurrentNode].Kind = Kind; }
 
     /// Up - Changes the node to the parent of the current node.
     void Up() {
@@ -773,9 +766,7 @@
     }
 
     /// Parent - Move the current read node to its parent.
-    void Parent() {
-      ReadNode = FlatTree[ReadNode].ParentNode;
-    }
+    void Parent() { ReadNode = FlatTree[ReadNode].ParentNode; }
 
     void GetTemplateDiff(TemplateDecl *&FromTD, TemplateDecl *&ToTD,
                          Qualifiers &FromQual, Qualifiers &ToQual) {
@@ -867,29 +858,19 @@
     }
 
     /// FromDefault - Return true if the from argument is the default.
-    bool FromDefault() {
-      return FlatTree[ReadNode].FromArgInfo.IsDefault;
-    }
+    bool FromDefault() { return FlatTree[ReadNode].FromArgInfo.IsDefault; }
 
     /// ToDefault - Return true if the to argument is the default.
-    bool ToDefault() {
-      return FlatTree[ReadNode].ToArgInfo.IsDefault;
-    }
+    bool ToDefault() { return FlatTree[ReadNode].ToArgInfo.IsDefault; }
 
     /// NodeIsSame - Returns true the arguments are the same.
-    bool NodeIsSame() {
-      return FlatTree[ReadNode].Same;
-    }
+    bool NodeIsSame() { return FlatTree[ReadNode].Same; }
 
     /// HasChildrend - Returns true if the node has children.
-    bool HasChildren() {
-      return FlatTree[ReadNode].ChildNode != 0;
-    }
+    bool HasChildren() { return FlatTree[ReadNode].ChildNode != 0; }
 
     /// MoveToChild - Moves from the current node to its child.
-    void MoveToChild() {
-      ReadNode = FlatTree[ReadNode].ChildNode;
-    }
+    void MoveToChild() { ReadNode = FlatTree[ReadNode].ChildNode; }
 
     /// AdvanceSibling - If there is a next sibling, advance to it and return
     /// true.  Otherwise, return false.
@@ -902,19 +883,13 @@
     }
 
     /// HasNextSibling - Return true if the node has a next sibling.
-    bool HasNextSibling() {
-      return FlatTree[ReadNode].NextNode != 0;
-    }
+    bool HasNextSibling() { return FlatTree[ReadNode].NextNode != 0; }
 
     /// Empty - Returns true if the tree has no information.
-    bool Empty() {
-      return GetKind() == Invalid;
-    }
+    bool Empty() { return GetKind() == Invalid; }
 
     /// GetKind - Returns the current node's type.
-    DiffKind GetKind() {
-      return FlatTree[ReadNode].Kind;
-    }
+    DiffKind GetKind() { return FlatTree[ReadNode].Kind; }
   };
 
   DiffTree Tree;
@@ -924,8 +899,8 @@
   /// The deseguared TemplateArgument should provide the canonical argument
   /// for comparisons.
   class TSTiterator {
-    typedef const TemplateArgument& reference;
-    typedef const TemplateArgument* pointer;
+    typedef TemplateArgument const &reference;
+    typedef TemplateArgument const *pointer;
 
     /// InternalIterator - an iterator that is used to enter a
     /// TemplateSpecializationType and read TemplateArguments inside template
@@ -933,7 +908,7 @@
     struct InternalIterator {
       /// TST - the template specialization whose arguments this iterator
       /// traverse over.
-      const TemplateSpecializationType *TST;
+      TemplateSpecializationType const *TST;
 
       /// Index - the index of the template argument in TST.
       unsigned Index;
@@ -947,22 +922,26 @@
 
       /// InternalIterator - Constructs an iterator and sets it to the first
       /// template argument.
-      InternalIterator(const TemplateSpecializationType *TST)
+      InternalIterator(TemplateSpecializationType const *TST)
           : TST(TST), Index(0), CurrentTA(nullptr), EndTA(nullptr) {
-        if (!TST) return;
+        if (!TST)
+          return;
 
-        if (isEnd()) return;
+        if (isEnd())
+          return;
 
         // Set to first template argument.  If not a parameter pack, done.
         TemplateArgument TA = TST->getArg(0);
-        if (TA.getKind() != TemplateArgument::Pack) return;
+        if (TA.getKind() != TemplateArgument::Pack)
+          return;
 
         // Start looking into the parameter pack.
         CurrentTA = TA.pack_begin();
         EndTA = TA.pack_end();
 
         // Found a valid template argument.
-        if (CurrentTA != EndTA) return;
+        if (CurrentTA != EndTA)
+          return;
 
         // Parameter pack is empty, use the increment to get to a valid
         // template argument.
@@ -1035,7 +1014,7 @@
     InternalIterator DesugaredIterator;
 
   public:
-    TSTiterator(ASTContext &Context, const TemplateSpecializationType *TST)
+    TSTiterator(ASTContext &Context, TemplateSpecializationType const *TST)
         : SugaredIterator(TST),
           DesugaredIterator(
               (TST->isSugared() && !TST->isTypeAlias())
@@ -1051,19 +1030,13 @@
     }
 
     /// operator* - Returns the appropriate TemplateArgument.
-    reference operator*() const {
-      return *SugaredIterator;
-    }
+    reference operator*() const { return *SugaredIterator; }
 
     /// operator-> - Allow access to the underlying TemplateArgument.
-    pointer operator->() const {
-      return &operator*();
-    }
+    pointer operator->() const { return &operator*(); }
 
     /// isEnd - Returns true if no more TemplateArguments are available.
-    bool isEnd() const {
-      return SugaredIterator.isEnd();
-    }
+    bool isEnd() const { return SugaredIterator.isEnd(); }
 
     /// hasDesugaredTA - Returns true if there is another TemplateArgument
     /// available.
@@ -1082,30 +1055,30 @@
   // These functions build up the template diff tree, including functions to
   // retrieve and compare template arguments.
 
-  static const TemplateSpecializationType *GetTemplateSpecializationType(
-      ASTContext &Context, QualType Ty) {
-    if (const TemplateSpecializationType *TST =
+  static TemplateSpecializationType const *
+  GetTemplateSpecializationType(ASTContext &Context, QualType Ty) {
+    if (TemplateSpecializationType const *TST =
             Ty->getAs<TemplateSpecializationType>())
       return TST;
 
-    if (const auto* SubstType = Ty->getAs<SubstTemplateTypeParmType>())
+    if (auto const *SubstType = Ty->getAs<SubstTemplateTypeParmType>())
       Ty = SubstType->getReplacementType();
 
-    const RecordType *RT = Ty->getAs<RecordType>();
+    RecordType const *RT = Ty->getAs<RecordType>();
 
     if (!RT)
       return nullptr;
 
-    const ClassTemplateSpecializationDecl *CTSD =
+    ClassTemplateSpecializationDecl const *CTSD =
         dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
 
     if (!CTSD)
       return nullptr;
 
     Ty = Context.getTemplateSpecializationType(
-             TemplateName(CTSD->getSpecializedTemplate()),
-             CTSD->getTemplateArgs().asArray(),
-             Ty.getLocalUnqualifiedType().getCanonicalType());
+        TemplateName(CTSD->getSpecializedTemplate()),
+        CTSD->getTemplateArgs().asArray(),
+        Ty.getLocalUnqualifiedType().getCanonicalType());
 
     return Ty->getAs<TemplateSpecializationType>();
   }
@@ -1113,8 +1086,8 @@
   /// Returns true if the DiffType is Type and false for Template.
   static bool OnlyPerformTypeDiff(ASTContext &Context, QualType FromType,
                                   QualType ToType,
-                                  const TemplateSpecializationType *&FromArgTST,
-                                  const TemplateSpecializationType *&ToArgTST) {
+                                  TemplateSpecializationType const *&FromArgTST,
+                                  TemplateSpecializationType const *&ToArgTST) {
     if (FromType.isNull() || ToType.isNull())
       return true;
 
@@ -1134,15 +1107,15 @@
   }
 
   /// DiffTypes - Fills a DiffNode with information about a type difference.
-  void DiffTypes(const TSTiterator &FromIter, const TSTiterator &ToIter) {
+  void DiffTypes(TSTiterator const &FromIter, TSTiterator const &ToIter) {
     QualType FromType = GetType(FromIter);
     QualType ToType = GetType(ToIter);
 
     bool FromDefault = FromIter.isEnd() && !FromType.isNull();
     bool ToDefault = ToIter.isEnd() && !ToType.isNull();
 
-    const TemplateSpecializationType *FromArgTST = nullptr;
-    const TemplateSpecializationType *ToArgTST = nullptr;
+    TemplateSpecializationType const *FromArgTST = nullptr;
+    TemplateSpecializationType const *ToArgTST = nullptr;
     if (OnlyPerformTypeDiff(Context, FromType, ToType, FromArgTST, ToArgTST)) {
       Tree.SetTypeDiff(FromType, ToType, FromDefault, ToDefault);
       Tree.SetSame(!FromType.isNull() && !ToType.isNull() &&
@@ -1163,8 +1136,8 @@
 
   /// DiffTemplateTemplates - Fills a DiffNode with information about a
   /// template template difference.
-  void DiffTemplateTemplates(const TSTiterator &FromIter,
-                             const TSTiterator &ToIter) {
+  void DiffTemplateTemplates(TSTiterator const &FromIter,
+                             TSTiterator const &ToIter) {
     TemplateDecl *FromDecl = GetTemplateDecl(FromIter);
     TemplateDecl *ToDecl = GetTemplateDecl(ToIter);
     Tree.SetTemplateTemplateDiff(FromDecl, ToDecl, FromIter.isEnd() && FromDecl,
@@ -1175,7 +1148,7 @@
 
   /// InitializeNonTypeDiffVariables - Helper function for DiffNonTypes
   static void InitializeNonTypeDiffVariables(ASTContext &Context,
-                                             const TSTiterator &Iter,
+                                             TSTiterator const &Iter,
                                              NonTypeTemplateParmDecl *Default,
                                              llvm::APSInt &Value, bool &HasInt,
                                              QualType &IntType, bool &IsNullPtr,
@@ -1183,46 +1156,16 @@
                                              bool &NeedAddressOf) {
     if (!Iter.isEnd()) {
       switch (Iter->getKind()) {
-        default:
-          llvm_unreachable("unknown ArgumentKind");
-        case TemplateArgument::Integral:
-          Value = Iter->getAsIntegral();
-          HasInt = true;
-          IntType = Iter->getIntegralType();
-          return;
-        case TemplateArgument::Declaration: {
-          VD = Iter->getAsDecl();
-          QualType ArgType = Iter->getParamTypeForDecl();
-          QualType VDType = VD->getType();
-          if (ArgType->isPointerType() &&
-              Context.hasSameType(ArgType->getPointeeType(), VDType))
-            NeedAddressOf = true;
-          return;
-        }
-        case TemplateArgument::NullPtr:
-          IsNullPtr = true;
-          return;
-        case TemplateArgument::Expression:
-          E = Iter->getAsExpr();
-      }
-    } else if (!Default->isParameterPack()) {
-      E = Default->getDefaultArgument();
-    }
-
-    if (!Iter.hasDesugaredTA()) return;
-
-    const TemplateArgument& TA = Iter.getDesugaredTA();
-    switch (TA.getKind()) {
       default:
         llvm_unreachable("unknown ArgumentKind");
       case TemplateArgument::Integral:
-        Value = TA.getAsIntegral();
+        Value = Iter->getAsIntegral();
         HasInt = true;
-        IntType = TA.getIntegralType();
+        IntType = Iter->getIntegralType();
         return;
       case TemplateArgument::Declaration: {
-        VD = TA.getAsDecl();
-        QualType ArgType = TA.getParamTypeForDecl();
+        VD = Iter->getAsDecl();
+        QualType ArgType = Iter->getParamTypeForDecl();
         QualType VDType = VD->getType();
         if (ArgType->isPointerType() &&
             Context.hasSameType(ArgType->getPointeeType(), VDType))
@@ -1233,18 +1176,49 @@
         IsNullPtr = true;
         return;
       case TemplateArgument::Expression:
-        // TODO: Sometimes, the desugared template argument Expr differs from
-        // the sugared template argument Expr.  It may be useful in the future
-        // but for now, it is just discarded.
-        if (!E)
-          E = TA.getAsExpr();
-        return;
+        E = Iter->getAsExpr();
+      }
+    } else if (!Default->isParameterPack()) {
+      E = Default->getDefaultArgument();
+    }
+
+    if (!Iter.hasDesugaredTA())
+      return;
+
+    TemplateArgument const &TA = Iter.getDesugaredTA();
+    switch (TA.getKind()) {
+    default:
+      llvm_unreachable("unknown ArgumentKind");
+    case TemplateArgument::Integral:
+      Value = TA.getAsIntegral();
+      HasInt = true;
+      IntType = TA.getIntegralType();
+      return;
+    case TemplateArgument::Declaration: {
+      VD = TA.getAsDecl();
+      QualType ArgType = TA.getParamTypeForDecl();
+      QualType VDType = VD->getType();
+      if (ArgType->isPointerType() &&
+          Context.hasSameType(ArgType->getPointeeType(), VDType))
+        NeedAddressOf = true;
+      return;
+    }
+    case TemplateArgument::NullPtr:
+      IsNullPtr = true;
+      return;
+    case TemplateArgument::Expression:
+      // TODO: Sometimes, the desugared template argument Expr differs from
+      // the sugared template argument Expr.  It may be useful in the future
+      // but for now, it is just discarded.
+      if (!E)
+        E = TA.getAsExpr();
+      return;
     }
   }
 
   /// DiffNonTypes - Handles any template parameters not handled by DiffTypes
   /// of DiffTemplatesTemplates, such as integer and declaration parameters.
-  void DiffNonTypes(const TSTiterator &FromIter, const TSTiterator &ToIter,
+  void DiffNonTypes(TSTiterator const &FromIter, TSTiterator const &ToIter,
                     NonTypeTemplateParmDecl *FromDefaultNonTypeDecl,
                     NonTypeTemplateParmDecl *ToDefaultNonTypeDecl) {
     Expr *FromExpr = nullptr, *ToExpr = nullptr;
@@ -1262,8 +1236,8 @@
 
     bool FromDefault = FromIter.isEnd() &&
                        (FromExpr || FromValueDecl || HasFromInt || FromNullPtr);
-    bool ToDefault = ToIter.isEnd() &&
-                     (ToExpr || ToValueDecl || HasToInt || ToNullPtr);
+    bool ToDefault =
+        ToIter.isEnd() && (ToExpr || ToValueDecl || HasToInt || ToNullPtr);
 
     bool FromDeclaration = FromValueDecl || FromNullPtr;
     bool ToDeclaration = ToValueDecl || ToNullPtr;
@@ -1274,7 +1248,6 @@
           HasToInt, ToIntType, ToExpr, FromDefault, ToDefault);
       Tree.SetSame(false);
       return;
-
     }
 
     if (HasFromInt && ToDeclaration) {
@@ -1315,8 +1288,8 @@
 
   /// DiffTemplate - recursively visits template arguments and stores the
   /// argument info into a tree.
-  void DiffTemplate(const TemplateSpecializationType *FromTST,
-                    const TemplateSpecializationType *ToTST) {
+  void DiffTemplate(TemplateSpecializationType const *FromTST,
+                    TemplateSpecializationType const *ToTST) {
     // Begin descent into diffing template tree.
     TemplateParameterList *ParamsFrom =
         FromTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
@@ -1361,8 +1334,8 @@
 
   /// makeTemplateList - Dump every template alias into the vector.
   static void makeTemplateList(
-      SmallVectorImpl<const TemplateSpecializationType *> &TemplateList,
-      const TemplateSpecializationType *TST) {
+      SmallVectorImpl<TemplateSpecializationType const *> &TemplateList,
+      TemplateSpecializationType const *TST) {
     while (TST) {
       TemplateList.push_back(TST);
       if (!TST->isTypeAlias())
@@ -1373,8 +1346,8 @@
 
   /// hasSameBaseTemplate - Returns true when the base templates are the same,
   /// even if the template arguments are not.
-  static bool hasSameBaseTemplate(const TemplateSpecializationType *FromTST,
-                                  const TemplateSpecializationType *ToTST) {
+  static bool hasSameBaseTemplate(TemplateSpecializationType const *FromTST,
+                                  TemplateSpecializationType const *ToTST) {
     return FromTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl() ==
            ToTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl();
   }
@@ -1383,22 +1356,23 @@
   /// same template declaration.  If they come from different template aliases,
   /// do a parallel ascension search to determine the highest template alias in
   /// common and set the arguments to them.
-  static bool hasSameTemplate(const TemplateSpecializationType *&FromTST,
-                              const TemplateSpecializationType *&ToTST) {
+  static bool hasSameTemplate(TemplateSpecializationType const *&FromTST,
+                              TemplateSpecializationType const *&ToTST) {
     // Check the top templates if they are the same.
     if (hasSameBaseTemplate(FromTST, ToTST))
       return true;
 
     // Create vectors of template aliases.
-    SmallVector<const TemplateSpecializationType*, 1> FromTemplateList,
-                                                      ToTemplateList;
+    SmallVector<TemplateSpecializationType const *, 1> FromTemplateList,
+        ToTemplateList;
 
     makeTemplateList(FromTemplateList, FromTST);
     makeTemplateList(ToTemplateList, ToTST);
 
-    SmallVectorImpl<const TemplateSpecializationType *>::reverse_iterator
-        FromIter = FromTemplateList.rbegin(), FromEnd = FromTemplateList.rend(),
-        ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();
+    SmallVectorImpl<TemplateSpecializationType const *>::reverse_iterator
+        FromIter = FromTemplateList.rbegin(),
+        FromEnd = FromTemplateList.rend(), ToIter = ToTemplateList.rbegin(),
+        ToEnd = ToTemplateList.rend();
 
     // Check if the lowest template types are the same.  If not, return.
     if (!hasSameBaseTemplate(*FromIter, *ToIter))
@@ -1420,7 +1394,7 @@
 
   /// GetType - Retrieves the template type arguments, including default
   /// arguments.
-  static QualType GetType(const TSTiterator &Iter) {
+  static QualType GetType(TSTiterator const &Iter) {
     if (!Iter.isEnd())
       return Iter->getAsType();
     if (Iter.hasDesugaredTA())
@@ -1430,7 +1404,7 @@
 
   /// GetTemplateDecl - Retrieves the template template arguments, including
   /// default arguments.
-  static TemplateDecl *GetTemplateDecl(const TSTiterator &Iter) {
+  static TemplateDecl *GetTemplateDecl(TSTiterator const &Iter) {
     if (!Iter.isEnd())
       return Iter->getAsTemplate().getAsTemplateDecl();
     if (Iter.hasDesugaredTA())
@@ -1469,137 +1443,137 @@
     // Handle cases where the difference is not templates with different
     // arguments.
     switch (Tree.GetKind()) {
-      case DiffTree::Invalid:
-        llvm_unreachable("Template diffing failed with bad DiffNode");
-      case DiffTree::Type: {
-        QualType FromType, ToType;
-        Tree.GetTypeDiff(FromType, ToType);
-        PrintTypeNames(FromType, ToType, Tree.FromDefault(), Tree.ToDefault(),
-                       Tree.NodeIsSame());
-        return;
-      }
-      case DiffTree::Expression: {
-        Expr *FromExpr, *ToExpr;
-        Tree.GetExpressionDiff(FromExpr, ToExpr);
-        PrintExpr(FromExpr, ToExpr, Tree.FromDefault(), Tree.ToDefault(),
-                  Tree.NodeIsSame());
-        return;
-      }
-      case DiffTree::TemplateTemplate: {
-        TemplateDecl *FromTD, *ToTD;
-        Tree.GetTemplateTemplateDiff(FromTD, ToTD);
-        PrintTemplateTemplate(FromTD, ToTD, Tree.FromDefault(),
-                              Tree.ToDefault(), Tree.NodeIsSame());
-        return;
-      }
-      case DiffTree::Integer: {
-        llvm::APSInt FromInt, ToInt;
-        Expr *FromExpr, *ToExpr;
-        bool IsValidFromInt, IsValidToInt;
-        QualType FromIntType, ToIntType;
-        Tree.GetIntegerDiff(FromInt, ToInt, IsValidFromInt, IsValidToInt,
-                            FromIntType, ToIntType, FromExpr, ToExpr);
-        PrintAPSInt(FromInt, ToInt, IsValidFromInt, IsValidToInt, FromIntType,
-                    ToIntType, FromExpr, ToExpr, Tree.FromDefault(),
-                    Tree.ToDefault(), Tree.NodeIsSame());
-        return;
-      }
-      case DiffTree::Declaration: {
-        ValueDecl *FromValueDecl, *ToValueDecl;
-        bool FromAddressOf, ToAddressOf;
-        bool FromNullPtr, ToNullPtr;
-        Expr *FromExpr, *ToExpr;
-        Tree.GetDeclarationDiff(FromValueDecl, ToValueDecl, FromAddressOf,
-                                ToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
-                                ToExpr);
-        PrintValueDecl(FromValueDecl, ToValueDecl, FromAddressOf, ToAddressOf,
-                       FromNullPtr, ToNullPtr, FromExpr, ToExpr,
-                       Tree.FromDefault(), Tree.ToDefault(), Tree.NodeIsSame());
-        return;
-      }
-      case DiffTree::FromDeclarationAndToInteger: {
-        ValueDecl *FromValueDecl;
-        bool FromAddressOf;
-        bool FromNullPtr;
-        Expr *FromExpr;
-        llvm::APSInt ToInt;
-        bool IsValidToInt;
-        QualType ToIntType;
-        Expr *ToExpr;
-        Tree.GetFromDeclarationAndToIntegerDiff(
-            FromValueDecl, FromAddressOf, FromNullPtr, FromExpr, ToInt,
-            IsValidToInt, ToIntType, ToExpr);
-        assert((FromValueDecl || FromNullPtr) && IsValidToInt);
-        PrintValueDeclAndInteger(FromValueDecl, FromAddressOf, FromNullPtr,
-                                 FromExpr, Tree.FromDefault(), ToInt, ToIntType,
-                                 ToExpr, Tree.ToDefault());
-        return;
-      }
-      case DiffTree::FromIntegerAndToDeclaration: {
-        llvm::APSInt FromInt;
-        bool IsValidFromInt;
-        QualType FromIntType;
-        Expr *FromExpr;
-        ValueDecl *ToValueDecl;
-        bool ToAddressOf;
-        bool ToNullPtr;
-        Expr *ToExpr;
-        Tree.GetFromIntegerAndToDeclarationDiff(
-            FromInt, IsValidFromInt, FromIntType, FromExpr, ToValueDecl,
-            ToAddressOf, ToNullPtr, ToExpr);
-        assert(IsValidFromInt && (ToValueDecl || ToNullPtr));
-        PrintIntegerAndValueDecl(FromInt, FromIntType, FromExpr,
-                                 Tree.FromDefault(), ToValueDecl, ToAddressOf,
-                                 ToNullPtr, ToExpr, Tree.ToDefault());
+    case DiffTree::Invalid:
+      llvm_unreachable("Template diffing failed with bad DiffNode");
+    case DiffTree::Type: {
+      QualType FromType, ToType;
+      Tree.GetTypeDiff(FromType, ToType);
+      PrintTypeNames(FromType, ToType, Tree.FromDefault(), Tree.ToDefault(),
+                     Tree.NodeIsSame());
+      return;
+    }
+    case DiffTree::Expression: {
+      Expr *FromExpr, *ToExpr;
+      Tree.GetExpressionDiff(FromExpr, ToExpr);
+      PrintExpr(FromExpr, ToExpr, Tree.FromDefault(), Tree.ToDefault(),
+                Tree.NodeIsSame());
+      return;
+    }
+    case DiffTree::TemplateTemplate: {
+      TemplateDecl *FromTD, *ToTD;
+      Tree.GetTemplateTemplateDiff(FromTD, ToTD);
+      PrintTemplateTemplate(FromTD, ToTD, Tree.FromDefault(), Tree.ToDefault(),
+                            Tree.NodeIsSame());
+      return;
+    }
+    case DiffTree::Integer: {
+      llvm::APSInt FromInt, ToInt;
+      Expr *FromExpr, *ToExpr;
+      bool IsValidFromInt, IsValidToInt;
+      QualType FromIntType, ToIntType;
+      Tree.GetIntegerDiff(FromInt, ToInt, IsValidFromInt, IsValidToInt,
+                          FromIntType, ToIntType, FromExpr, ToExpr);
+      PrintAPSInt(FromInt, ToInt, IsValidFromInt, IsValidToInt, FromIntType,
+                  ToIntType, FromExpr, ToExpr, Tree.FromDefault(),
+                  Tree.ToDefault(), Tree.NodeIsSame());
+      return;
+    }
+    case DiffTree::Declaration: {
+      ValueDecl *FromValueDecl, *ToValueDecl;
+      bool FromAddressOf, ToAddressOf;
+      bool FromNullPtr, ToNullPtr;
+      Expr *FromExpr, *ToExpr;
+      Tree.GetDeclarationDiff(FromValueDecl, ToValueDecl, FromAddressOf,
+                              ToAddressOf, FromNullPtr, ToNullPtr, FromExpr,
+                              ToExpr);
+      PrintValueDecl(FromValueDecl, ToValueDecl, FromAddressOf, ToAddressOf,
+                     FromNullPtr, ToNullPtr, FromExpr, ToExpr,
+                     Tree.FromDefault(), Tree.ToDefault(), Tree.NodeIsSame());
+      return;
+    }
+    case DiffTree::FromDeclarationAndToInteger: {
+      ValueDecl *FromValueDecl;
+      bool FromAddressOf;
+      bool FromNullPtr;
+      Expr *FromExpr;
+      llvm::APSInt ToInt;
+      bool IsValidToInt;
+      QualType ToIntType;
+      Expr *ToExpr;
+      Tree.GetFromDeclarationAndToIntegerDiff(FromValueDecl, FromAddressOf,
+                                              FromNullPtr, FromExpr, ToInt,
+                                              IsValidToInt, ToIntType, ToExpr);
+      assert((FromValueDecl || FromNullPtr) && IsValidToInt);
+      PrintValueDeclAndInteger(FromValueDecl, FromAddressOf, FromNullPtr,
+                               FromExpr, Tree.FromDefault(), ToInt, ToIntType,
+                               ToExpr, Tree.ToDefault());
+      return;
+    }
+    case DiffTree::FromIntegerAndToDeclaration: {
+      llvm::APSInt FromInt;
+      bool IsValidFromInt;
+      QualType FromIntType;
+      Expr *FromExpr;
+      ValueDecl *ToValueDecl;
+      bool ToAddressOf;
+      bool ToNullPtr;
+      Expr *ToExpr;
+      Tree.GetFromIntegerAndToDeclarationDiff(
+          FromInt, IsValidFromInt, FromIntType, FromExpr, ToValueDecl,
+          ToAddressOf, ToNullPtr, ToExpr);
+      assert(IsValidFromInt && (ToValueDecl || ToNullPtr));
+      PrintIntegerAndValueDecl(FromInt, FromIntType, FromExpr,
+                               Tree.FromDefault(), ToValueDecl, ToAddressOf,
+                               ToNullPtr, ToExpr, Tree.ToDefault());
+      return;
+    }
+    case DiffTree::Template: {
+      // Node is root of template.  Recurse on children.
+      TemplateDecl *FromTD, *ToTD;
+      Qualifiers FromQual, ToQual;
+      Tree.GetTemplateDiff(FromTD, ToTD, FromQual, ToQual);
+
+      PrintQualifiers(FromQual, ToQual);
+
+      if (!Tree.HasChildren()) {
+        // If we're dealing with a template specialization with zero
+        // arguments, there are no children; special-case this.
+        OS << FromTD->getDeclName() << "<>";
         return;
       }
-      case DiffTree::Template: {
-        // Node is root of template.  Recurse on children.
-        TemplateDecl *FromTD, *ToTD;
-        Qualifiers FromQual, ToQual;
-        Tree.GetTemplateDiff(FromTD, ToTD, FromQual, ToQual);
-
-        PrintQualifiers(FromQual, ToQual);
-
-        if (!Tree.HasChildren()) {
-          // If we're dealing with a template specialization with zero
-          // arguments, there are no children; special-case this.
-          OS << FromTD->getDeclName() << "<>";
-          return;
-        }
 
-        OS << FromTD->getDeclName() << '<';
-        Tree.MoveToChild();
-        unsigned NumElideArgs = 0;
-        bool AllArgsElided = true;
-        do {
-          if (ElideType) {
-            if (Tree.NodeIsSame()) {
-              ++NumElideArgs;
-              continue;
-            }
-            AllArgsElided = false;
-            if (NumElideArgs > 0) {
-              PrintElideArgs(NumElideArgs, Indent);
-              NumElideArgs = 0;
-              OS << ", ";
-            }
+      OS << FromTD->getDeclName() << '<';
+      Tree.MoveToChild();
+      unsigned NumElideArgs = 0;
+      bool AllArgsElided = true;
+      do {
+        if (ElideType) {
+          if (Tree.NodeIsSame()) {
+            ++NumElideArgs;
+            continue;
           }
-          TreeToString(Indent);
-          if (Tree.HasNextSibling())
-            OS << ", ";
-        } while (Tree.AdvanceSibling());
-        if (NumElideArgs > 0) {
-          if (AllArgsElided)
-            OS << "...";
-          else
+          AllArgsElided = false;
+          if (NumElideArgs > 0) {
             PrintElideArgs(NumElideArgs, Indent);
+            NumElideArgs = 0;
+            OS << ", ";
+          }
         }
-
-        Tree.Parent();
-        OS << ">";
-        return;
+        TreeToString(Indent);
+        if (Tree.HasNextSibling())
+          OS << ", ";
+      } while (Tree.AdvanceSibling());
+      if (NumElideArgs > 0) {
+        if (AllArgsElided)
+          OS << "...";
+        else
+          PrintElideArgs(NumElideArgs, Indent);
       }
+
+      Tree.Parent();
+      OS << ">";
+      return;
+    }
     }
   }
 
@@ -1628,8 +1602,8 @@
   /// PrintTypeNames - prints the typenames, bolding differences.  Will detect
   /// typenames that are the same and attempt to disambiguate them by using
   /// canonical typenames.
-  void PrintTypeNames(QualType FromType, QualType ToType,
-                      bool FromDefault, bool ToDefault, bool Same) {
+  void PrintTypeNames(QualType FromType, QualType ToType, bool FromDefault,
+                      bool ToDefault, bool Same) {
     assert((!FromType.isNull() || !ToType.isNull()) &&
            "Only one template argument may be missing.");
 
@@ -1640,7 +1614,7 @@
 
     if (!FromType.isNull() && !ToType.isNull() &&
         FromType.getLocalUnqualifiedType() ==
-        ToType.getLocalUnqualifiedType()) {
+            ToType.getLocalUnqualifiedType()) {
       Qualifiers FromQual = FromType.getLocalQualifiers(),
                  ToQual = ToType.getLocalQualifiers();
       PrintQualifiers(FromQual, ToQual);
@@ -1648,10 +1622,10 @@
       return;
     }
 
-    std::string FromTypeStr = FromType.isNull() ? "(no argument)"
-                                                : FromType.getAsString(Policy);
-    std::string ToTypeStr = ToType.isNull() ? "(no argument)"
-                                            : ToType.getAsString(Policy);
+    std::string FromTypeStr =
+        FromType.isNull() ? "(no argument)" : FromType.getAsString(Policy);
+    std::string ToTypeStr =
+        ToType.isNull() ? "(no argument)" : ToType.getAsString(Policy);
     // Switch to canonical typename if it is better.
     // TODO: merge this with other aka printing above.
     if (FromTypeStr == ToTypeStr) {
@@ -1664,7 +1638,8 @@
       }
     }
 
-    if (PrintTree) OS << '[';
+    if (PrintTree)
+      OS << '[';
     OS << (FromDefault ? "(default) " : "");
     Bold();
     OS << FromTypeStr;
@@ -1680,10 +1655,10 @@
 
   /// PrintExpr - Prints out the expr template arguments, highlighting argument
   /// differences.
-  void PrintExpr(const Expr *FromExpr, const Expr *ToExpr, bool FromDefault,
+  void PrintExpr(Expr const *FromExpr, Expr const *ToExpr, bool FromDefault,
                  bool ToDefault, bool Same) {
     assert((FromExpr || ToExpr) &&
-            "Only one template argument may be missing.");
+           "Only one template argument may be missing.");
     if (Same) {
       PrintExpr(FromExpr);
     } else if (!PrintTree) {
@@ -1705,7 +1680,7 @@
   }
 
   /// PrintExpr - Actual formatting and printing of expressions.
-  void PrintExpr(const Expr *E) {
+  void PrintExpr(Expr const *E) {
     if (E) {
       E->printPretty(OS, nullptr, Policy);
       return;
@@ -1749,7 +1724,7 @@
 
   /// PrintAPSInt - Handles printing of integral arguments, highlighting
   /// argument differences.
-  void PrintAPSInt(const llvm::APSInt &FromInt, const llvm::APSInt &ToInt,
+  void PrintAPSInt(llvm::APSInt const &FromInt, llvm::APSInt const &ToInt,
                    bool IsValidFromInt, bool IsValidToInt, QualType FromIntType,
                    QualType ToIntType, Expr *FromExpr, Expr *ToExpr,
                    bool FromDefault, bool ToDefault, bool Same) {
@@ -1782,7 +1757,7 @@
 
   /// PrintAPSInt - If valid, print the APSInt.  If the expression is
   /// gives more information, print it too.
-  void PrintAPSInt(const llvm::APSInt &Val, Expr *E, bool Valid,
+  void PrintAPSInt(llvm::APSInt const &Val, Expr *E, bool Valid,
                    QualType IntType, bool PrintType) {
     Bold();
     if (Valid) {
@@ -1817,11 +1792,13 @@
   /// HasExtraInfo - Returns true if E is not an integer literal, the
   /// negation of an integer literal, or a boolean literal.
   bool HasExtraInfo(Expr *E) {
-    if (!E) return false;
+    if (!E)
+      return false;
 
     E = E->IgnoreImpCasts();
 
-    if (isa<IntegerLiteral>(E)) return false;
+    if (isa<IntegerLiteral>(E))
+      return false;
 
     if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
       if (UO->getOpcode() == UO_Minus)
@@ -1901,7 +1878,7 @@
   /// APSInt to print a mixed difference.
   void PrintValueDeclAndInteger(ValueDecl *VD, bool NeedAddressOf,
                                 bool IsNullPtr, Expr *VDExpr, bool DefaultDecl,
-                                const llvm::APSInt &Val, QualType IntType,
+                                llvm::APSInt const &Val, QualType IntType,
                                 Expr *IntExpr, bool DefaultInt) {
     if (!PrintTree) {
       OS << (DefaultDecl ? "(default) " : "");
@@ -1921,7 +1898,7 @@
 
   /// PrintIntegerAndValueDecl - Uses the print functions for APSInt and
   /// ValueDecl to print a mixed difference.
-  void PrintIntegerAndValueDecl(const llvm::APSInt &Val, QualType IntType,
+  void PrintIntegerAndValueDecl(llvm::APSInt const &Val, QualType IntType,
                                 Expr *IntExpr, bool DefaultInt, ValueDecl *VD,
                                 bool NeedAddressOf, bool IsNullPtr,
                                 Expr *VDExpr, bool DefaultDecl) {
@@ -1946,7 +1923,8 @@
       for (unsigned i = 0; i < Indent; ++i)
         OS << "  ";
     }
-    if (NumElideArgs == 0) return;
+    if (NumElideArgs == 0)
+      return;
     if (NumElideArgs == 1)
       OS << "[...]";
     else
@@ -1961,13 +1939,13 @@
 
     // Both types have same qualifiers
     if (FromQual == ToQual) {
-      PrintQualifier(FromQual, /*ApplyBold*/false);
+      PrintQualifier(FromQual, /*ApplyBold*/ false);
       return;
     }
 
     // Find common qualifiers and strip them from FromQual and ToQual.
-    Qualifiers CommonQual = Qualifiers::removeCommonQualifiers(FromQual,
-                                                               ToQual);
+    Qualifiers CommonQual =
+        Qualifiers::removeCommonQualifiers(FromQual, ToQual);
 
     // The qualifiers are printed before the template name.
     // Inline printing:
@@ -1986,8 +1964,8 @@
         OS << "(no qualifiers) ";
         Unbold();
       } else {
-        PrintQualifier(CommonQual, /*ApplyBold*/false);
-        PrintQualifier(FromQual, /*ApplyBold*/true);
+        PrintQualifier(CommonQual, /*ApplyBold*/ false);
+        PrintQualifier(FromQual, /*ApplyBold*/ true);
       }
       OS << "!= ";
       if (CommonQual.empty() && ToQual.empty()) {
@@ -1995,51 +1973,48 @@
         OS << "(no qualifiers)";
         Unbold();
       } else {
-        PrintQualifier(CommonQual, /*ApplyBold*/false,
-                       /*appendSpaceIfNonEmpty*/!ToQual.empty());
-        PrintQualifier(ToQual, /*ApplyBold*/true,
-                       /*appendSpaceIfNonEmpty*/false);
+        PrintQualifier(CommonQual, /*ApplyBold*/ false,
+                       /*appendSpaceIfNonEmpty*/ !ToQual.empty());
+        PrintQualifier(ToQual, /*ApplyBold*/ true,
+                       /*appendSpaceIfNonEmpty*/ false);
       }
       OS << "] ";
     } else {
-      PrintQualifier(CommonQual, /*ApplyBold*/false);
-      PrintQualifier(FromQual, /*ApplyBold*/true);
+      PrintQualifier(CommonQual, /*ApplyBold*/ false);
+      PrintQualifier(FromQual, /*ApplyBold*/ true);
     }
   }
 
   void PrintQualifier(Qualifiers Q, bool ApplyBold,
                       bool AppendSpaceIfNonEmpty = true) {
-    if (Q.empty()) return;
-    if (ApplyBold) Bold();
+    if (Q.empty())
+      return;
+    if (ApplyBold)
+      Bold();
     Q.print(OS, Policy, AppendSpaceIfNonEmpty);
-    if (ApplyBold) Unbold();
+    if (ApplyBold)
+      Unbold();
   }
 
 public:
-
   TemplateDiff(raw_ostream &OS, ASTContext &Context, QualType FromType,
                QualType ToType, bool PrintTree, bool PrintFromType,
                bool ElideType, bool ShowColor)
-    : Context(Context),
-      Policy(Context.getLangOpts()),
-      ElideType(ElideType),
-      PrintTree(PrintTree),
-      ShowColor(ShowColor),
-      // When printing a single type, the FromType is the one printed.
-      FromTemplateType(PrintFromType ? FromType : ToType),
-      ToTemplateType(PrintFromType ? ToType : FromType),
-      OS(OS),
-      IsBold(false) {
-  }
+      : Context(Context), Policy(Context.getLangOpts()), ElideType(ElideType),
+        PrintTree(PrintTree), ShowColor(ShowColor),
+        // When printing a single type, the FromType is the one printed.
+        FromTemplateType(PrintFromType ? FromType : ToType),
+        ToTemplateType(PrintFromType ? ToType : FromType), OS(OS),
+        IsBold(false) {}
 
   /// DiffTemplate - Start the template type diffing.
   void DiffTemplate() {
     Qualifiers FromQual = FromTemplateType.getQualifiers(),
                ToQual = ToTemplateType.getQualifiers();
 
-    const TemplateSpecializationType *FromOrigTST =
+    TemplateSpecializationType const *FromOrigTST =
         GetTemplateSpecializationType(Context, FromTemplateType);
-    const TemplateSpecializationType *ToOrigTST =
+    TemplateSpecializationType const *ToOrigTST =
         GetTemplateSpecializationType(Context, ToTemplateType);
 
     // Only checking templates.
@@ -2076,7 +2051,7 @@
     return true;
   }
 }; // end class TemplateDiff
-}  // end anonymous namespace
+} // end anonymous namespace
 
 /// FormatTemplateTypeDiff - A helper static function to start the template
 /// diff and return the properly formatted string.  Returns true if the diff
Index: clang/lib/AST/ASTDumper.cpp
===================================================================
--- clang/lib/AST/ASTDumper.cpp
+++ clang/lib/AST/ASTDumper.cpp
@@ -22,7 +22,7 @@
 using namespace clang;
 using namespace clang::comments;
 
-void ASTDumper::dumpLookups(const DeclContext *DC, bool DumpDecls) {
+void ASTDumper::dumpLookups(DeclContext const *DC, bool DumpDecls) {
   NodeDumper.AddChild([=] {
     OS << "StoredDeclsMap ";
     NodeDumper.dumpBareDeclRef(cast<Decl>(DC));
@@ -82,11 +82,11 @@
 }
 
 template <typename SpecializationDecl>
-void ASTDumper::dumpTemplateDeclSpecialization(const SpecializationDecl *D,
+void ASTDumper::dumpTemplateDeclSpecialization(SpecializationDecl const *D,
                                                bool DumpExplicitInst,
                                                bool DumpRefOnly) {
   bool DumpedAny = false;
-  for (const auto *RedeclWithBadType : D->redecls()) {
+  for (auto const *RedeclWithBadType : D->redecls()) {
     // FIXME: The redecls() range sometimes has elements of a less-specific
     // type. (In particular, ClassTemplateSpecializationDecl::redecls() gives
     // us TagDecls, and should give CXXRecordDecls).
@@ -124,30 +124,30 @@
 }
 
 template <typename TemplateDecl>
-void ASTDumper::dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst) {
+void ASTDumper::dumpTemplateDecl(TemplateDecl const *D, bool DumpExplicitInst) {
   dumpTemplateParameters(D->getTemplateParameters());
 
   Visit(D->getTemplatedDecl());
 
   if (GetTraversalKind() == TK_AsIs) {
-    for (const auto *Child : D->specializations())
+    for (auto const *Child : D->specializations())
       dumpTemplateDeclSpecialization(Child, DumpExplicitInst,
                                      !D->isCanonicalDecl());
   }
 }
 
-void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
+void ASTDumper::VisitFunctionTemplateDecl(FunctionTemplateDecl const *D) {
   // FIXME: We don't add a declaration of a function template specialization
   // to its context when it's explicitly instantiated, so dump explicit
   // instantiations when we dump the template itself.
   dumpTemplateDecl(D, true);
 }
 
-void ASTDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
+void ASTDumper::VisitClassTemplateDecl(ClassTemplateDecl const *D) {
   dumpTemplateDecl(D, false);
 }
 
-void ASTDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
+void ASTDumper::VisitVarTemplateDecl(VarTemplateDecl const *D) {
   dumpTemplateDecl(D, false);
 }
 
@@ -155,7 +155,7 @@
 // Type method implementations
 //===----------------------------------------------------------------------===//
 
-void QualType::dump(const char *msg) const {
+void QualType::dump(char const *msg) const {
   if (msg)
     llvm::errs() << msg << ": ";
   dump();
@@ -167,7 +167,7 @@
 }
 
 LLVM_DUMP_METHOD void QualType::dump(llvm::raw_ostream &OS,
-                                     const ASTContext &Context) const {
+                                     ASTContext const &Context) const {
   ASTDumper Dumper(OS, Context, Context.getDiagnostics().getShowColors());
   Dumper.Visit(*this);
 }
@@ -175,7 +175,7 @@
 LLVM_DUMP_METHOD void Type::dump() const { QualType(this, 0).dump(); }
 
 LLVM_DUMP_METHOD void Type::dump(llvm::raw_ostream &OS,
-                                 const ASTContext &Context) const {
+                                 ASTContext const &Context) const {
   QualType(this, 0).dump(OS, Context);
 }
 
@@ -188,7 +188,7 @@
 LLVM_DUMP_METHOD void Decl::dump(raw_ostream &OS, bool Deserialize,
                                  ASTDumpOutputFormat Format) const {
   ASTContext &Ctx = getASTContext();
-  const SourceManager &SM = Ctx.getSourceManager();
+  SourceManager const &SM = Ctx.getSourceManager();
 
   if (ADOF_JSON == Format) {
     JSONDumper P(OS, SM, Ctx, Ctx.getPrintingPolicy(),
@@ -203,7 +203,7 @@
 }
 
 LLVM_DUMP_METHOD void Decl::dumpColor() const {
-  const ASTContext &Ctx = getASTContext();
+  ASTContext const &Ctx = getASTContext();
   ASTDumper P(llvm::errs(), Ctx, /*ShowColors=*/true);
   P.Visit(this);
 }
@@ -212,13 +212,12 @@
   dumpLookups(llvm::errs());
 }
 
-LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS,
-                                               bool DumpDecls,
+LLVM_DUMP_METHOD void DeclContext::dumpLookups(raw_ostream &OS, bool DumpDecls,
                                                bool Deserialize) const {
-  const DeclContext *DC = this;
+  DeclContext const *DC = this;
   while (!DC->isTranslationUnit())
     DC = DC->getParent();
-  const ASTContext &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
+  ASTContext const &Ctx = cast<TranslationUnitDecl>(DC)->getASTContext();
   ASTDumper P(OS, Ctx, Ctx.getDiagnostics().getShowColors());
   P.setDeserialize(Deserialize);
   P.dumpLookups(this, DumpDecls);
@@ -234,7 +233,7 @@
 }
 
 LLVM_DUMP_METHOD void Stmt::dump(raw_ostream &OS,
-                                 const ASTContext &Context) const {
+                                 ASTContext const &Context) const {
   ASTDumper P(OS, Context, Context.getDiagnostics().getShowColors());
   P.Visit(this);
 }
@@ -249,7 +248,7 @@
 //===----------------------------------------------------------------------===//
 
 LLVM_DUMP_METHOD void Comment::dump() const {
-  const auto *FC = dyn_cast<FullComment>(this);
+  auto const *FC = dyn_cast<FullComment>(this);
   if (!FC)
     return;
   ASTDumper Dumper(llvm::errs(), /*ShowColors=*/false);
@@ -257,8 +256,8 @@
 }
 
 LLVM_DUMP_METHOD void Comment::dump(raw_ostream &OS,
-                                    const ASTContext &Context) const {
-  const auto *FC = dyn_cast<FullComment>(this);
+                                    ASTContext const &Context) const {
+  auto const *FC = dyn_cast<FullComment>(this);
   if (!FC)
     return;
   ASTDumper Dumper(OS, Context, Context.getDiagnostics().getShowColors());
@@ -266,7 +265,7 @@
 }
 
 LLVM_DUMP_METHOD void Comment::dumpColor() const {
-  const auto *FC = dyn_cast<FullComment>(this);
+  auto const *FC = dyn_cast<FullComment>(this);
   if (!FC)
     return;
   ASTDumper Dumper(llvm::errs(), /*ShowColors=*/true);
@@ -283,7 +282,7 @@
 }
 
 LLVM_DUMP_METHOD void APValue::dump(raw_ostream &OS,
-                                    const ASTContext &Context) const {
+                                    ASTContext const &Context) const {
   ASTDumper Dumper(llvm::errs(), Context,
                    Context.getDiagnostics().getShowColors());
   Dumper.Visit(*this, /*Ty=*/Context.getPointerType(Context.CharTy));
Index: clang/lib/AST/ASTImporter.cpp
===================================================================
--- clang/lib/AST/ASTImporter.cpp
+++ clang/lib/AST/ASTImporter.cpp
@@ -12,9 +12,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTImporter.h"
-#include "clang/AST/ASTImporterSharedState.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
+#include "clang/AST/ASTImporterSharedState.h"
 #include "clang/AST/ASTStructuralEquivalence.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
@@ -58,8 +58,8 @@
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -73,646 +73,636 @@
 
 namespace clang {
 
-  using llvm::make_error;
-  using llvm::Error;
-  using llvm::Expected;
-  using ExpectedType = llvm::Expected<QualType>;
-  using ExpectedStmt = llvm::Expected<Stmt *>;
-  using ExpectedExpr = llvm::Expected<Expr *>;
-  using ExpectedDecl = llvm::Expected<Decl *>;
-  using ExpectedSLoc = llvm::Expected<SourceLocation>;
-  using ExpectedName = llvm::Expected<DeclarationName>;
-
-  std::string ImportError::toString() const {
-    // FIXME: Improve error texts.
-    switch (Error) {
-    case NameConflict:
-      return "NameConflict";
-    case UnsupportedConstruct:
-      return "UnsupportedConstruct";
-    case Unknown:
-      return "Unknown error";
-    }
-    llvm_unreachable("Invalid error code.");
-    return "Invalid error code.";
-  }
+using llvm::Error;
+using llvm::Expected;
+using llvm::make_error;
+using ExpectedType = llvm::Expected<QualType>;
+using ExpectedStmt = llvm::Expected<Stmt *>;
+using ExpectedExpr = llvm::Expected<Expr *>;
+using ExpectedDecl = llvm::Expected<Decl *>;
+using ExpectedSLoc = llvm::Expected<SourceLocation>;
+using ExpectedName = llvm::Expected<DeclarationName>;
 
-  void ImportError::log(raw_ostream &OS) const {
-    OS << toString();
+std::string ImportError::toString() const {
+  // FIXME: Improve error texts.
+  switch (Error) {
+  case NameConflict:
+    return "NameConflict";
+  case UnsupportedConstruct:
+    return "UnsupportedConstruct";
+  case Unknown:
+    return "Unknown error";
   }
+  llvm_unreachable("Invalid error code.");
+  return "Invalid error code.";
+}
 
-  std::error_code ImportError::convertToErrorCode() const {
-    llvm_unreachable("Function not implemented.");
-  }
+void ImportError::log(raw_ostream &OS) const { OS << toString(); }
 
-  char ImportError::ID;
+std::error_code ImportError::convertToErrorCode() const {
+  llvm_unreachable("Function not implemented.");
+}
 
-  template <class T>
-  SmallVector<Decl *, 2>
-  getCanonicalForwardRedeclChain(Redeclarable<T>* D) {
-    SmallVector<Decl *, 2> Redecls;
-    for (auto *R : D->getFirstDecl()->redecls()) {
-      if (R != D->getFirstDecl())
-        Redecls.push_back(R);
-    }
-    Redecls.push_back(D->getFirstDecl());
-    std::reverse(Redecls.begin(), Redecls.end());
-    return Redecls;
-  }
+char ImportError::ID;
 
-  SmallVector<Decl*, 2> getCanonicalForwardRedeclChain(Decl* D) {
-    if (auto *FD = dyn_cast<FunctionDecl>(D))
-      return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
-    if (auto *VD = dyn_cast<VarDecl>(D))
-      return getCanonicalForwardRedeclChain<VarDecl>(VD);
-    if (auto *TD = dyn_cast<TagDecl>(D))
-      return getCanonicalForwardRedeclChain<TagDecl>(TD);
-    llvm_unreachable("Bad declaration kind");
+template <class T>
+SmallVector<Decl *, 2> getCanonicalForwardRedeclChain(Redeclarable<T> *D) {
+  SmallVector<Decl *, 2> Redecls;
+  for (auto *R : D->getFirstDecl()->redecls()) {
+    if (R != D->getFirstDecl())
+      Redecls.push_back(R);
+  }
+  Redecls.push_back(D->getFirstDecl());
+  std::reverse(Redecls.begin(), Redecls.end());
+  return Redecls;
+}
+
+SmallVector<Decl *, 2> getCanonicalForwardRedeclChain(Decl *D) {
+  if (auto *FD = dyn_cast<FunctionDecl>(D))
+    return getCanonicalForwardRedeclChain<FunctionDecl>(FD);
+  if (auto *VD = dyn_cast<VarDecl>(D))
+    return getCanonicalForwardRedeclChain<VarDecl>(VD);
+  if (auto *TD = dyn_cast<TagDecl>(D))
+    return getCanonicalForwardRedeclChain<TagDecl>(TD);
+  llvm_unreachable("Bad declaration kind");
+}
+
+void updateFlags(Decl const *From, Decl *To) {
+  // Check if some flags or attrs are new in 'From' and copy into 'To'.
+  // FIXME: Other flags or attrs?
+  if (From->isUsed(false) && !To->isUsed(false))
+    To->setIsUsed();
+}
+
+class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>,
+                        public DeclVisitor<ASTNodeImporter, ExpectedDecl>,
+                        public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
+  ASTImporter &Importer;
+
+  // Use this instead of Importer.importInto .
+  template <typename ImportT>
+  LLVM_NODISCARD Error importInto(ImportT &To, ImportT const &From) {
+    return Importer.importInto(To, From);
+  }
+
+  // Use this to import pointers of specific type.
+  template <typename ImportT>
+  LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
+    auto ToOrErr = Importer.Import(From);
+    if (ToOrErr)
+      To = cast_or_null<ImportT>(*ToOrErr);
+    return ToOrErr.takeError();
   }
 
-  void updateFlags(const Decl *From, Decl *To) {
-    // Check if some flags or attrs are new in 'From' and copy into 'To'.
-    // FIXME: Other flags or attrs?
-    if (From->isUsed(false) && !To->isUsed(false))
-      To->setIsUsed();
+  // Call the import function of ASTImporter for a baseclass of type `T` and
+  // cast the return value to `T`.
+  template <typename T> Expected<T *> import(T *From) {
+    auto ToOrErr = Importer.Import(From);
+    if (!ToOrErr)
+      return ToOrErr.takeError();
+    return cast_or_null<T>(*ToOrErr);
   }
 
-  class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>,
-                          public DeclVisitor<ASTNodeImporter, ExpectedDecl>,
-                          public StmtVisitor<ASTNodeImporter, ExpectedStmt> {
-    ASTImporter &Importer;
+  template <typename T> Expected<T *> import(const T *From) {
+    return import(const_cast<T *>(From));
+  }
 
-    // Use this instead of Importer.importInto .
-    template <typename ImportT>
-    LLVM_NODISCARD Error importInto(ImportT &To, const ImportT &From) {
-      return Importer.importInto(To, From);
-    }
+  // Call the import function of ASTImporter for type `T`.
+  template <typename T> Expected<T> import(const T &From) {
+    return Importer.Import(From);
+  }
 
-    // Use this to import pointers of specific type.
-    template <typename ImportT>
-    LLVM_NODISCARD Error importInto(ImportT *&To, ImportT *From) {
-      auto ToOrErr = Importer.Import(From);
-      if (ToOrErr)
-        To = cast_or_null<ImportT>(*ToOrErr);
-      return ToOrErr.takeError();
-    }
+  // Import an Optional<T> by importing the contained T, if any.
+  template <typename T> Expected<Optional<T>> import(Optional<T> From) {
+    if (!From)
+      return Optional<T>();
+    return import(*From);
+  }
 
-    // Call the import function of ASTImporter for a baseclass of type `T` and
-    // cast the return value to `T`.
-    template <typename T>
-    Expected<T *> import(T *From) {
-      auto ToOrErr = Importer.Import(From);
-      if (!ToOrErr)
-        return ToOrErr.takeError();
-      return cast_or_null<T>(*ToOrErr);
+  // Helper for chaining together multiple imports. If an error is detected,
+  // subsequent imports will return default constructed nodes, so that failure
+  // can be detected with a single conditional branch after a sequence of
+  // imports.
+  template <typename T> T importChecked(Error &Err, const T &From) {
+    // Don't attempt to import nodes if we hit an error earlier.
+    if (Err)
+      return T{};
+    Expected<T> MaybeVal = import(From);
+    if (!MaybeVal) {
+      Err = MaybeVal.takeError();
+      return T{};
     }
+    return *MaybeVal;
+  }
 
-    template <typename T>
-    Expected<T *> import(const T *From) {
-      return import(const_cast<T *>(From));
-    }
+  ExplicitSpecifier importExplicitSpecifier(Error &Err,
+                                            ExplicitSpecifier ESpec);
 
-    // Call the import function of ASTImporter for type `T`.
-    template <typename T>
-    Expected<T> import(const T &From) {
-      return Importer.Import(From);
+  // Wrapper for an overload set.
+  template <typename ToDeclT> struct CallOverloadedCreateFun {
+    template <typename... Args> decltype(auto) operator()(Args &&...args) {
+      return ToDeclT::Create(std::forward<Args>(args)...);
     }
+  };
 
-    // Import an Optional<T> by importing the contained T, if any.
-    template<typename T>
-    Expected<Optional<T>> import(Optional<T> From) {
-      if (!From)
-        return Optional<T>();
-      return import(*From);
+  // Always use these functions to create a Decl during import. There are
+  // certain tasks which must be done after the Decl was created, e.g. we
+  // must immediately register that as an imported Decl.  The parameter `ToD`
+  // will be set to the newly created Decl or if had been imported before
+  // then to the already imported Decl.  Returns a bool value set to true if
+  // the `FromD` had been imported before.
+  template <typename ToDeclT, typename FromDeclT, typename... Args>
+  LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
+                                              Args &&...args) {
+    // There may be several overloads of ToDeclT::Create. We must make sure
+    // to call the one which would be chosen by the arguments, thus we use a
+    // wrapper for the overload set.
+    CallOverloadedCreateFun<ToDeclT> OC;
+    return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
+                                          std::forward<Args>(args)...);
+  }
+  // Use this overload if a special Type is needed to be created.  E.g if we
+  // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
+  // then:
+  // TypedefNameDecl *ToTypedef;
+  // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
+  template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
+            typename... Args>
+  LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
+                                              Args &&...args) {
+    CallOverloadedCreateFun<NewDeclT> OC;
+    return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
+                                          std::forward<Args>(args)...);
+  }
+  // Use this version if a special create function must be
+  // used, e.g. CXXRecordDecl::CreateLambda .
+  template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
+            typename... Args>
+  LLVM_NODISCARD bool
+  GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
+                                 FromDeclT *FromD, Args &&...args) {
+    if (Importer.getImportDeclErrorIfAny(FromD)) {
+      ToD = nullptr;
+      return true; // Already imported but with error.
     }
+    ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
+    if (ToD)
+      return true; // Already imported.
+    ToD = CreateFun(std::forward<Args>(args)...);
+    // Keep track of imported Decls.
+    Importer.RegisterImportedDecl(FromD, ToD);
+    InitializeImportedDecl(FromD, ToD);
+    return false; // A new Decl is created.
+  }
+
+  void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
+    ToD->IdentifierNamespace = FromD->IdentifierNamespace;
+    if (FromD->isUsed())
+      ToD->setIsUsed();
+    if (FromD->isImplicit())
+      ToD->setImplicit();
+  }
+
+  // Check if we have found an existing definition.  Returns with that
+  // definition if yes, otherwise returns null.
+  Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) {
+    FunctionDecl const *Definition = nullptr;
+    if (D->doesThisDeclarationHaveABody() && FoundFunction->hasBody(Definition))
+      return Importer.MapImported(D, const_cast<FunctionDecl *>(Definition));
+    return nullptr;
+  }
 
-    // Helper for chaining together multiple imports. If an error is detected,
-    // subsequent imports will return default constructed nodes, so that failure
-    // can be detected with a single conditional branch after a sequence of
-    // imports.
-    template <typename T> T importChecked(Error &Err, const T &From) {
-      // Don't attempt to import nodes if we hit an error earlier.
-      if (Err)
-        return T{};
-      Expected<T> MaybeVal = import(From);
-      if (!MaybeVal) {
-        Err = MaybeVal.takeError();
-        return T{};
-      }
-      return *MaybeVal;
+  void addDeclToContexts(Decl *FromD, Decl *ToD) {
+    if (Importer.isMinimalImport()) {
+      // In minimal import case the decl must be added even if it is not
+      // contained in original context, for LLDB compatibility.
+      // FIXME: Check if a better solution is possible.
+      if (!FromD->getDescribedTemplate() &&
+          FromD->getFriendObjectKind() == Decl::FOK_None)
+        ToD->getLexicalDeclContext()->addDeclInternal(ToD);
+      return;
     }
 
-    ExplicitSpecifier importExplicitSpecifier(Error &Err,
-                                              ExplicitSpecifier ESpec);
+    DeclContext *FromDC = FromD->getDeclContext();
+    DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
+    DeclContext *ToDC = ToD->getDeclContext();
+    DeclContext *ToLexicalDC = ToD->getLexicalDeclContext();
 
-    // Wrapper for an overload set.
-    template <typename ToDeclT> struct CallOverloadedCreateFun {
-      template <typename... Args> decltype(auto) operator()(Args &&... args) {
-        return ToDeclT::Create(std::forward<Args>(args)...);
-      }
-    };
-
-    // Always use these functions to create a Decl during import. There are
-    // certain tasks which must be done after the Decl was created, e.g. we
-    // must immediately register that as an imported Decl.  The parameter `ToD`
-    // will be set to the newly created Decl or if had been imported before
-    // then to the already imported Decl.  Returns a bool value set to true if
-    // the `FromD` had been imported before.
-    template <typename ToDeclT, typename FromDeclT, typename... Args>
-    LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
-                                                Args &&... args) {
-      // There may be several overloads of ToDeclT::Create. We must make sure
-      // to call the one which would be chosen by the arguments, thus we use a
-      // wrapper for the overload set.
-      CallOverloadedCreateFun<ToDeclT> OC;
-      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
-                                            std::forward<Args>(args)...);
-    }
-    // Use this overload if a special Type is needed to be created.  E.g if we
-    // want to create a `TypeAliasDecl` and assign that to a `TypedefNameDecl`
-    // then:
-    // TypedefNameDecl *ToTypedef;
-    // GetImportedOrCreateDecl<TypeAliasDecl>(ToTypedef, FromD, ...);
-    template <typename NewDeclT, typename ToDeclT, typename FromDeclT,
-              typename... Args>
-    LLVM_NODISCARD bool GetImportedOrCreateDecl(ToDeclT *&ToD, FromDeclT *FromD,
-                                                Args &&... args) {
-      CallOverloadedCreateFun<NewDeclT> OC;
-      return GetImportedOrCreateSpecialDecl(ToD, OC, FromD,
-                                            std::forward<Args>(args)...);
+    bool Visible = false;
+    if (FromDC->containsDeclAndLoad(FromD)) {
+      ToDC->addDeclInternal(ToD);
+      Visible = true;
     }
-    // Use this version if a special create function must be
-    // used, e.g. CXXRecordDecl::CreateLambda .
-    template <typename ToDeclT, typename CreateFunT, typename FromDeclT,
-              typename... Args>
-    LLVM_NODISCARD bool
-    GetImportedOrCreateSpecialDecl(ToDeclT *&ToD, CreateFunT CreateFun,
-                                   FromDeclT *FromD, Args &&... args) {
-      if (Importer.getImportDeclErrorIfAny(FromD)) {
-        ToD = nullptr;
-        return true; // Already imported but with error.
-      }
-      ToD = cast_or_null<ToDeclT>(Importer.GetAlreadyImportedOrNull(FromD));
-      if (ToD)
-        return true; // Already imported.
-      ToD = CreateFun(std::forward<Args>(args)...);
-      // Keep track of imported Decls.
-      Importer.RegisterImportedDecl(FromD, ToD);
-      InitializeImportedDecl(FromD, ToD);
-      return false; // A new Decl is created.
-    }
-
-    void InitializeImportedDecl(Decl *FromD, Decl *ToD) {
-      ToD->IdentifierNamespace = FromD->IdentifierNamespace;
-      if (FromD->isUsed())
-        ToD->setIsUsed();
-      if (FromD->isImplicit())
-        ToD->setImplicit();
+    if (ToDC != ToLexicalDC && FromLexicalDC->containsDeclAndLoad(FromD)) {
+      ToLexicalDC->addDeclInternal(ToD);
+      Visible = true;
     }
 
-    // Check if we have found an existing definition.  Returns with that
-    // definition if yes, otherwise returns null.
-    Decl *FindAndMapDefinition(FunctionDecl *D, FunctionDecl *FoundFunction) {
-      const FunctionDecl *Definition = nullptr;
-      if (D->doesThisDeclarationHaveABody() &&
-          FoundFunction->hasBody(Definition))
-        return Importer.MapImported(D, const_cast<FunctionDecl *>(Definition));
-      return nullptr;
-    }
-
-    void addDeclToContexts(Decl *FromD, Decl *ToD) {
-      if (Importer.isMinimalImport()) {
-        // In minimal import case the decl must be added even if it is not
-        // contained in original context, for LLDB compatibility.
-        // FIXME: Check if a better solution is possible.
-        if (!FromD->getDescribedTemplate() &&
-            FromD->getFriendObjectKind() == Decl::FOK_None)
-          ToD->getLexicalDeclContext()->addDeclInternal(ToD);
-        return;
-      }
-
-      DeclContext *FromDC = FromD->getDeclContext();
-      DeclContext *FromLexicalDC = FromD->getLexicalDeclContext();
-      DeclContext *ToDC = ToD->getDeclContext();
-      DeclContext *ToLexicalDC = ToD->getLexicalDeclContext();
-
-      bool Visible = false;
-      if (FromDC->containsDeclAndLoad(FromD)) {
-        ToDC->addDeclInternal(ToD);
-        Visible = true;
-      }
-      if (ToDC != ToLexicalDC && FromLexicalDC->containsDeclAndLoad(FromD)) {
-        ToLexicalDC->addDeclInternal(ToD);
-        Visible = true;
-      }
-
-      // If the Decl was added to any context, it was made already visible.
-      // Otherwise it is still possible that it should be visible.
-      if (!Visible) {
-        if (auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
-          auto *ToNamed = cast<NamedDecl>(ToD);
-          DeclContextLookupResult FromLookup =
-              FromDC->lookup(FromNamed->getDeclName());
-          for (NamedDecl *ND : FromLookup)
-            if (ND == FromNamed) {
-              ToDC->makeDeclVisibleInContext(ToNamed);
-              break;
-            }
-        }
+    // If the Decl was added to any context, it was made already visible.
+    // Otherwise it is still possible that it should be visible.
+    if (!Visible) {
+      if (auto *FromNamed = dyn_cast<NamedDecl>(FromD)) {
+        auto *ToNamed = cast<NamedDecl>(ToD);
+        DeclContextLookupResult FromLookup =
+            FromDC->lookup(FromNamed->getDeclName());
+        for (NamedDecl *ND : FromLookup)
+          if (ND == FromNamed) {
+            ToDC->makeDeclVisibleInContext(ToNamed);
+            break;
+          }
       }
     }
+  }
 
-    void updateLookupTableForTemplateParameters(TemplateParameterList &Params,
-                                                DeclContext *OldDC) {
-      ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable();
-      if (!LT)
-        return;
-
-      for (NamedDecl *TP : Params)
-        LT->update(TP, OldDC);
-    }
-
-    void updateLookupTableForTemplateParameters(TemplateParameterList &Params) {
-      updateLookupTableForTemplateParameters(
-          Params, Importer.getToContext().getTranslationUnitDecl());
-    }
-
-  public:
-    explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
-
-    using TypeVisitor<ASTNodeImporter, ExpectedType>::Visit;
-    using DeclVisitor<ASTNodeImporter, ExpectedDecl>::Visit;
-    using StmtVisitor<ASTNodeImporter, ExpectedStmt>::Visit;
-
-    // Importing types
-    ExpectedType VisitType(const Type *T);
-    ExpectedType VisitAtomicType(const AtomicType *T);
-    ExpectedType VisitBuiltinType(const BuiltinType *T);
-    ExpectedType VisitDecayedType(const DecayedType *T);
-    ExpectedType VisitComplexType(const ComplexType *T);
-    ExpectedType VisitPointerType(const PointerType *T);
-    ExpectedType VisitBlockPointerType(const BlockPointerType *T);
-    ExpectedType VisitLValueReferenceType(const LValueReferenceType *T);
-    ExpectedType VisitRValueReferenceType(const RValueReferenceType *T);
-    ExpectedType VisitMemberPointerType(const MemberPointerType *T);
-    ExpectedType VisitConstantArrayType(const ConstantArrayType *T);
-    ExpectedType VisitIncompleteArrayType(const IncompleteArrayType *T);
-    ExpectedType VisitVariableArrayType(const VariableArrayType *T);
-    ExpectedType VisitDependentSizedArrayType(const DependentSizedArrayType *T);
-    // FIXME: DependentSizedExtVectorType
-    ExpectedType VisitVectorType(const VectorType *T);
-    ExpectedType VisitExtVectorType(const ExtVectorType *T);
-    ExpectedType VisitFunctionNoProtoType(const FunctionNoProtoType *T);
-    ExpectedType VisitFunctionProtoType(const FunctionProtoType *T);
-    ExpectedType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
-    ExpectedType VisitParenType(const ParenType *T);
-    ExpectedType VisitTypedefType(const TypedefType *T);
-    ExpectedType VisitTypeOfExprType(const TypeOfExprType *T);
-    // FIXME: DependentTypeOfExprType
-    ExpectedType VisitTypeOfType(const TypeOfType *T);
-    ExpectedType VisitDecltypeType(const DecltypeType *T);
-    ExpectedType VisitUnaryTransformType(const UnaryTransformType *T);
-    ExpectedType VisitAutoType(const AutoType *T);
-    ExpectedType VisitDeducedTemplateSpecializationType(
-        const DeducedTemplateSpecializationType *T);
-    ExpectedType VisitInjectedClassNameType(const InjectedClassNameType *T);
-    // FIXME: DependentDecltypeType
-    ExpectedType VisitRecordType(const RecordType *T);
-    ExpectedType VisitEnumType(const EnumType *T);
-    ExpectedType VisitAttributedType(const AttributedType *T);
-    ExpectedType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
-    ExpectedType VisitSubstTemplateTypeParmType(
-        const SubstTemplateTypeParmType *T);
-    ExpectedType
-    VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T);
-    ExpectedType VisitTemplateSpecializationType(
-        const TemplateSpecializationType *T);
-    ExpectedType VisitElaboratedType(const ElaboratedType *T);
-    ExpectedType VisitDependentNameType(const DependentNameType *T);
-    ExpectedType VisitPackExpansionType(const PackExpansionType *T);
-    ExpectedType VisitDependentTemplateSpecializationType(
-        const DependentTemplateSpecializationType *T);
-    ExpectedType VisitObjCInterfaceType(const ObjCInterfaceType *T);
-    ExpectedType VisitObjCObjectType(const ObjCObjectType *T);
-    ExpectedType VisitObjCObjectPointerType(const ObjCObjectPointerType *T);
-
-    // Importing declarations
-    Error ImportDeclParts(NamedDecl *D, DeclarationName &Name, NamedDecl *&ToD,
-                          SourceLocation &Loc);
-    Error ImportDeclParts(
-        NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
-        DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc);
-    Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
-    Error ImportDeclarationNameLoc(
-        const DeclarationNameInfo &From, DeclarationNameInfo &To);
-    Error ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
-    Error ImportDeclContext(
-        Decl *From, DeclContext *&ToDC, DeclContext *&ToLexicalDC);
-    Error ImportImplicitMethods(const CXXRecordDecl *From, CXXRecordDecl *To);
-
-    Expected<CXXCastPath> ImportCastPath(CastExpr *E);
-    Expected<APValue> ImportAPValue(const APValue &FromValue);
-
-    using Designator = DesignatedInitExpr::Designator;
-
-    /// What we should import from the definition.
-    enum ImportDefinitionKind {
-      /// Import the default subset of the definition, which might be
-      /// nothing (if minimal import is set) or might be everything (if minimal
-      /// import is not set).
-      IDK_Default,
-      /// Import everything.
-      IDK_Everything,
-      /// Import only the bare bones needed to establish a valid
-      /// DeclContext.
-      IDK_Basic
-    };
-
-    bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
-      return IDK == IDK_Everything ||
-             (IDK == IDK_Default && !Importer.isMinimalImport());
-    }
+  void updateLookupTableForTemplateParameters(TemplateParameterList &Params,
+                                              DeclContext *OldDC) {
+    ASTImporterLookupTable *LT = Importer.SharedState->getLookupTable();
+    if (!LT)
+      return;
+
+    for (NamedDecl *TP : Params)
+      LT->update(TP, OldDC);
+  }
+
+  void updateLookupTableForTemplateParameters(TemplateParameterList &Params) {
+    updateLookupTableForTemplateParameters(
+        Params, Importer.getToContext().getTranslationUnitDecl());
+  }
+
+public:
+  explicit ASTNodeImporter(ASTImporter &Importer) : Importer(Importer) {}
+
+  using TypeVisitor<ASTNodeImporter, ExpectedType>::Visit;
+  using DeclVisitor<ASTNodeImporter, ExpectedDecl>::Visit;
+  using StmtVisitor<ASTNodeImporter, ExpectedStmt>::Visit;
+
+  // Importing types
+  ExpectedType VisitType(Type const *T);
+  ExpectedType VisitAtomicType(AtomicType const *T);
+  ExpectedType VisitBuiltinType(BuiltinType const *T);
+  ExpectedType VisitDecayedType(DecayedType const *T);
+  ExpectedType VisitComplexType(ComplexType const *T);
+  ExpectedType VisitPointerType(PointerType const *T);
+  ExpectedType VisitBlockPointerType(BlockPointerType const *T);
+  ExpectedType VisitLValueReferenceType(LValueReferenceType const *T);
+  ExpectedType VisitRValueReferenceType(RValueReferenceType const *T);
+  ExpectedType VisitMemberPointerType(MemberPointerType const *T);
+  ExpectedType VisitConstantArrayType(ConstantArrayType const *T);
+  ExpectedType VisitIncompleteArrayType(IncompleteArrayType const *T);
+  ExpectedType VisitVariableArrayType(VariableArrayType const *T);
+  ExpectedType VisitDependentSizedArrayType(DependentSizedArrayType const *T);
+  // FIXME: DependentSizedExtVectorType
+  ExpectedType VisitVectorType(VectorType const *T);
+  ExpectedType VisitExtVectorType(ExtVectorType const *T);
+  ExpectedType VisitFunctionNoProtoType(FunctionNoProtoType const *T);
+  ExpectedType VisitFunctionProtoType(FunctionProtoType const *T);
+  ExpectedType VisitUnresolvedUsingType(UnresolvedUsingType const *T);
+  ExpectedType VisitParenType(ParenType const *T);
+  ExpectedType VisitTypedefType(TypedefType const *T);
+  ExpectedType VisitTypeOfExprType(TypeOfExprType const *T);
+  // FIXME: DependentTypeOfExprType
+  ExpectedType VisitTypeOfType(TypeOfType const *T);
+  ExpectedType VisitDecltypeType(DecltypeType const *T);
+  ExpectedType VisitUnaryTransformType(UnaryTransformType const *T);
+  ExpectedType VisitAutoType(AutoType const *T);
+  ExpectedType VisitDeducedTemplateSpecializationType(
+      DeducedTemplateSpecializationType const *T);
+  ExpectedType VisitInjectedClassNameType(InjectedClassNameType const *T);
+  // FIXME: DependentDecltypeType
+  ExpectedType VisitRecordType(RecordType const *T);
+  ExpectedType VisitEnumType(EnumType const *T);
+  ExpectedType VisitAttributedType(AttributedType const *T);
+  ExpectedType VisitTemplateTypeParmType(TemplateTypeParmType const *T);
+  ExpectedType
+  VisitSubstTemplateTypeParmType(SubstTemplateTypeParmType const *T);
+  ExpectedType
+  VisitSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType const *T);
+  ExpectedType
+  VisitTemplateSpecializationType(TemplateSpecializationType const *T);
+  ExpectedType VisitElaboratedType(ElaboratedType const *T);
+  ExpectedType VisitDependentNameType(DependentNameType const *T);
+  ExpectedType VisitPackExpansionType(PackExpansionType const *T);
+  ExpectedType VisitDependentTemplateSpecializationType(
+      DependentTemplateSpecializationType const *T);
+  ExpectedType VisitObjCInterfaceType(ObjCInterfaceType const *T);
+  ExpectedType VisitObjCObjectType(ObjCObjectType const *T);
+  ExpectedType VisitObjCObjectPointerType(ObjCObjectPointerType const *T);
+
+  // Importing declarations
+  Error ImportDeclParts(NamedDecl *D, DeclarationName &Name, NamedDecl *&ToD,
+                        SourceLocation &Loc);
+  Error ImportDeclParts(NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
+                        DeclarationName &Name, NamedDecl *&ToD,
+                        SourceLocation &Loc);
+  Error ImportDefinitionIfNeeded(Decl *FromD, Decl *ToD = nullptr);
+  Error ImportDeclarationNameLoc(DeclarationNameInfo const &From,
+                                 DeclarationNameInfo &To);
+  Error ImportDeclContext(DeclContext *FromDC, bool ForceImport = false);
+  Error ImportDeclContext(Decl *From, DeclContext *&ToDC,
+                          DeclContext *&ToLexicalDC);
+  Error ImportImplicitMethods(CXXRecordDecl const *From, CXXRecordDecl *To);
+
+  Expected<CXXCastPath> ImportCastPath(CastExpr *E);
+  Expected<APValue> ImportAPValue(APValue const &FromValue);
+
+  using Designator = DesignatedInitExpr::Designator;
+
+  /// What we should import from the definition.
+  enum ImportDefinitionKind {
+    /// Import the default subset of the definition, which might be
+    /// nothing (if minimal import is set) or might be everything (if minimal
+    /// import is not set).
+    IDK_Default,
+    /// Import everything.
+    IDK_Everything,
+    /// Import only the bare bones needed to establish a valid
+    /// DeclContext.
+    IDK_Basic
+  };
 
-    Error ImportInitializer(VarDecl *From, VarDecl *To);
-    Error ImportDefinition(
-        RecordDecl *From, RecordDecl *To,
-        ImportDefinitionKind Kind = IDK_Default);
-    Error ImportDefinition(
-        EnumDecl *From, EnumDecl *To,
-        ImportDefinitionKind Kind = IDK_Default);
-    Error ImportDefinition(
-        ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
-        ImportDefinitionKind Kind = IDK_Default);
-    Error ImportDefinition(
-        ObjCProtocolDecl *From, ObjCProtocolDecl *To,
-        ImportDefinitionKind Kind = IDK_Default);
-    Error ImportTemplateArguments(
-        const TemplateArgument *FromArgs, unsigned NumFromArgs,
-        SmallVectorImpl<TemplateArgument> &ToArgs);
-    Expected<TemplateArgument>
-    ImportTemplateArgument(const TemplateArgument &From);
-
-    template <typename InContainerTy>
-    Error ImportTemplateArgumentListInfo(
-        const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo);
-
-    template<typename InContainerTy>
-    Error ImportTemplateArgumentListInfo(
-      SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
-      const InContainerTy &Container, TemplateArgumentListInfo &Result);
-
-    using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
-    using FunctionTemplateAndArgsTy =
-        std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
-    Expected<FunctionTemplateAndArgsTy>
-    ImportFunctionTemplateWithTemplateArgsFromSpecialization(
-        FunctionDecl *FromFD);
-    Error ImportTemplateParameterLists(const DeclaratorDecl *FromD,
-                                       DeclaratorDecl *ToD);
-
-    Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);
-
-    Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD);
-
-    Error ImportDefaultArgOfParmVarDecl(const ParmVarDecl *FromParam,
-                                        ParmVarDecl *ToParam);
-
-    template <typename T>
-    bool hasSameVisibilityContextAndLinkage(T *Found, T *From);
-
-    bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
-    bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
-                           bool Complain = true);
-    bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
-                           bool Complain = true);
-    bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
-    bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
-    bool IsStructuralMatch(FunctionTemplateDecl *From,
-                           FunctionTemplateDecl *To);
-    bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
-    bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
-    bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
-    ExpectedDecl VisitDecl(Decl *D);
-    ExpectedDecl VisitImportDecl(ImportDecl *D);
-    ExpectedDecl VisitEmptyDecl(EmptyDecl *D);
-    ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
-    ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
-    ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
-    ExpectedDecl VisitBindingDecl(BindingDecl *D);
-    ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);
-    ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
-    ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
-    ExpectedDecl VisitTypedefDecl(TypedefDecl *D);
-    ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D);
-    ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
-    ExpectedDecl VisitLabelDecl(LabelDecl *D);
-    ExpectedDecl VisitEnumDecl(EnumDecl *D);
-    ExpectedDecl VisitRecordDecl(RecordDecl *D);
-    ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D);
-    ExpectedDecl VisitFunctionDecl(FunctionDecl *D);
-    ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D);
-    ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D);
-    ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D);
-    ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D);
-    ExpectedDecl VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
-    ExpectedDecl VisitFieldDecl(FieldDecl *D);
-    ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D);
-    ExpectedDecl VisitFriendDecl(FriendDecl *D);
-    ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D);
-    ExpectedDecl VisitVarDecl(VarDecl *D);
-    ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D);
-    ExpectedDecl VisitParmVarDecl(ParmVarDecl *D);
-    ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D);
-    ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
-    ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D);
-    ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D);
-    ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D);
-    ExpectedDecl VisitUsingDecl(UsingDecl *D);
-    ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D);
-    ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
-    ExpectedDecl ImportUsingShadowDecls(BaseUsingDecl *D, BaseUsingDecl *ToSI);
-    ExpectedDecl VisitUsingEnumDecl(UsingEnumDecl *D);
-    ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
-    ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
-    ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
-    ExpectedDecl
-    VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
-
-    Expected<ObjCTypeParamList *>
-    ImportObjCTypeParamList(ObjCTypeParamList *list);
-
-    ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
-    ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
-    ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D);
-    ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D);
-    ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
-    ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
-    ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
-    ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
-    ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D);
-    ExpectedDecl VisitClassTemplateSpecializationDecl(
-                                            ClassTemplateSpecializationDecl *D);
-    ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D);
-    ExpectedDecl VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
-    ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
-
-    // Importing statements
-    ExpectedStmt VisitStmt(Stmt *S);
-    ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S);
-    ExpectedStmt VisitDeclStmt(DeclStmt *S);
-    ExpectedStmt VisitNullStmt(NullStmt *S);
-    ExpectedStmt VisitCompoundStmt(CompoundStmt *S);
-    ExpectedStmt VisitCaseStmt(CaseStmt *S);
-    ExpectedStmt VisitDefaultStmt(DefaultStmt *S);
-    ExpectedStmt VisitLabelStmt(LabelStmt *S);
-    ExpectedStmt VisitAttributedStmt(AttributedStmt *S);
-    ExpectedStmt VisitIfStmt(IfStmt *S);
-    ExpectedStmt VisitSwitchStmt(SwitchStmt *S);
-    ExpectedStmt VisitWhileStmt(WhileStmt *S);
-    ExpectedStmt VisitDoStmt(DoStmt *S);
-    ExpectedStmt VisitForStmt(ForStmt *S);
-    ExpectedStmt VisitGotoStmt(GotoStmt *S);
-    ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S);
-    ExpectedStmt VisitContinueStmt(ContinueStmt *S);
-    ExpectedStmt VisitBreakStmt(BreakStmt *S);
-    ExpectedStmt VisitReturnStmt(ReturnStmt *S);
-    // FIXME: MSAsmStmt
-    // FIXME: SEHExceptStmt
-    // FIXME: SEHFinallyStmt
-    // FIXME: SEHTryStmt
-    // FIXME: SEHLeaveStmt
-    // FIXME: CapturedStmt
-    ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S);
-    ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S);
-    ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S);
-    // FIXME: MSDependentExistsStmt
-    ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
-    ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
-    ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
-    ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S);
-    ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
-    ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
-    ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
-
-    // Importing expressions
-    ExpectedStmt VisitExpr(Expr *E);
-    ExpectedStmt VisitSourceLocExpr(SourceLocExpr *E);
-    ExpectedStmt VisitVAArgExpr(VAArgExpr *E);
-    ExpectedStmt VisitChooseExpr(ChooseExpr *E);
-    ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E);
-    ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E);
-    ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E);
-    ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E);
-    ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
-    ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E);
-    ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
-    ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E);
-    ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E);
-    ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E);
-    ExpectedStmt VisitFixedPointLiteral(FixedPointLiteral *E);
-    ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E);
-    ExpectedStmt VisitStringLiteral(StringLiteral *E);
-    ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
-    ExpectedStmt VisitAtomicExpr(AtomicExpr *E);
-    ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E);
-    ExpectedStmt VisitConstantExpr(ConstantExpr *E);
-    ExpectedStmt VisitParenExpr(ParenExpr *E);
-    ExpectedStmt VisitParenListExpr(ParenListExpr *E);
-    ExpectedStmt VisitStmtExpr(StmtExpr *E);
-    ExpectedStmt VisitUnaryOperator(UnaryOperator *E);
-    ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
-    ExpectedStmt VisitBinaryOperator(BinaryOperator *E);
-    ExpectedStmt VisitConditionalOperator(ConditionalOperator *E);
-    ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
-    ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E);
-    ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
-    ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E);
-    ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E);
-    ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E);
-    ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E);
-    ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E);
-    ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE);
-    ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E);
-    ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
-    ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
-    ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
-    ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
-    ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
-    ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
-    ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E);
-    ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E);
-    ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E);
-    ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E);
-    ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E);
-    ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
-    ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
-    ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
-    ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
-    ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
-    ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
-    ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E);
-    ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E);
-    ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
-    ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
-    ExpectedStmt VisitMemberExpr(MemberExpr *E);
-    ExpectedStmt VisitCallExpr(CallExpr *E);
-    ExpectedStmt VisitLambdaExpr(LambdaExpr *LE);
-    ExpectedStmt VisitInitListExpr(InitListExpr *E);
-    ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
-    ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
-    ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
-    ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
-    ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
-    ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
-    ExpectedStmt VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
-    ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E);
-    ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E);
-    ExpectedStmt VisitCXXFoldExpr(CXXFoldExpr *E);
-
-    template<typename IIter, typename OIter>
-    Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
-      using ItemT = std::remove_reference_t<decltype(*Obegin)>;
-      for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
-        Expected<ItemT> ToOrErr = import(*Ibegin);
-        if (!ToOrErr)
-          return ToOrErr.takeError();
-        *Obegin = *ToOrErr;
-      }
-      return Error::success();
+  bool shouldForceImportDeclContext(ImportDefinitionKind IDK) {
+    return IDK == IDK_Everything ||
+           (IDK == IDK_Default && !Importer.isMinimalImport());
+  }
+
+  Error ImportInitializer(VarDecl *From, VarDecl *To);
+  Error ImportDefinition(RecordDecl *From, RecordDecl *To,
+                         ImportDefinitionKind Kind = IDK_Default);
+  Error ImportDefinition(EnumDecl *From, EnumDecl *To,
+                         ImportDefinitionKind Kind = IDK_Default);
+  Error ImportDefinition(ObjCInterfaceDecl *From, ObjCInterfaceDecl *To,
+                         ImportDefinitionKind Kind = IDK_Default);
+  Error ImportDefinition(ObjCProtocolDecl *From, ObjCProtocolDecl *To,
+                         ImportDefinitionKind Kind = IDK_Default);
+  Error ImportTemplateArguments(TemplateArgument const *FromArgs,
+                                unsigned NumFromArgs,
+                                SmallVectorImpl<TemplateArgument> &ToArgs);
+  Expected<TemplateArgument>
+  ImportTemplateArgument(TemplateArgument const &From);
+
+  template <typename InContainerTy>
+  Error ImportTemplateArgumentListInfo(InContainerTy const &Container,
+                                       TemplateArgumentListInfo &ToTAInfo);
+
+  template <typename InContainerTy>
+  Error ImportTemplateArgumentListInfo(SourceLocation FromLAngleLoc,
+                                       SourceLocation FromRAngleLoc,
+                                       InContainerTy const &Container,
+                                       TemplateArgumentListInfo &Result);
+
+  using TemplateArgsTy = SmallVector<TemplateArgument, 8>;
+  using FunctionTemplateAndArgsTy =
+      std::tuple<FunctionTemplateDecl *, TemplateArgsTy>;
+  Expected<FunctionTemplateAndArgsTy>
+  ImportFunctionTemplateWithTemplateArgsFromSpecialization(
+      FunctionDecl *FromFD);
+  Error ImportTemplateParameterLists(DeclaratorDecl const *FromD,
+                                     DeclaratorDecl *ToD);
+
+  Error ImportTemplateInformation(FunctionDecl *FromFD, FunctionDecl *ToFD);
+
+  Error ImportFunctionDeclBody(FunctionDecl *FromFD, FunctionDecl *ToFD);
+
+  Error ImportDefaultArgOfParmVarDecl(ParmVarDecl const *FromParam,
+                                      ParmVarDecl *ToParam);
+
+  template <typename T>
+  bool hasSameVisibilityContextAndLinkage(T *Found, T *From);
+
+  bool IsStructuralMatch(Decl *From, Decl *To, bool Complain);
+  bool IsStructuralMatch(RecordDecl *FromRecord, RecordDecl *ToRecord,
+                         bool Complain = true);
+  bool IsStructuralMatch(VarDecl *FromVar, VarDecl *ToVar,
+                         bool Complain = true);
+  bool IsStructuralMatch(EnumDecl *FromEnum, EnumDecl *ToRecord);
+  bool IsStructuralMatch(EnumConstantDecl *FromEC, EnumConstantDecl *ToEC);
+  bool IsStructuralMatch(FunctionTemplateDecl *From, FunctionTemplateDecl *To);
+  bool IsStructuralMatch(FunctionDecl *From, FunctionDecl *To);
+  bool IsStructuralMatch(ClassTemplateDecl *From, ClassTemplateDecl *To);
+  bool IsStructuralMatch(VarTemplateDecl *From, VarTemplateDecl *To);
+  ExpectedDecl VisitDecl(Decl *D);
+  ExpectedDecl VisitImportDecl(ImportDecl *D);
+  ExpectedDecl VisitEmptyDecl(EmptyDecl *D);
+  ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
+  ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
+  ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
+  ExpectedDecl VisitBindingDecl(BindingDecl *D);
+  ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);
+  ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
+  ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
+  ExpectedDecl VisitTypedefDecl(TypedefDecl *D);
+  ExpectedDecl VisitTypeAliasDecl(TypeAliasDecl *D);
+  ExpectedDecl VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
+  ExpectedDecl VisitLabelDecl(LabelDecl *D);
+  ExpectedDecl VisitEnumDecl(EnumDecl *D);
+  ExpectedDecl VisitRecordDecl(RecordDecl *D);
+  ExpectedDecl VisitEnumConstantDecl(EnumConstantDecl *D);
+  ExpectedDecl VisitFunctionDecl(FunctionDecl *D);
+  ExpectedDecl VisitCXXMethodDecl(CXXMethodDecl *D);
+  ExpectedDecl VisitCXXConstructorDecl(CXXConstructorDecl *D);
+  ExpectedDecl VisitCXXDestructorDecl(CXXDestructorDecl *D);
+  ExpectedDecl VisitCXXConversionDecl(CXXConversionDecl *D);
+  ExpectedDecl VisitCXXDeductionGuideDecl(CXXDeductionGuideDecl *D);
+  ExpectedDecl VisitFieldDecl(FieldDecl *D);
+  ExpectedDecl VisitIndirectFieldDecl(IndirectFieldDecl *D);
+  ExpectedDecl VisitFriendDecl(FriendDecl *D);
+  ExpectedDecl VisitObjCIvarDecl(ObjCIvarDecl *D);
+  ExpectedDecl VisitVarDecl(VarDecl *D);
+  ExpectedDecl VisitImplicitParamDecl(ImplicitParamDecl *D);
+  ExpectedDecl VisitParmVarDecl(ParmVarDecl *D);
+  ExpectedDecl VisitObjCMethodDecl(ObjCMethodDecl *D);
+  ExpectedDecl VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
+  ExpectedDecl VisitObjCCategoryDecl(ObjCCategoryDecl *D);
+  ExpectedDecl VisitObjCProtocolDecl(ObjCProtocolDecl *D);
+  ExpectedDecl VisitLinkageSpecDecl(LinkageSpecDecl *D);
+  ExpectedDecl VisitUsingDecl(UsingDecl *D);
+  ExpectedDecl VisitUsingShadowDecl(UsingShadowDecl *D);
+  ExpectedDecl VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
+  ExpectedDecl ImportUsingShadowDecls(BaseUsingDecl *D, BaseUsingDecl *ToSI);
+  ExpectedDecl VisitUsingEnumDecl(UsingEnumDecl *D);
+  ExpectedDecl VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
+  ExpectedDecl VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
+  ExpectedDecl VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
+  ExpectedDecl
+  VisitLifetimeExtendedTemporaryDecl(LifetimeExtendedTemporaryDecl *D);
+
+  Expected<ObjCTypeParamList *>
+  ImportObjCTypeParamList(ObjCTypeParamList *list);
+
+  ExpectedDecl VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
+  ExpectedDecl VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
+  ExpectedDecl VisitObjCImplementationDecl(ObjCImplementationDecl *D);
+  ExpectedDecl VisitObjCPropertyDecl(ObjCPropertyDecl *D);
+  ExpectedDecl VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
+  ExpectedDecl VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
+  ExpectedDecl VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
+  ExpectedDecl VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
+  ExpectedDecl VisitClassTemplateDecl(ClassTemplateDecl *D);
+  ExpectedDecl
+  VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D);
+  ExpectedDecl VisitVarTemplateDecl(VarTemplateDecl *D);
+  ExpectedDecl
+  VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D);
+  ExpectedDecl VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
+
+  // Importing statements
+  ExpectedStmt VisitStmt(Stmt *S);
+  ExpectedStmt VisitGCCAsmStmt(GCCAsmStmt *S);
+  ExpectedStmt VisitDeclStmt(DeclStmt *S);
+  ExpectedStmt VisitNullStmt(NullStmt *S);
+  ExpectedStmt VisitCompoundStmt(CompoundStmt *S);
+  ExpectedStmt VisitCaseStmt(CaseStmt *S);
+  ExpectedStmt VisitDefaultStmt(DefaultStmt *S);
+  ExpectedStmt VisitLabelStmt(LabelStmt *S);
+  ExpectedStmt VisitAttributedStmt(AttributedStmt *S);
+  ExpectedStmt VisitIfStmt(IfStmt *S);
+  ExpectedStmt VisitSwitchStmt(SwitchStmt *S);
+  ExpectedStmt VisitWhileStmt(WhileStmt *S);
+  ExpectedStmt VisitDoStmt(DoStmt *S);
+  ExpectedStmt VisitForStmt(ForStmt *S);
+  ExpectedStmt VisitGotoStmt(GotoStmt *S);
+  ExpectedStmt VisitIndirectGotoStmt(IndirectGotoStmt *S);
+  ExpectedStmt VisitContinueStmt(ContinueStmt *S);
+  ExpectedStmt VisitBreakStmt(BreakStmt *S);
+  ExpectedStmt VisitReturnStmt(ReturnStmt *S);
+  // FIXME: MSAsmStmt
+  // FIXME: SEHExceptStmt
+  // FIXME: SEHFinallyStmt
+  // FIXME: SEHTryStmt
+  // FIXME: SEHLeaveStmt
+  // FIXME: CapturedStmt
+  ExpectedStmt VisitCXXCatchStmt(CXXCatchStmt *S);
+  ExpectedStmt VisitCXXTryStmt(CXXTryStmt *S);
+  ExpectedStmt VisitCXXForRangeStmt(CXXForRangeStmt *S);
+  // FIXME: MSDependentExistsStmt
+  ExpectedStmt VisitObjCForCollectionStmt(ObjCForCollectionStmt *S);
+  ExpectedStmt VisitObjCAtCatchStmt(ObjCAtCatchStmt *S);
+  ExpectedStmt VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S);
+  ExpectedStmt VisitObjCAtTryStmt(ObjCAtTryStmt *S);
+  ExpectedStmt VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S);
+  ExpectedStmt VisitObjCAtThrowStmt(ObjCAtThrowStmt *S);
+  ExpectedStmt VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
+
+  // Importing expressions
+  ExpectedStmt VisitExpr(Expr *E);
+  ExpectedStmt VisitSourceLocExpr(SourceLocExpr *E);
+  ExpectedStmt VisitVAArgExpr(VAArgExpr *E);
+  ExpectedStmt VisitChooseExpr(ChooseExpr *E);
+  ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E);
+  ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E);
+  ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E);
+  ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E);
+  ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
+  ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E);
+  ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
+  ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E);
+  ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E);
+  ExpectedStmt VisitImaginaryLiteral(ImaginaryLiteral *E);
+  ExpectedStmt VisitFixedPointLiteral(FixedPointLiteral *E);
+  ExpectedStmt VisitCharacterLiteral(CharacterLiteral *E);
+  ExpectedStmt VisitStringLiteral(StringLiteral *E);
+  ExpectedStmt VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
+  ExpectedStmt VisitAtomicExpr(AtomicExpr *E);
+  ExpectedStmt VisitAddrLabelExpr(AddrLabelExpr *E);
+  ExpectedStmt VisitConstantExpr(ConstantExpr *E);
+  ExpectedStmt VisitParenExpr(ParenExpr *E);
+  ExpectedStmt VisitParenListExpr(ParenListExpr *E);
+  ExpectedStmt VisitStmtExpr(StmtExpr *E);
+  ExpectedStmt VisitUnaryOperator(UnaryOperator *E);
+  ExpectedStmt VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E);
+  ExpectedStmt VisitBinaryOperator(BinaryOperator *E);
+  ExpectedStmt VisitConditionalOperator(ConditionalOperator *E);
+  ExpectedStmt VisitBinaryConditionalOperator(BinaryConditionalOperator *E);
+  ExpectedStmt VisitOpaqueValueExpr(OpaqueValueExpr *E);
+  ExpectedStmt VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E);
+  ExpectedStmt VisitExpressionTraitExpr(ExpressionTraitExpr *E);
+  ExpectedStmt VisitArraySubscriptExpr(ArraySubscriptExpr *E);
+  ExpectedStmt VisitCompoundAssignOperator(CompoundAssignOperator *E);
+  ExpectedStmt VisitImplicitCastExpr(ImplicitCastExpr *E);
+  ExpectedStmt VisitExplicitCastExpr(ExplicitCastExpr *E);
+  ExpectedStmt VisitOffsetOfExpr(OffsetOfExpr *OE);
+  ExpectedStmt VisitCXXThrowExpr(CXXThrowExpr *E);
+  ExpectedStmt VisitCXXNoexceptExpr(CXXNoexceptExpr *E);
+  ExpectedStmt VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
+  ExpectedStmt VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
+  ExpectedStmt VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
+  ExpectedStmt VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E);
+  ExpectedStmt VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
+  ExpectedStmt VisitPackExpansionExpr(PackExpansionExpr *E);
+  ExpectedStmt VisitSizeOfPackExpr(SizeOfPackExpr *E);
+  ExpectedStmt VisitCXXNewExpr(CXXNewExpr *E);
+  ExpectedStmt VisitCXXDeleteExpr(CXXDeleteExpr *E);
+  ExpectedStmt VisitCXXConstructExpr(CXXConstructExpr *E);
+  ExpectedStmt VisitCXXMemberCallExpr(CXXMemberCallExpr *E);
+  ExpectedStmt VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
+  ExpectedStmt VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
+  ExpectedStmt VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
+  ExpectedStmt VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
+  ExpectedStmt VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
+  ExpectedStmt VisitExprWithCleanups(ExprWithCleanups *E);
+  ExpectedStmt VisitCXXThisExpr(CXXThisExpr *E);
+  ExpectedStmt VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
+  ExpectedStmt VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
+  ExpectedStmt VisitMemberExpr(MemberExpr *E);
+  ExpectedStmt VisitCallExpr(CallExpr *E);
+  ExpectedStmt VisitLambdaExpr(LambdaExpr *LE);
+  ExpectedStmt VisitInitListExpr(InitListExpr *E);
+  ExpectedStmt VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
+  ExpectedStmt VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E);
+  ExpectedStmt VisitArrayInitLoopExpr(ArrayInitLoopExpr *E);
+  ExpectedStmt VisitArrayInitIndexExpr(ArrayInitIndexExpr *E);
+  ExpectedStmt VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E);
+  ExpectedStmt VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
+  ExpectedStmt
+  VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E);
+  ExpectedStmt VisitTypeTraitExpr(TypeTraitExpr *E);
+  ExpectedStmt VisitCXXTypeidExpr(CXXTypeidExpr *E);
+  ExpectedStmt VisitCXXFoldExpr(CXXFoldExpr *E);
+
+  template <typename IIter, typename OIter>
+  Error ImportArrayChecked(IIter Ibegin, IIter Iend, OIter Obegin) {
+    using ItemT = std::remove_reference_t<decltype(*Obegin)>;
+    for (; Ibegin != Iend; ++Ibegin, ++Obegin) {
+      Expected<ItemT> ToOrErr = import(*Ibegin);
+      if (!ToOrErr)
+        return ToOrErr.takeError();
+      *Obegin = *ToOrErr;
     }
+    return Error::success();
+  }
 
-    // Import every item from a container structure into an output container.
-    // If error occurs, stops at first error and returns the error.
-    // The output container should have space for all needed elements (it is not
-    // expanded, new items are put into from the beginning).
-    template<typename InContainerTy, typename OutContainerTy>
-    Error ImportContainerChecked(
-        const InContainerTy &InContainer, OutContainerTy &OutContainer) {
-      return ImportArrayChecked(
-          InContainer.begin(), InContainer.end(), OutContainer.begin());
-    }
+  // Import every item from a container structure into an output container.
+  // If error occurs, stops at first error and returns the error.
+  // The output container should have space for all needed elements (it is not
+  // expanded, new items are put into from the beginning).
+  template <typename InContainerTy, typename OutContainerTy>
+  Error ImportContainerChecked(InContainerTy const &InContainer,
+                               OutContainerTy &OutContainer) {
+    return ImportArrayChecked(InContainer.begin(), InContainer.end(),
+                              OutContainer.begin());
+  }
 
-    template<typename InContainerTy, typename OIter>
-    Error ImportArrayChecked(const InContainerTy &InContainer, OIter Obegin) {
-      return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
-    }
+  template <typename InContainerTy, typename OIter>
+  Error ImportArrayChecked(InContainerTy const &InContainer, OIter Obegin) {
+    return ImportArrayChecked(InContainer.begin(), InContainer.end(), Obegin);
+  }
 
-    Error ImportOverriddenMethods(CXXMethodDecl *ToMethod,
-                                  CXXMethodDecl *FromMethod);
+  Error ImportOverriddenMethods(CXXMethodDecl *ToMethod,
+                                CXXMethodDecl *FromMethod);
 
-    Expected<FunctionDecl *> FindFunctionTemplateSpecialization(
-        FunctionDecl *FromFD);
+  Expected<FunctionDecl *>
+  FindFunctionTemplateSpecialization(FunctionDecl *FromFD);
 
-    // Returns true if the given function has a placeholder return type and
-    // that type is declared inside the body of the function.
-    // E.g. auto f() { struct X{}; return X(); }
-    bool hasAutoReturnTypeDeclaredInside(FunctionDecl *D);
-  };
+  // Returns true if the given function has a placeholder return type and
+  // that type is declared inside the body of the function.
+  // E.g. auto f() { struct X{}; return X(); }
+  bool hasAutoReturnTypeDeclaredInside(FunctionDecl *D);
+};
 
 template <typename InContainerTy>
 Error ASTNodeImporter::ImportTemplateArgumentListInfo(
     SourceLocation FromLAngleLoc, SourceLocation FromRAngleLoc,
-    const InContainerTy &Container, TemplateArgumentListInfo &Result) {
+    InContainerTy const &Container, TemplateArgumentListInfo &Result) {
   auto ToLAngleLocOrErr = import(FromLAngleLoc);
   if (!ToLAngleLocOrErr)
     return ToLAngleLocOrErr.takeError();
@@ -729,25 +719,24 @@
 
 template <>
 Error ASTNodeImporter::ImportTemplateArgumentListInfo<TemplateArgumentListInfo>(
-    const TemplateArgumentListInfo &From, TemplateArgumentListInfo &Result) {
+    TemplateArgumentListInfo const &From, TemplateArgumentListInfo &Result) {
   return ImportTemplateArgumentListInfo(
       From.getLAngleLoc(), From.getRAngleLoc(), From.arguments(), Result);
 }
 
 template <>
 Error ASTNodeImporter::ImportTemplateArgumentListInfo<
-    ASTTemplateArgumentListInfo>(
-        const ASTTemplateArgumentListInfo &From,
-        TemplateArgumentListInfo &Result) {
-  return ImportTemplateArgumentListInfo(
-      From.LAngleLoc, From.RAngleLoc, From.arguments(), Result);
+    ASTTemplateArgumentListInfo>(ASTTemplateArgumentListInfo const &From,
+                                 TemplateArgumentListInfo &Result) {
+  return ImportTemplateArgumentListInfo(From.LAngleLoc, From.RAngleLoc,
+                                        From.arguments(), Result);
 }
 
 Expected<ASTNodeImporter::FunctionTemplateAndArgsTy>
 ASTNodeImporter::ImportFunctionTemplateWithTemplateArgsFromSpecialization(
     FunctionDecl *FromFD) {
   assert(FromFD->getTemplatedKind() ==
-      FunctionDecl::TK_FunctionTemplateSpecialization);
+         FunctionDecl::TK_FunctionTemplateSpecialization);
 
   FunctionTemplateAndArgsTy Result;
 
@@ -758,7 +747,7 @@
   // Import template arguments.
   auto TemplArgs = FTSInfo->TemplateArguments->asArray();
   if (Error Err = ImportTemplateArguments(TemplArgs.data(), TemplArgs.size(),
-      std::get<1>(Result)))
+                                          std::get<1>(Result)))
     return std::move(Err);
 
   return Result;
@@ -786,17 +775,13 @@
     return ToRAngleLocOrErr.takeError();
 
   return TemplateParameterList::Create(
-      Importer.getToContext(),
-      *ToTemplateLocOrErr,
-      *ToLAngleLocOrErr,
-      To,
-      *ToRAngleLocOrErr,
-      *ToRequiresClause);
+      Importer.getToContext(), *ToTemplateLocOrErr, *ToLAngleLocOrErr, To,
+      *ToRAngleLocOrErr, *ToRequiresClause);
 }
 
 template <>
 Expected<TemplateArgument>
-ASTNodeImporter::import(const TemplateArgument &From) {
+ASTNodeImporter::import(TemplateArgument const &From) {
   switch (From.getKind()) {
   case TemplateArgument::Null:
     return TemplateArgument();
@@ -829,7 +814,7 @@
     ExpectedType ToTypeOrErr = import(From.getNullPtrType());
     if (!ToTypeOrErr)
       return ToTypeOrErr.takeError();
-    return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/true);
+    return TemplateArgument(*ToTypeOrErr, /*isNullPtr*/ true);
   }
 
   case TemplateArgument::Template: {
@@ -846,8 +831,7 @@
     if (!ToTemplateOrErr)
       return ToTemplateOrErr.takeError();
 
-    return TemplateArgument(
-        *ToTemplateOrErr, From.getNumTemplateExpansions());
+    return TemplateArgument(*ToTemplateOrErr, From.getNumTemplateExpansions());
   }
 
   case TemplateArgument::Expression:
@@ -859,8 +843,8 @@
   case TemplateArgument::Pack: {
     SmallVector<TemplateArgument, 2> ToPack;
     ToPack.reserve(From.pack_size());
-    if (Error Err = ImportTemplateArguments(
-        From.pack_begin(), From.pack_size(), ToPack))
+    if (Error Err = ImportTemplateArguments(From.pack_begin(), From.pack_size(),
+                                            ToPack))
       return std::move(Err);
 
     return TemplateArgument(
@@ -873,7 +857,7 @@
 
 template <>
 Expected<TemplateArgumentLoc>
-ASTNodeImporter::import(const TemplateArgumentLoc &TALoc) {
+ASTNodeImporter::import(TemplateArgumentLoc const &TALoc) {
   Expected<TemplateArgument> ArgOrErr = import(TALoc.getArgument());
   if (!ArgOrErr)
     return ArgOrErr.takeError();
@@ -900,8 +884,7 @@
     auto ToTemplateNameLocOrErr = import(FromInfo.getTemplateNameLoc());
     if (!ToTemplateNameLocOrErr)
       return ToTemplateNameLocOrErr.takeError();
-    auto ToTemplateEllipsisLocOrErr =
-        import(FromInfo.getTemplateEllipsisLoc());
+    auto ToTemplateEllipsisLocOrErr = import(FromInfo.getTemplateEllipsisLoc());
     if (!ToTemplateEllipsisLocOrErr)
       return ToTemplateEllipsisLocOrErr.takeError();
     ToInfo = TemplateArgumentLocInfo(
@@ -913,7 +896,7 @@
 }
 
 template <>
-Expected<DeclGroupRef> ASTNodeImporter::import(const DeclGroupRef &DG) {
+Expected<DeclGroupRef> ASTNodeImporter::import(DeclGroupRef const &DG) {
   if (DG.isNull())
     return DeclGroupRef::Create(Importer.getToContext(), nullptr, 0);
   size_t NumDecls = DG.end() - DG.begin();
@@ -925,14 +908,13 @@
     else
       return ToDOrErr.takeError();
   }
-  return DeclGroupRef::Create(Importer.getToContext(),
-                              ToDecls.begin(),
+  return DeclGroupRef::Create(Importer.getToContext(), ToDecls.begin(),
                               NumDecls);
 }
 
 template <>
 Expected<ASTNodeImporter::Designator>
-ASTNodeImporter::import(const Designator &D) {
+ASTNodeImporter::import(Designator const &D) {
   if (D.isFieldDesignator()) {
     IdentifierInfo *ToFieldName = Importer.Import(D.getFieldName());
 
@@ -956,21 +938,20 @@
     return ToRBracketLocOrErr.takeError();
 
   if (D.isArrayDesignator())
-    return Designator(D.getFirstExprIndex(),
-                      *ToLBracketLocOrErr, *ToRBracketLocOrErr);
+    return Designator(D.getFirstExprIndex(), *ToLBracketLocOrErr,
+                      *ToRBracketLocOrErr);
 
   ExpectedSLoc ToEllipsisLocOrErr = import(D.getEllipsisLoc());
   if (!ToEllipsisLocOrErr)
     return ToEllipsisLocOrErr.takeError();
 
   assert(D.isArrayRangeDesignator());
-  return Designator(
-      D.getFirstExprIndex(), *ToLBracketLocOrErr, *ToEllipsisLocOrErr,
-      *ToRBracketLocOrErr);
+  return Designator(D.getFirstExprIndex(), *ToLBracketLocOrErr,
+                    *ToEllipsisLocOrErr, *ToRBracketLocOrErr);
 }
 
 template <>
-Expected<LambdaCapture> ASTNodeImporter::import(const LambdaCapture &From) {
+Expected<LambdaCapture> ASTNodeImporter::import(LambdaCapture const &From) {
   VarDecl *Var = nullptr;
   if (From.capturesVariable()) {
     if (auto VarOrErr = import(From.getCapturedVar()))
@@ -988,9 +969,8 @@
     if (Error Err = importInto(EllipsisLoc, From.getEllipsisLoc()))
       return std::move(Err);
 
-  return LambdaCapture(
-      *LocationOrErr, From.isImplicit(), From.getCaptureKind(), Var,
-      EllipsisLoc);
+  return LambdaCapture(*LocationOrErr, From.isImplicit(), From.getCaptureKind(),
+                       Var, EllipsisLoc);
 }
 
 template <typename T>
@@ -1010,8 +990,8 @@
 }
 
 template <>
-bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(TypedefNameDecl *Found,
-                                               TypedefNameDecl *From) {
+bool ASTNodeImporter::hasSameVisibilityContextAndLinkage(
+    TypedefNameDecl *Found, TypedefNameDecl *From) {
   if (Found->getLinkageInternal() != From->getLinkageInternal())
     return false;
 
@@ -1028,13 +1008,13 @@
 
 using namespace clang;
 
-ExpectedType ASTNodeImporter::VisitType(const Type *T) {
+ExpectedType ASTNodeImporter::VisitType(Type const *T) {
   Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node)
-    << T->getTypeClassName();
+      << T->getTypeClassName();
   return make_error<ImportError>(ImportError::UnsupportedConstruct);
 }
 
-ExpectedType ASTNodeImporter::VisitAtomicType(const AtomicType *T){
+ExpectedType ASTNodeImporter::VisitAtomicType(AtomicType const *T) {
   ExpectedType UnderlyingTypeOrErr = import(T->getValueType());
   if (!UnderlyingTypeOrErr)
     return UnderlyingTypeOrErr.takeError();
@@ -1042,22 +1022,22 @@
   return Importer.getToContext().getAtomicType(*UnderlyingTypeOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitBuiltinType(const BuiltinType *T) {
+ExpectedType ASTNodeImporter::VisitBuiltinType(BuiltinType const *T) {
   switch (T->getKind()) {
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-  case BuiltinType::Id: \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
+  case BuiltinType::Id:                                                        \
     return Importer.getToContext().SingletonId;
 #include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-  case BuiltinType::Id: \
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext)                                      \
+  case BuiltinType::Id:                                                        \
     return Importer.getToContext().Id##Ty;
 #include "clang/Basic/OpenCLExtensionTypes.def"
-#define SVE_TYPE(Name, Id, SingletonId) \
-  case BuiltinType::Id: \
+#define SVE_TYPE(Name, Id, SingletonId)                                        \
+  case BuiltinType::Id:                                                        \
     return Importer.getToContext().SingletonId;
 #include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-  case BuiltinType::Id: \
+#define PPC_VECTOR_TYPE(Name, Id, Size)                                        \
+  case BuiltinType::Id:                                                        \
     return Importer.getToContext().Id##Ty;
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId)                                        \
@@ -1065,15 +1045,16 @@
     return Importer.getToContext().SingletonId;
 #include "clang/Basic/RISCVVTypes.def"
 #define SHARED_SINGLETON_TYPE(Expansion)
-#define BUILTIN_TYPE(Id, SingletonId) \
-  case BuiltinType::Id: return Importer.getToContext().SingletonId;
+#define BUILTIN_TYPE(Id, SingletonId)                                          \
+  case BuiltinType::Id:                                                        \
+    return Importer.getToContext().SingletonId;
 #include "clang/AST/BuiltinTypes.def"
 
-  // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
-  // context supports C++.
+    // FIXME: for Char16, Char32, and NullPtr, make sure that the "to"
+    // context supports C++.
 
-  // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
-  // context supports ObjC.
+    // FIXME: for ObjCId, ObjCClass, and ObjCSel, make sure that the "to"
+    // context supports ObjC.
 
   case BuiltinType::Char_U:
     // The context we're importing from has an unsigned 'char'. If we're
@@ -1103,7 +1084,7 @@
   llvm_unreachable("Invalid BuiltinType Kind!");
 }
 
-ExpectedType ASTNodeImporter::VisitDecayedType(const DecayedType *T) {
+ExpectedType ASTNodeImporter::VisitDecayedType(DecayedType const *T) {
   ExpectedType ToOriginalTypeOrErr = import(T->getOriginalType());
   if (!ToOriginalTypeOrErr)
     return ToOriginalTypeOrErr.takeError();
@@ -1111,7 +1092,7 @@
   return Importer.getToContext().getDecayedType(*ToOriginalTypeOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitComplexType(const ComplexType *T) {
+ExpectedType ASTNodeImporter::VisitComplexType(ComplexType const *T) {
   ExpectedType ToElementTypeOrErr = import(T->getElementType());
   if (!ToElementTypeOrErr)
     return ToElementTypeOrErr.takeError();
@@ -1119,7 +1100,7 @@
   return Importer.getToContext().getComplexType(*ToElementTypeOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitPointerType(const PointerType *T) {
+ExpectedType ASTNodeImporter::VisitPointerType(PointerType const *T) {
   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
   if (!ToPointeeTypeOrErr)
     return ToPointeeTypeOrErr.takeError();
@@ -1127,7 +1108,7 @@
   return Importer.getToContext().getPointerType(*ToPointeeTypeOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitBlockPointerType(const BlockPointerType *T) {
+ExpectedType ASTNodeImporter::VisitBlockPointerType(BlockPointerType const *T) {
   // FIXME: Check for blocks support in "to" context.
   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
   if (!ToPointeeTypeOrErr)
@@ -1137,7 +1118,7 @@
 }
 
 ExpectedType
-ASTNodeImporter::VisitLValueReferenceType(const LValueReferenceType *T) {
+ASTNodeImporter::VisitLValueReferenceType(LValueReferenceType const *T) {
   // FIXME: Check for C++ support in "to" context.
   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
   if (!ToPointeeTypeOrErr)
@@ -1147,7 +1128,7 @@
 }
 
 ExpectedType
-ASTNodeImporter::VisitRValueReferenceType(const RValueReferenceType *T) {
+ASTNodeImporter::VisitRValueReferenceType(RValueReferenceType const *T) {
   // FIXME: Check for C++0x support in "to" context.
   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeTypeAsWritten());
   if (!ToPointeeTypeOrErr)
@@ -1157,7 +1138,7 @@
 }
 
 ExpectedType
-ASTNodeImporter::VisitMemberPointerType(const MemberPointerType *T) {
+ASTNodeImporter::VisitMemberPointerType(MemberPointerType const *T) {
   // FIXME: Check for C++ support in "to" context.
   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
   if (!ToPointeeTypeOrErr)
@@ -1172,7 +1153,7 @@
 }
 
 ExpectedType
-ASTNodeImporter::VisitConstantArrayType(const ConstantArrayType *T) {
+ASTNodeImporter::VisitConstantArrayType(ConstantArrayType const *T) {
   Error Err = Error::success();
   auto ToElementType = importChecked(Err, T->getElementType());
   auto ToSizeExpr = importChecked(Err, T->getSizeExpr());
@@ -1185,18 +1166,18 @@
 }
 
 ExpectedType
-ASTNodeImporter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
+ASTNodeImporter::VisitIncompleteArrayType(IncompleteArrayType const *T) {
   ExpectedType ToElementTypeOrErr = import(T->getElementType());
   if (!ToElementTypeOrErr)
     return ToElementTypeOrErr.takeError();
 
-  return Importer.getToContext().getIncompleteArrayType(*ToElementTypeOrErr,
-                                                        T->getSizeModifier(),
-                                                T->getIndexTypeCVRQualifiers());
+  return Importer.getToContext().getIncompleteArrayType(
+      *ToElementTypeOrErr, T->getSizeModifier(),
+      T->getIndexTypeCVRQualifiers());
 }
 
 ExpectedType
-ASTNodeImporter::VisitVariableArrayType(const VariableArrayType *T) {
+ASTNodeImporter::VisitVariableArrayType(VariableArrayType const *T) {
   Error Err = Error::success();
   QualType ToElementType = importChecked(Err, T->getElementType());
   Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
@@ -1209,7 +1190,7 @@
 }
 
 ExpectedType ASTNodeImporter::VisitDependentSizedArrayType(
-    const DependentSizedArrayType *T) {
+    DependentSizedArrayType const *T) {
   Error Err = Error::success();
   QualType ToElementType = importChecked(Err, T->getElementType());
   Expr *ToSizeExpr = importChecked(Err, T->getSizeExpr());
@@ -1224,17 +1205,16 @@
       T->getIndexTypeCVRQualifiers(), ToBracketsRange);
 }
 
-ExpectedType ASTNodeImporter::VisitVectorType(const VectorType *T) {
+ExpectedType ASTNodeImporter::VisitVectorType(VectorType const *T) {
   ExpectedType ToElementTypeOrErr = import(T->getElementType());
   if (!ToElementTypeOrErr)
     return ToElementTypeOrErr.takeError();
 
-  return Importer.getToContext().getVectorType(*ToElementTypeOrErr,
-                                               T->getNumElements(),
-                                               T->getVectorKind());
+  return Importer.getToContext().getVectorType(
+      *ToElementTypeOrErr, T->getNumElements(), T->getVectorKind());
 }
 
-ExpectedType ASTNodeImporter::VisitExtVectorType(const ExtVectorType *T) {
+ExpectedType ASTNodeImporter::VisitExtVectorType(ExtVectorType const *T) {
   ExpectedType ToElementTypeOrErr = import(T->getElementType());
   if (!ToElementTypeOrErr)
     return ToElementTypeOrErr.takeError();
@@ -1244,7 +1224,7 @@
 }
 
 ExpectedType
-ASTNodeImporter::VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
+ASTNodeImporter::VisitFunctionNoProtoType(FunctionNoProtoType const *T) {
   // FIXME: What happens if we're importing a function without a prototype
   // into C++? Should we make it variadic?
   ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
@@ -1256,14 +1236,14 @@
 }
 
 ExpectedType
-ASTNodeImporter::VisitFunctionProtoType(const FunctionProtoType *T) {
+ASTNodeImporter::VisitFunctionProtoType(FunctionProtoType const *T) {
   ExpectedType ToReturnTypeOrErr = import(T->getReturnType());
   if (!ToReturnTypeOrErr)
     return ToReturnTypeOrErr.takeError();
 
   // Import argument types
   SmallVector<QualType, 4> ArgTypes;
-  for (const auto &A : T->param_types()) {
+  for (auto const &A : T->param_types()) {
     ExpectedType TyOrErr = import(A);
     if (!TyOrErr)
       return TyOrErr.takeError();
@@ -1272,7 +1252,7 @@
 
   // Import exception types
   SmallVector<QualType, 4> ExceptionTypes;
-  for (const auto &E : T->exceptions()) {
+  for (auto const &E : T->exceptions()) {
     ExpectedType TyOrErr = import(E);
     if (!TyOrErr)
       return TyOrErr.takeError();
@@ -1299,12 +1279,12 @@
   if (Err)
     return std::move(Err);
 
-  return Importer.getToContext().getFunctionType(
-      *ToReturnTypeOrErr, ArgTypes, ToEPI);
+  return Importer.getToContext().getFunctionType(*ToReturnTypeOrErr, ArgTypes,
+                                                 ToEPI);
 }
 
-ExpectedType ASTNodeImporter::VisitUnresolvedUsingType(
-    const UnresolvedUsingType *T) {
+ExpectedType
+ASTNodeImporter::VisitUnresolvedUsingType(UnresolvedUsingType const *T) {
   Error Err = Error::success();
   auto ToD = importChecked(Err, T->getDecl());
   auto ToPrevD = importChecked(Err, T->getDecl()->getPreviousDecl());
@@ -1315,7 +1295,7 @@
       ToD, cast_or_null<TypeDecl>(ToPrevD));
 }
 
-ExpectedType ASTNodeImporter::VisitParenType(const ParenType *T) {
+ExpectedType ASTNodeImporter::VisitParenType(ParenType const *T) {
   ExpectedType ToInnerTypeOrErr = import(T->getInnerType());
   if (!ToInnerTypeOrErr)
     return ToInnerTypeOrErr.takeError();
@@ -1323,7 +1303,7 @@
   return Importer.getToContext().getParenType(*ToInnerTypeOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitTypedefType(const TypedefType *T) {
+ExpectedType ASTNodeImporter::VisitTypedefType(TypedefType const *T) {
   Expected<TypedefNameDecl *> ToDeclOrErr = import(T->getDecl());
   if (!ToDeclOrErr)
     return ToDeclOrErr.takeError();
@@ -1331,7 +1311,7 @@
   return Importer.getToContext().getTypeDeclType(*ToDeclOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitTypeOfExprType(const TypeOfExprType *T) {
+ExpectedType ASTNodeImporter::VisitTypeOfExprType(TypeOfExprType const *T) {
   ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
   if (!ToExprOrErr)
     return ToExprOrErr.takeError();
@@ -1339,7 +1319,7 @@
   return Importer.getToContext().getTypeOfExprType(*ToExprOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitTypeOfType(const TypeOfType *T) {
+ExpectedType ASTNodeImporter::VisitTypeOfType(TypeOfType const *T) {
   ExpectedType ToUnderlyingTypeOrErr = import(T->getUnderlyingType());
   if (!ToUnderlyingTypeOrErr)
     return ToUnderlyingTypeOrErr.takeError();
@@ -1347,7 +1327,7 @@
   return Importer.getToContext().getTypeOfType(*ToUnderlyingTypeOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
+ExpectedType ASTNodeImporter::VisitDecltypeType(DecltypeType const *T) {
   // FIXME: Make sure that the "to" context supports C++0x!
   ExpectedExpr ToExprOrErr = import(T->getUnderlyingExpr());
   if (!ToExprOrErr)
@@ -1357,12 +1337,12 @@
   if (!ToUnderlyingTypeOrErr)
     return ToUnderlyingTypeOrErr.takeError();
 
-  return Importer.getToContext().getDecltypeType(
-      *ToExprOrErr, *ToUnderlyingTypeOrErr);
+  return Importer.getToContext().getDecltypeType(*ToExprOrErr,
+                                                 *ToUnderlyingTypeOrErr);
 }
 
 ExpectedType
-ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
+ASTNodeImporter::VisitUnaryTransformType(UnaryTransformType const *T) {
   ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
   if (!ToBaseTypeOrErr)
     return ToBaseTypeOrErr.takeError();
@@ -1375,7 +1355,7 @@
       *ToBaseTypeOrErr, *ToUnderlyingTypeOrErr, T->getUTTKind());
 }
 
-ExpectedType ASTNodeImporter::VisitAutoType(const AutoType *T) {
+ExpectedType ASTNodeImporter::VisitAutoType(AutoType const *T) {
   // FIXME: Make sure that the "to" context supports C++11!
   ExpectedType ToDeducedTypeOrErr = import(T->getDeducedType());
   if (!ToDeducedTypeOrErr)
@@ -1387,19 +1367,18 @@
 
   SmallVector<TemplateArgument, 2> ToTemplateArgs;
   ArrayRef<TemplateArgument> FromTemplateArgs = T->getTypeConstraintArguments();
-  if (Error Err = ImportTemplateArguments(FromTemplateArgs.data(),
-                                          FromTemplateArgs.size(),
-                                          ToTemplateArgs))
+  if (Error Err = ImportTemplateArguments(
+          FromTemplateArgs.data(), FromTemplateArgs.size(), ToTemplateArgs))
     return std::move(Err);
 
   return Importer.getToContext().getAutoType(
-      *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/false,
+      *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/ false,
       /*IsPack=*/false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
       ToTemplateArgs);
 }
 
 ExpectedType ASTNodeImporter::VisitDeducedTemplateSpecializationType(
-    const DeducedTemplateSpecializationType *T) {
+    DeducedTemplateSpecializationType const *T) {
   // FIXME: Make sure that the "to" context supports C++17!
   Expected<TemplateName> ToTemplateNameOrErr = import(T->getTemplateName());
   if (!ToTemplateNameOrErr)
@@ -1412,8 +1391,8 @@
       *ToTemplateNameOrErr, *ToDeducedTypeOrErr, T->isDependentType());
 }
 
-ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
-    const InjectedClassNameType *T) {
+ExpectedType
+ASTNodeImporter::VisitInjectedClassNameType(InjectedClassNameType const *T) {
   Expected<CXXRecordDecl *> ToDeclOrErr = import(T->getDecl());
   if (!ToDeclOrErr)
     return ToDeclOrErr.takeError();
@@ -1425,16 +1404,14 @@
   // FIXME: ASTContext::getInjectedClassNameType is not suitable for AST reading
   // See comments in InjectedClassNameType definition for details
   // return Importer.getToContext().getInjectedClassNameType(D, InjType);
-  enum {
-    TypeAlignmentInBits = 4,
-    TypeAlignment = 1 << TypeAlignmentInBits
-  };
+  enum { TypeAlignmentInBits = 4, TypeAlignment = 1 << TypeAlignmentInBits };
 
   return QualType(new (Importer.getToContext(), TypeAlignment)
-                  InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr), 0);
+                      InjectedClassNameType(*ToDeclOrErr, *ToInjTypeOrErr),
+                  0);
 }
 
-ExpectedType ASTNodeImporter::VisitRecordType(const RecordType *T) {
+ExpectedType ASTNodeImporter::VisitRecordType(RecordType const *T) {
   Expected<RecordDecl *> ToDeclOrErr = import(T->getDecl());
   if (!ToDeclOrErr)
     return ToDeclOrErr.takeError();
@@ -1442,7 +1419,7 @@
   return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitEnumType(const EnumType *T) {
+ExpectedType ASTNodeImporter::VisitEnumType(EnumType const *T) {
   Expected<EnumDecl *> ToDeclOrErr = import(T->getDecl());
   if (!ToDeclOrErr)
     return ToDeclOrErr.takeError();
@@ -1450,7 +1427,7 @@
   return Importer.getToContext().getTagDeclType(*ToDeclOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitAttributedType(const AttributedType *T) {
+ExpectedType ASTNodeImporter::VisitAttributedType(AttributedType const *T) {
   ExpectedType ToModifiedTypeOrErr = import(T->getModifiedType());
   if (!ToModifiedTypeOrErr)
     return ToModifiedTypeOrErr.takeError();
@@ -1458,12 +1435,12 @@
   if (!ToEquivalentTypeOrErr)
     return ToEquivalentTypeOrErr.takeError();
 
-  return Importer.getToContext().getAttributedType(T->getAttrKind(),
-      *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
+  return Importer.getToContext().getAttributedType(
+      T->getAttrKind(), *ToModifiedTypeOrErr, *ToEquivalentTypeOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitTemplateTypeParmType(
-    const TemplateTypeParmType *T) {
+ExpectedType
+ASTNodeImporter::VisitTemplateTypeParmType(TemplateTypeParmType const *T) {
   Expected<TemplateTypeParmDecl *> ToDeclOrErr = import(T->getDecl());
   if (!ToDeclOrErr)
     return ToDeclOrErr.takeError();
@@ -1473,11 +1450,11 @@
 }
 
 ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmType(
-    const SubstTemplateTypeParmType *T) {
+    SubstTemplateTypeParmType const *T) {
   ExpectedType ReplacedOrErr = import(QualType(T->getReplacedParameter(), 0));
   if (!ReplacedOrErr)
     return ReplacedOrErr.takeError();
-  const TemplateTypeParmType *Replaced =
+  TemplateTypeParmType const *Replaced =
       cast<TemplateTypeParmType>((*ReplacedOrErr).getTypePtr());
 
   ExpectedType ToReplacementTypeOrErr = import(T->getReplacementType());
@@ -1485,15 +1462,15 @@
     return ToReplacementTypeOrErr.takeError();
 
   return Importer.getToContext().getSubstTemplateTypeParmType(
-        Replaced, (*ToReplacementTypeOrErr).getCanonicalType());
+      Replaced, (*ToReplacementTypeOrErr).getCanonicalType());
 }
 
 ExpectedType ASTNodeImporter::VisitSubstTemplateTypeParmPackType(
-    const SubstTemplateTypeParmPackType *T) {
+    SubstTemplateTypeParmPackType const *T) {
   ExpectedType ReplacedOrErr = import(QualType(T->getReplacedParameter(), 0));
   if (!ReplacedOrErr)
     return ReplacedOrErr.takeError();
-  const TemplateTypeParmType *Replaced =
+  TemplateTypeParmType const *Replaced =
       cast<TemplateTypeParmType>(ReplacedOrErr->getTypePtr());
 
   Expected<TemplateArgument> ToArgumentPack = import(T->getArgumentPack());
@@ -1505,31 +1482,30 @@
 }
 
 ExpectedType ASTNodeImporter::VisitTemplateSpecializationType(
-                                       const TemplateSpecializationType *T) {
+    TemplateSpecializationType const *T) {
   auto ToTemplateOrErr = import(T->getTemplateName());
   if (!ToTemplateOrErr)
     return ToTemplateOrErr.takeError();
 
   SmallVector<TemplateArgument, 2> ToTemplateArgs;
-  if (Error Err = ImportTemplateArguments(
-      T->getArgs(), T->getNumArgs(), ToTemplateArgs))
+  if (Error Err = ImportTemplateArguments(T->getArgs(), T->getNumArgs(),
+                                          ToTemplateArgs))
     return std::move(Err);
 
   QualType ToCanonType;
   if (!QualType(T, 0).isCanonical()) {
-    QualType FromCanonType
-      = Importer.getFromContext().getCanonicalType(QualType(T, 0));
+    QualType FromCanonType =
+        Importer.getFromContext().getCanonicalType(QualType(T, 0));
     if (ExpectedType TyOrErr = import(FromCanonType))
       ToCanonType = *TyOrErr;
     else
       return TyOrErr.takeError();
   }
-  return Importer.getToContext().getTemplateSpecializationType(*ToTemplateOrErr,
-                                                               ToTemplateArgs,
-                                                               ToCanonType);
+  return Importer.getToContext().getTemplateSpecializationType(
+      *ToTemplateOrErr, ToTemplateArgs, ToCanonType);
 }
 
-ExpectedType ASTNodeImporter::VisitElaboratedType(const ElaboratedType *T) {
+ExpectedType ASTNodeImporter::VisitElaboratedType(ElaboratedType const *T) {
   // Note: the qualifier in an ElaboratedType is optional.
   auto ToQualifierOrErr = import(T->getQualifier());
   if (!ToQualifierOrErr)
@@ -1543,14 +1519,13 @@
   if (!ToOwnedTagDeclOrErr)
     return ToOwnedTagDeclOrErr.takeError();
 
-  return Importer.getToContext().getElaboratedType(T->getKeyword(),
-                                                   *ToQualifierOrErr,
-                                                   *ToNamedTypeOrErr,
-                                                   *ToOwnedTagDeclOrErr);
+  return Importer.getToContext().getElaboratedType(
+      T->getKeyword(), *ToQualifierOrErr, *ToNamedTypeOrErr,
+      *ToOwnedTagDeclOrErr);
 }
 
 ExpectedType
-ASTNodeImporter::VisitPackExpansionType(const PackExpansionType *T) {
+ASTNodeImporter::VisitPackExpansionType(PackExpansionType const *T) {
   ExpectedType ToPatternOrErr = import(T->getPattern());
   if (!ToPatternOrErr)
     return ToPatternOrErr.takeError();
@@ -1561,7 +1536,7 @@
 }
 
 ExpectedType ASTNodeImporter::VisitDependentTemplateSpecializationType(
-    const DependentTemplateSpecializationType *T) {
+    DependentTemplateSpecializationType const *T) {
   auto ToQualifierOrErr = import(T->getQualifier());
   if (!ToQualifierOrErr)
     return ToQualifierOrErr.takeError();
@@ -1570,8 +1545,8 @@
 
   SmallVector<TemplateArgument, 2> ToPack;
   ToPack.reserve(T->getNumArgs());
-  if (Error Err = ImportTemplateArguments(
-      T->getArgs(), T->getNumArgs(), ToPack))
+  if (Error Err =
+          ImportTemplateArguments(T->getArgs(), T->getNumArgs(), ToPack))
     return std::move(Err);
 
   return Importer.getToContext().getDependentTemplateSpecializationType(
@@ -1579,7 +1554,7 @@
 }
 
 ExpectedType
-ASTNodeImporter::VisitDependentNameType(const DependentNameType *T) {
+ASTNodeImporter::VisitDependentNameType(DependentNameType const *T) {
   auto ToQualifierOrErr = import(T->getQualifier());
   if (!ToQualifierOrErr)
     return ToQualifierOrErr.takeError();
@@ -1594,13 +1569,12 @@
       return TyOrErr.takeError();
   }
 
-  return Importer.getToContext().getDependentNameType(T->getKeyword(),
-                                                      *ToQualifierOrErr,
-                                                      Name, Canon);
+  return Importer.getToContext().getDependentNameType(
+      T->getKeyword(), *ToQualifierOrErr, Name, Canon);
 }
 
 ExpectedType
-ASTNodeImporter::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
+ASTNodeImporter::VisitObjCInterfaceType(ObjCInterfaceType const *T) {
   Expected<ObjCInterfaceDecl *> ToDeclOrErr = import(T->getDecl());
   if (!ToDeclOrErr)
     return ToDeclOrErr.takeError();
@@ -1608,7 +1582,7 @@
   return Importer.getToContext().getObjCInterfaceType(*ToDeclOrErr);
 }
 
-ExpectedType ASTNodeImporter::VisitObjCObjectType(const ObjCObjectType *T) {
+ExpectedType ASTNodeImporter::VisitObjCObjectType(ObjCObjectType const *T) {
   ExpectedType ToBaseTypeOrErr = import(T->getBaseType());
   if (!ToBaseTypeOrErr)
     return ToBaseTypeOrErr.takeError();
@@ -1627,16 +1601,14 @@
       Protocols.push_back(*ProtocolOrErr);
     else
       return ProtocolOrErr.takeError();
-
   }
 
-  return Importer.getToContext().getObjCObjectType(*ToBaseTypeOrErr, TypeArgs,
-                                                   Protocols,
-                                                   T->isKindOfTypeAsWritten());
+  return Importer.getToContext().getObjCObjectType(
+      *ToBaseTypeOrErr, TypeArgs, Protocols, T->isKindOfTypeAsWritten());
 }
 
 ExpectedType
-ASTNodeImporter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
+ASTNodeImporter::VisitObjCObjectPointerType(ObjCObjectPointerType const *T) {
   ExpectedType ToPointeeTypeOrErr = import(T->getPointeeType());
   if (!ToPointeeTypeOrErr)
     return ToPointeeTypeOrErr.takeError();
@@ -1647,9 +1619,10 @@
 //----------------------------------------------------------------------------
 // Import Declarations
 //----------------------------------------------------------------------------
-Error ASTNodeImporter::ImportDeclParts(
-    NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC,
-    DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc) {
+Error ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC,
+                                       DeclContext *&LexicalDC,
+                                       DeclarationName &Name, NamedDecl *&ToD,
+                                       SourceLocation &Loc) {
   // Check if RecordDecl is in FunctionDecl parameters to avoid infinite loop.
   // example: int struct_in_proto(struct data_t{int a;int b;} *d);
   // FIXME: We could support these constructs by importing a different type of
@@ -1660,14 +1633,14 @@
   FunctionDecl *FunDecl;
   if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) &&
       FunDecl->hasBody()) {
-    auto getLeafPointeeType = [](const Type *T) {
+    auto getLeafPointeeType = [](Type const *T) {
       while (T->isPointerType() || T->isArrayType()) {
         T = T->getPointeeOrArrayElementType();
       }
       return T;
     };
-    for (const ParmVarDecl *P : FunDecl->parameters()) {
-      const Type *LeafT =
+    for (ParmVarDecl const *P : FunDecl->parameters()) {
+      Type const *LeafT =
           getLeafPointeeType(P->getType().getCanonicalType().getTypePtr());
       auto *RT = dyn_cast<RecordType>(LeafT);
       if (RT && RT->getDecl() == D) {
@@ -1749,9 +1722,8 @@
   return Error::success();
 }
 
-Error
-ASTNodeImporter::ImportDeclarationNameLoc(
-    const DeclarationNameInfo &From, DeclarationNameInfo& To) {
+Error ASTNodeImporter::ImportDeclarationNameLoc(DeclarationNameInfo const &From,
+                                                DeclarationNameInfo &To) {
   // NOTE: To.Name and To.Loc are already imported.
   // We only have to import To.LocInfo.
   switch (To.getName().getNameKind()) {
@@ -1790,8 +1762,8 @@
   llvm_unreachable("Unknown name kind.");
 }
 
-Error
-ASTNodeImporter::ImportDeclContext(DeclContext *FromDC, bool ForceImport) {
+Error ASTNodeImporter::ImportDeclContext(DeclContext *FromDC,
+                                         bool ForceImport) {
   if (Importer.isMinimalImport() && !ForceImport) {
     auto ToDCOrErr = Importer.ImportContext(FromDC);
     return ToDCOrErr.takeError();
@@ -1826,15 +1798,19 @@
         // If we have a field that is an ArrayType we need to check if the array
         // element is a RecordDecl and if so we need to import the defintion.
         if (FieldFrom->getType()->isArrayType()) {
-          // getBaseElementTypeUnsafe(...) handles multi-dimensonal arrays for us.
-          FromRecordDecl = FieldFrom->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
-          ToRecordDecl = FieldTo->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
+          // getBaseElementTypeUnsafe(...) handles multi-dimensonal arrays for
+          // us.
+          FromRecordDecl = FieldFrom->getType()
+                               ->getBaseElementTypeUnsafe()
+                               ->getAsRecordDecl();
+          ToRecordDecl =
+              FieldTo->getType()->getBaseElementTypeUnsafe()->getAsRecordDecl();
         }
 
         if (!FromRecordDecl || !ToRecordDecl) {
-          const RecordType *RecordFrom =
+          RecordType const *RecordFrom =
               FieldFrom->getType()->getAs<RecordType>();
-          const RecordType *RecordTo = FieldTo->getType()->getAs<RecordType>();
+          RecordType const *RecordTo = FieldTo->getType()->getAs<RecordType>();
 
           if (RecordFrom && RecordTo) {
             FromRecordDecl = RecordFrom->getDecl();
@@ -1848,7 +1824,7 @@
             Error Err = ImportDefinition(FromRecordDecl, ToRecordDecl);
 
             if (Err && AccumulateChildErrors)
-              ChildErrors =  joinErrors(std::move(ChildErrors), std::move(Err));
+              ChildErrors = joinErrors(std::move(ChildErrors), std::move(Err));
             else
               consumeError(std::move(Err));
           }
@@ -1886,7 +1862,7 @@
   // interface in LLDB is implemented by the means of the ASTImporter. However,
   // calling an import at this point would result in an uncontrolled import, we
   // must avoid that.
-  const auto *FromRD = dyn_cast<RecordDecl>(FromDC);
+  auto const *FromRD = dyn_cast<RecordDecl>(FromDC);
   if (!FromRD)
     return ChildErrors;
 
@@ -1919,16 +1895,16 @@
   return ChildErrors;
 }
 
-Error ASTNodeImporter::ImportDeclContext(
-    Decl *FromD, DeclContext *&ToDC, DeclContext *&ToLexicalDC) {
+Error ASTNodeImporter::ImportDeclContext(Decl *FromD, DeclContext *&ToDC,
+                                         DeclContext *&ToLexicalDC) {
   auto ToDCOrErr = Importer.ImportContext(FromD->getDeclContext());
   if (!ToDCOrErr)
     return ToDCOrErr.takeError();
   ToDC = *ToDCOrErr;
 
   if (FromD->getDeclContext() != FromD->getLexicalDeclContext()) {
-    auto ToLexicalDCOrErr = Importer.ImportContext(
-        FromD->getLexicalDeclContext());
+    auto ToLexicalDCOrErr =
+        Importer.ImportContext(FromD->getLexicalDeclContext());
     if (!ToLexicalDCOrErr)
       return ToLexicalDCOrErr.takeError();
     ToLexicalDC = *ToLexicalDCOrErr;
@@ -1938,10 +1914,10 @@
   return Error::success();
 }
 
-Error ASTNodeImporter::ImportImplicitMethods(
-    const CXXRecordDecl *From, CXXRecordDecl *To) {
+Error ASTNodeImporter::ImportImplicitMethods(CXXRecordDecl const *From,
+                                             CXXRecordDecl *To) {
   assert(From->isCompleteDefinition() && To->getDefinition() == To &&
-      "Import implicit methods to or from non-definition");
+         "Import implicit methods to or from non-definition");
 
   for (CXXMethodDecl *FromM : From->methods())
     if (FromM->isImplicit()) {
@@ -1964,8 +1940,8 @@
   return Error::success();
 }
 
-Error ASTNodeImporter::ImportDefinition(
-    RecordDecl *From, RecordDecl *To, ImportDefinitionKind Kind) {
+Error ASTNodeImporter::ImportDefinition(RecordDecl *From, RecordDecl *To,
+                                        ImportDefinitionKind Kind) {
   auto DefinitionCompleter = [To]() {
     // There are cases in LLDB when we first import a class without its
     // members. The class will have DefinitionData, but no members. Then,
@@ -1988,7 +1964,7 @@
         auto *FromCXXRD = cast<CXXRecordDecl>(From);
         SmallVector<LambdaCapture, 8> ToCaptures;
         ToCaptures.reserve(FromCXXRD->capture_size());
-        for (const auto &FromCapture : FromCXXRD->captures()) {
+        for (auto const &FromCapture : FromCXXRD->captures()) {
           if (auto ToCaptureOrErr = import(FromCapture))
             ToCaptures.push_back(*ToCaptureOrErr);
           else
@@ -2026,15 +2002,14 @@
     struct CXXRecordDecl::DefinitionData &ToData = ToCXX->data();
     struct CXXRecordDecl::DefinitionData &FromData = FromCXX->data();
 
-    #define FIELD(Name, Width, Merge) \
-    ToData.Name = FromData.Name;
-    #include "clang/AST/CXXRecordDeclDefinitionBits.def"
+#define FIELD(Name, Width, Merge) ToData.Name = FromData.Name;
+#include "clang/AST/CXXRecordDeclDefinitionBits.def"
 
     // Copy over the data stored in RecordDeclBits
     ToCXX->setArgPassingRestrictions(FromCXX->getArgPassingRestrictions());
 
     SmallVector<CXXBaseSpecifier *, 4> Bases;
-    for (const auto &Base1 : FromCXX->bases()) {
+    for (auto const &Base1 : FromCXX->bases()) {
       ExpectedType TyOrErr = import(Base1.getType());
       if (!TyOrErr)
         return TyOrErr.takeError();
@@ -2049,7 +2024,7 @@
 
       // Ensure that we have a definition for the base.
       if (Error Err =
-          ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()))
+              ImportDefinitionIfNeeded(Base1.getType()->getAsCXXRecordDecl()))
         return Err;
 
       auto RangeOrErr = import(Base1.getSourceRange());
@@ -2060,14 +2035,9 @@
       if (!TSIOrErr)
         return TSIOrErr.takeError();
 
-      Bases.push_back(
-          new (Importer.getToContext()) CXXBaseSpecifier(
-              *RangeOrErr,
-              Base1.isVirtual(),
-              Base1.isBaseOfClass(),
-              Base1.getAccessSpecifierAsWritten(),
-              *TSIOrErr,
-              EllipsisLoc));
+      Bases.push_back(new (Importer.getToContext()) CXXBaseSpecifier(
+          *RangeOrErr, Base1.isVirtual(), Base1.isBaseOfClass(),
+          Base1.getAccessSpecifierAsWritten(), *TSIOrErr, EllipsisLoc));
     }
     if (!Bases.empty())
       ToCXX->setBases(Bases.data(), Bases.size());
@@ -2104,8 +2074,8 @@
   return Error::success();
 }
 
-Error ASTNodeImporter::ImportDefinition(
-    EnumDecl *From, EnumDecl *To, ImportDefinitionKind Kind) {
+Error ASTNodeImporter::ImportDefinition(EnumDecl *From, EnumDecl *To,
+                                        ImportDefinitionKind Kind) {
   if (To->getDefinition() || To->isBeingDefined()) {
     if (Kind == IDK_Everything)
       return ImportDeclContext(From, /*ForceImport=*/true);
@@ -2139,7 +2109,7 @@
 }
 
 Error ASTNodeImporter::ImportTemplateArguments(
-    const TemplateArgument *FromArgs, unsigned NumFromArgs,
+    TemplateArgument const *FromArgs, unsigned NumFromArgs,
     SmallVectorImpl<TemplateArgument> &ToArgs) {
   for (unsigned I = 0; I != NumFromArgs; ++I) {
     if (auto ToOrErr = import(FromArgs[I]))
@@ -2153,14 +2123,14 @@
 
 // FIXME: Do not forget to remove this and use only 'import'.
 Expected<TemplateArgument>
-ASTNodeImporter::ImportTemplateArgument(const TemplateArgument &From) {
+ASTNodeImporter::ImportTemplateArgument(TemplateArgument const &From) {
   return import(From);
 }
 
 template <typename InContainerTy>
 Error ASTNodeImporter::ImportTemplateArgumentListInfo(
-    const InContainerTy &Container, TemplateArgumentListInfo &ToTAInfo) {
-  for (const auto &FromLoc : Container) {
+    InContainerTy const &Container, TemplateArgumentListInfo &ToTAInfo) {
+  for (auto const &FromLoc : Container) {
     if (auto ToLocOrErr = import(FromLoc))
       ToTAInfo.addArgument(*ToLocOrErr);
     else
@@ -2170,7 +2140,7 @@
 }
 
 static StructuralEquivalenceKind
-getStructuralEquivalenceKind(const ASTImporter &Importer) {
+getStructuralEquivalenceKind(ASTImporter const &Importer) {
   return Importer.isMinimalImport() ? StructuralEquivalenceKind::Minimal
                                     : StructuralEquivalenceKind::Default;
 }
@@ -2194,11 +2164,10 @@
       ToRecord = ToOriginRecord;
   }
 
-  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
-                                   ToRecord->getASTContext(),
-                                   Importer.getNonEquivalentDecls(),
-                                   getStructuralEquivalenceKind(Importer),
-                                   false, Complain);
+  StructuralEquivalenceContext Ctx(
+      Importer.getFromContext(), ToRecord->getASTContext(),
+      Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer),
+      false, Complain);
   return Ctx.IsEquivalent(FromRecord, ToRecord);
 }
 
@@ -2216,7 +2185,7 @@
   // something we're trying to import while completing ToEnum.
   if (Decl *ToOrigin = Importer.GetOriginalDecl(ToEnum))
     if (auto *ToOriginEnum = dyn_cast<EnumDecl>(ToOrigin))
-        ToEnum = ToOriginEnum;
+      ToEnum = ToOriginEnum;
 
   StructuralEquivalenceContext Ctx(
       Importer.getFromContext(), Importer.getToContext(),
@@ -2243,35 +2212,32 @@
 
 bool ASTNodeImporter::IsStructuralMatch(EnumConstantDecl *FromEC,
                                         EnumConstantDecl *ToEC) {
-  const llvm::APSInt &FromVal = FromEC->getInitVal();
-  const llvm::APSInt &ToVal = ToEC->getInitVal();
+  llvm::APSInt const &FromVal = FromEC->getInitVal();
+  llvm::APSInt const &ToVal = ToEC->getInitVal();
 
   return FromVal.isSigned() == ToVal.isSigned() &&
-         FromVal.getBitWidth() == ToVal.getBitWidth() &&
-         FromVal == ToVal;
+         FromVal.getBitWidth() == ToVal.getBitWidth() && FromVal == ToVal;
 }
 
 bool ASTNodeImporter::IsStructuralMatch(ClassTemplateDecl *From,
                                         ClassTemplateDecl *To) {
-  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
-                                   Importer.getToContext(),
-                                   Importer.getNonEquivalentDecls(),
-                                   getStructuralEquivalenceKind(Importer));
+  StructuralEquivalenceContext Ctx(
+      Importer.getFromContext(), Importer.getToContext(),
+      Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
   return Ctx.IsEquivalent(From, To);
 }
 
 bool ASTNodeImporter::IsStructuralMatch(VarTemplateDecl *From,
                                         VarTemplateDecl *To) {
-  StructuralEquivalenceContext Ctx(Importer.getFromContext(),
-                                   Importer.getToContext(),
-                                   Importer.getNonEquivalentDecls(),
-                                   getStructuralEquivalenceKind(Importer));
+  StructuralEquivalenceContext Ctx(
+      Importer.getFromContext(), Importer.getToContext(),
+      Importer.getNonEquivalentDecls(), getStructuralEquivalenceKind(Importer));
   return Ctx.IsEquivalent(From, To);
 }
 
 ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {
   Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node)
-    << D->getDeclKindName();
+      << D->getDeclKindName();
   return make_error<ImportError>(ImportError::UnsupportedConstruct);
 }
 
@@ -2302,8 +2268,7 @@
 }
 
 ExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
-  TranslationUnitDecl *ToD =
-    Importer.getToContext().getTranslationUnitDecl();
+  TranslationUnitDecl *ToD = Importer.getToContext().getTranslationUnitDecl();
 
   Importer.MapImported(D, ToD);
 
@@ -2382,9 +2347,9 @@
     return std::move(Err);
 
   StaticAssertDecl *ToD;
-  if (GetImportedOrCreateDecl(
-      ToD, D, Importer.getToContext(), DC, ToLocation, ToAssertExpr, ToMessage,
-      ToRParenLoc, D->isFailed()))
+  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, ToLocation,
+                              ToAssertExpr, ToMessage, ToRParenLoc,
+                              D->isFailed()))
     return ToD;
 
   ToD->setLexicalDeclContext(LexicalDC);
@@ -2449,10 +2414,10 @@
   // Create the "to" namespace, if needed.
   NamespaceDecl *ToNamespace = MergeWithNamespace;
   if (!ToNamespace) {
-    if (GetImportedOrCreateDecl(
-            ToNamespace, D, Importer.getToContext(), DC, D->isInline(),
-            *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
-            /*PrevDecl=*/nullptr))
+    if (GetImportedOrCreateDecl(ToNamespace, D, Importer.getToContext(), DC,
+                                D->isInline(), *BeginLocOrErr, Loc,
+                                Name.getAsIdentifierInfo(),
+                                /*PrevDecl=*/nullptr))
       return ToNamespace;
     ToNamespace->setRBraceLoc(*RBraceLocOrErr);
     ToNamespace->setLexicalDeclContext(LexicalDC);
@@ -2500,9 +2465,9 @@
   IdentifierInfo *ToIdentifier = Importer.Import(D->getIdentifier());
 
   NamespaceAliasDecl *ToD;
-  if (GetImportedOrCreateDecl(
-      ToD, D, Importer.getToContext(), DC, ToNamespaceLoc, ToAliasLoc,
-      ToIdentifier, ToQualifierLoc, ToTargetNameLoc, ToNamespace))
+  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC,
+                              ToNamespaceLoc, ToAliasLoc, ToIdentifier,
+                              ToQualifierLoc, ToTargetNameLoc, ToNamespace))
     return ToD;
 
   ToD->setLexicalDeclContext(LexicalDC);
@@ -2511,8 +2476,8 @@
   return ToD;
 }
 
-ExpectedDecl
-ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias) {
+ExpectedDecl ASTNodeImporter::VisitTypedefNameDecl(TypedefNameDecl *D,
+                                                   bool IsAlias) {
   // Import the major distinguishing characteristics of this typedef.
   DeclarationName Name;
   SourceLocation Loc;
@@ -2585,12 +2550,12 @@
   TypedefNameDecl *ToTypedef;
   if (IsAlias) {
     if (GetImportedOrCreateDecl<TypeAliasDecl>(
-        ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
-        Name.getAsIdentifierInfo(), ToTypeSourceInfo))
+            ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
+            Name.getAsIdentifierInfo(), ToTypeSourceInfo))
       return ToTypedef;
   } else if (GetImportedOrCreateDecl<TypedefDecl>(
-      ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
-      Name.getAsIdentifierInfo(), ToTypeSourceInfo))
+                 ToTypedef, D, Importer.getToContext(), DC, ToBeginLoc, Loc,
+                 Name.getAsIdentifierInfo(), ToTypeSourceInfo))
     return ToTypedef;
 
   // Import the DeclContext and set it to the Typedef.
@@ -2703,7 +2668,6 @@
     if (GetImportedOrCreateDecl(ToLabel, D, Importer.getToContext(), DC, Loc,
                                 Name.getAsIdentifierInfo()))
       return ToLabel;
-
   }
 
   Expected<LabelStmt *> ToStmtOrErr = import(D->getStmt());
@@ -2731,8 +2695,8 @@
   unsigned IDNS = Decl::IDNS_Tag;
   DeclarationName SearchName = Name;
   if (!SearchName && D->getTypedefNameForAnonDecl()) {
-    if (Error Err = importInto(
-        SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
+    if (Error Err = importInto(SearchName,
+                               D->getTypedefNameForAnonDecl()->getDeclName()))
       return std::move(Err);
     IDNS = Decl::IDNS_Ordinary;
   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
@@ -2742,14 +2706,13 @@
   EnumDecl *PrevDecl = nullptr;
   if (!DC->isFunctionOrMethod() && SearchName) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
-    auto FoundDecls =
-        Importer.findDeclsInToCtx(DC, SearchName);
+    auto FoundDecls = Importer.findDeclsInToCtx(DC, SearchName);
     for (auto *FoundDecl : FoundDecls) {
       if (!FoundDecl->isInIdentifierNamespace(IDNS))
         continue;
 
       if (auto *Typedef = dyn_cast<TypedefNameDecl>(FoundDecl)) {
-        if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
+        if (auto const *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
           FoundDecl = Tag->getDecl();
       }
 
@@ -2788,10 +2751,10 @@
 
   // Create the enum declaration.
   EnumDecl *D2;
-  if (GetImportedOrCreateDecl(
-          D2, D, Importer.getToContext(), DC, ToBeginLoc,
-          Loc, Name.getAsIdentifierInfo(), PrevDecl, D->isScoped(),
-          D->isScopedUsingClassTag(), D->isFixed()))
+  if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC, ToBeginLoc,
+                              Loc, Name.getAsIdentifierInfo(), PrevDecl,
+                              D->isScoped(), D->isScopedUsingClassTag(),
+                              D->isFixed()))
     return D2;
 
   D2->setQualifierInfo(ToQualifierLoc);
@@ -2845,8 +2808,8 @@
   unsigned IDNS = Decl::IDNS_Tag;
   DeclarationName SearchName = Name;
   if (!SearchName && D->getTypedefNameForAnonDecl()) {
-    if (Error Err = importInto(
-        SearchName, D->getTypedefNameForAnonDecl()->getDeclName()))
+    if (Error Err = importInto(SearchName,
+                               D->getTypedefNameForAnonDecl()->getDeclName()))
       return std::move(Err);
     IDNS = Decl::IDNS_Ordinary;
   } else if (Importer.getToContext().getLangOpts().CPlusPlus)
@@ -2856,8 +2819,7 @@
   RecordDecl *PrevDecl = nullptr;
   if (!DC->isFunctionOrMethod() && !D->isLambda()) {
     SmallVector<NamedDecl *, 4> ConflictingDecls;
-    auto FoundDecls =
-        Importer.findDeclsInToCtx(DC, SearchName);
+    auto FoundDecls = Importer.findDeclsInToCtx(DC, SearchName);
     if (!FoundDecls.empty()) {
       // We're going to have to compare D against potentially conflicting Decls,
       // so complete it.
@@ -2871,7 +2833,7 @@
 
       Decl *Found = FoundDecl;
       if (auto *Typedef = dyn_cast<TypedefNameDecl>(Found)) {
-        if (const auto *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
+        if (auto const *Tag = Typedef->getUnderlyingType()->getAs<TagType>())
           Found = Tag->getDecl();
       }
 
@@ -2898,7 +2860,7 @@
             // FIXME: Structural equivalence check should check for same
             // user-defined methods.
             Importer.MapImported(D, FoundDef);
-            if (const auto *DCXX = dyn_cast<CXXRecordDecl>(D)) {
+            if (auto const *DCXX = dyn_cast<CXXRecordDecl>(D)) {
               auto *FoundCXX = dyn_cast<CXXRecordDecl>(FoundDef);
               assert(FoundCXX && "Record type mismatch");
 
@@ -2914,7 +2876,7 @@
         }
         ConflictingDecls.push_back(FoundDecl);
       } // kind is RecordDecl
-    } // for
+    }   // for
 
     if (!ConflictingDecls.empty() && SearchName) {
       ExpectedName NameOrErr = Importer.HandleNameConflict(
@@ -2951,17 +2913,17 @@
                                DCXX->hasKnownLambdaInternalLinkage());
       D2CXX->setDeviceLambdaManglingNumber(
           DCXX->getDeviceLambdaManglingNumber());
-   } else if (DCXX->isInjectedClassName()) {
+    } else if (DCXX->isInjectedClassName()) {
       // We have to be careful to do a similar dance to the one in
       // Sema::ActOnStartCXXMemberDeclarations
-      const bool DelayTypeCreation = true;
+      bool const DelayTypeCreation = true;
       if (GetImportedOrCreateDecl(
               D2CXX, D, Importer.getToContext(), D->getTagKind(), DC,
               *BeginLocOrErr, Loc, Name.getAsIdentifierInfo(),
               cast_or_null<CXXRecordDecl>(PrevDecl), DelayTypeCreation))
         return D2CXX;
-      Importer.getToContext().getTypeDeclType(
-          D2CXX, dyn_cast<CXXRecordDecl>(DC));
+      Importer.getToContext().getTypeDeclType(D2CXX,
+                                              dyn_cast<CXXRecordDecl>(DC));
     } else {
       if (GetImportedOrCreateDecl(D2CXX, D, Importer.getToContext(),
                                   D->getTagKind(), DC, *BeginLocOrErr, Loc,
@@ -2975,8 +2937,7 @@
     D2->setLexicalDeclContext(LexicalDC);
     addDeclToContexts(D, D2);
 
-    if (ClassTemplateDecl *FromDescribed =
-        DCXX->getDescribedClassTemplate()) {
+    if (ClassTemplateDecl *FromDescribed = DCXX->getDescribedClassTemplate()) {
       ClassTemplateDecl *ToDescribed;
       if (Error Err = importInto(ToDescribed, FromDescribed))
         return std::move(Err);
@@ -2997,8 +2958,7 @@
           }
         }
         // Create an injected type for the whole redecl chain.
-        SmallVector<Decl *, 2> Redecls =
-            getCanonicalForwardRedeclChain(D2CXX);
+        SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D2CXX);
         for (auto *R : Redecls) {
           auto *RI = cast<CXXRecordDecl>(R);
           RI->setTypeForDecl(nullptr);
@@ -3016,26 +2976,25 @@
       }
     } else if (MemberSpecializationInfo *MemberInfo =
                    DCXX->getMemberSpecializationInfo()) {
-        TemplateSpecializationKind SK =
-            MemberInfo->getTemplateSpecializationKind();
-        CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
+      TemplateSpecializationKind SK =
+          MemberInfo->getTemplateSpecializationKind();
+      CXXRecordDecl *FromInst = DCXX->getInstantiatedFromMemberClass();
 
-        if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst))
-          D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK);
-        else
-          return ToInstOrErr.takeError();
+      if (Expected<CXXRecordDecl *> ToInstOrErr = import(FromInst))
+        D2CXX->setInstantiationOfMemberClass(*ToInstOrErr, SK);
+      else
+        return ToInstOrErr.takeError();
 
-        if (ExpectedSLoc POIOrErr =
-            import(MemberInfo->getPointOfInstantiation()))
-          D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
+      if (ExpectedSLoc POIOrErr = import(MemberInfo->getPointOfInstantiation()))
+        D2CXX->getMemberSpecializationInfo()->setPointOfInstantiation(
             *POIOrErr);
-        else
-          return POIOrErr.takeError();
+      else
+        return POIOrErr.takeError();
     }
 
   } else {
-    if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(),
-                                D->getTagKind(), DC, *BeginLocOrErr, Loc,
+    if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), D->getTagKind(),
+                                DC, *BeginLocOrErr, Loc,
                                 Name.getAsIdentifierInfo(), PrevDecl))
       return D2;
     D2->setLexicalDeclContext(LexicalDC);
@@ -3119,7 +3078,7 @@
   return ToEnumerator;
 }
 
-Error ASTNodeImporter::ImportTemplateParameterLists(const DeclaratorDecl *FromD,
+Error ASTNodeImporter::ImportTemplateParameterLists(DeclaratorDecl const *FromD,
                                                     DeclaratorDecl *ToD) {
   unsigned int Num = FromD->getNumTemplateParameterLists();
   if (Num == 0)
@@ -3135,8 +3094,8 @@
   return Error::success();
 }
 
-Error ASTNodeImporter::ImportTemplateInformation(
-    FunctionDecl *FromFD, FunctionDecl *ToFD) {
+Error ASTNodeImporter::ImportTemplateInformation(FunctionDecl *FromFD,
+                                                 FunctionDecl *ToFD) {
   switch (FromFD->getTemplatedKind()) {
   case FunctionDecl::TK_NonTemplate:
   case FunctionDecl::TK_FunctionTemplate:
@@ -3146,13 +3105,13 @@
     TemplateSpecializationKind TSK = FromFD->getTemplateSpecializationKind();
 
     if (Expected<FunctionDecl *> InstFDOrErr =
-        import(FromFD->getInstantiatedFromMemberFunction()))
+            import(FromFD->getInstantiatedFromMemberFunction()))
       ToFD->setInstantiationOfMemberFunction(*InstFDOrErr, TSK);
     else
       return InstFDOrErr.takeError();
 
     if (ExpectedSLoc POIOrErr = import(
-        FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()))
+            FromFD->getMemberSpecializationInfo()->getPointOfInstantiation()))
       ToFD->getMemberSpecializationInfo()->setPointOfInstantiation(*POIOrErr);
     else
       return POIOrErr.takeError();
@@ -3167,14 +3126,14 @@
       return FunctionAndArgsOrErr.takeError();
 
     TemplateArgumentList *ToTAList = TemplateArgumentList::CreateCopy(
-          Importer.getToContext(), std::get<1>(*FunctionAndArgsOrErr));
+        Importer.getToContext(), std::get<1>(*FunctionAndArgsOrErr));
 
     auto *FTSInfo = FromFD->getTemplateSpecializationInfo();
     TemplateArgumentListInfo ToTAInfo;
-    const auto *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
+    auto const *FromTAArgsAsWritten = FTSInfo->TemplateArgumentsAsWritten;
     if (FromTAArgsAsWritten)
-      if (Error Err = ImportTemplateArgumentListInfo(
-          *FromTAArgsAsWritten, ToTAInfo))
+      if (Error Err =
+              ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ToTAInfo))
         return Err;
 
     ExpectedSLoc POIOrErr = import(FTSInfo->getPointOfInstantiation());
@@ -3197,7 +3156,7 @@
     unsigned NumTemplates = FromInfo->getNumTemplates();
     for (unsigned I = 0; I < NumTemplates; I++) {
       if (Expected<FunctionTemplateDecl *> ToFTDOrErr =
-          import(FromInfo->getTemplate(I)))
+              import(FromInfo->getTemplate(I)))
         TemplDecls.addDecl(*ToFTDOrErr);
       else
         return ToFTDOrErr.takeError();
@@ -3206,10 +3165,10 @@
     // Import TemplateArgumentListInfo.
     TemplateArgumentListInfo ToTAInfo;
     if (Error Err = ImportTemplateArgumentListInfo(
-        FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
-        llvm::makeArrayRef(
-            FromInfo->getTemplateArgs(), FromInfo->getNumTemplateArgs()),
-        ToTAInfo))
+            FromInfo->getLAngleLoc(), FromInfo->getRAngleLoc(),
+            llvm::makeArrayRef(FromInfo->getTemplateArgs(),
+                               FromInfo->getNumTemplateArgs()),
+            ToTAInfo))
       return Err;
 
     ToFD->setDependentTemplateSpecialization(Importer.getToContext(),
@@ -3248,8 +3207,8 @@
 
 // Returns true if the given D has a DeclContext up to the TranslationUnitDecl
 // which is equal to the given DC.
-static bool isAncestorDeclContextOf(const DeclContext *DC, const Decl *D) {
-  const DeclContext *DCi = D->getDeclContext();
+static bool isAncestorDeclContextOf(DeclContext const *DC, Decl const *D) {
+  DeclContext const *DCi = D->getDeclContext();
   while (DCi != D->getTranslationUnitDecl()) {
     if (DCi == DC)
       return true;
@@ -3260,11 +3219,11 @@
 
 bool ASTNodeImporter::hasAutoReturnTypeDeclaredInside(FunctionDecl *D) {
   QualType FromTy = D->getType();
-  const FunctionProtoType *FromFPT = FromTy->getAs<FunctionProtoType>();
+  FunctionProtoType const *FromFPT = FromTy->getAs<FunctionProtoType>();
   assert(FromFPT && "Must be called on FunctionProtoType");
   if (AutoType *AutoT = FromFPT->getReturnType()->getContainedAutoType()) {
     QualType DeducedT = AutoT->getDeducedType();
-    if (const RecordType *RecordT =
+    if (RecordType const *RecordT =
             DeducedT.isNull() ? nullptr : dyn_cast<RecordType>(DeducedT)) {
       RecordDecl *RD = RecordT->getDecl();
       assert(RD);
@@ -3274,7 +3233,7 @@
       }
     }
   }
-  if (const TypedefType *TypedefT =
+  if (TypedefType const *TypedefT =
           dyn_cast<TypedefType>(FromFPT->getReturnType())) {
     TypedefNameDecl *TD = TypedefT->getDecl();
     assert(TD);
@@ -3423,7 +3382,7 @@
   // FunctionDecl with a simplified function type and update it only after the
   // relevant AST nodes are already imported.
   bool UsedDifferentProtoType = false;
-  if (const auto *FromFPT = FromTy->getAs<FunctionProtoType>()) {
+  if (auto const *FromFPT = FromTy->getAs<FunctionProtoType>()) {
     QualType FromReturnTy = FromFPT->getReturnType();
     // Functions with auto return type may define a struct inside their body
     // and the return type could refer to that struct.
@@ -3547,8 +3506,8 @@
 
   // Connect the redecl chain.
   if (FoundByLookup) {
-    auto *Recent = const_cast<FunctionDecl *>(
-          FoundByLookup->getMostRecentDecl());
+    auto *Recent =
+        const_cast<FunctionDecl *>(FoundByLookup->getMostRecentDecl());
     ToFunction->setPreviousDecl(Recent);
     // FIXME Probably we should merge exception specifications.  E.g. In the
     // "To" context the existing function may have exception specification with
@@ -3581,7 +3540,7 @@
   // params it refers to.
   if (TInfo) {
     if (auto ProtoLoc =
-        TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
+            TInfo->getTypeLoc().IgnoreParens().getAs<FunctionProtoTypeLoc>()) {
       for (unsigned I = 0, N = Parameters.size(); I != N; ++I)
         ProtoLoc.setParam(I, Parameters[I]);
     }
@@ -3599,8 +3558,8 @@
     if (unsigned NumInitializers = FromConstructor->getNumCtorInitializers()) {
       SmallVector<CXXCtorInitializer *, 4> CtorInitializers(NumInitializers);
       // Import first, then allocate memory and copy if there was no error.
-      if (Error Err = ImportContainerChecked(
-          FromConstructor->inits(), CtorInitializers))
+      if (Error Err = ImportContainerChecked(FromConstructor->inits(),
+                                             CtorInitializers))
         return std::move(Err);
       auto **Memory =
           new (Importer.getToContext()) CXXCtorInitializer *[NumInitializers];
@@ -3686,9 +3645,8 @@
   for (auto *FoundDecl : FoundDecls) {
     if (FieldDecl *FoundField = dyn_cast<FieldDecl>(FoundDecl)) {
       // For anonymous fields, match up by index.
-      if (!Name &&
-          ASTImporter::getFieldIndex(D) !=
-          ASTImporter::getFieldIndex(FoundField))
+      if (!Name && ASTImporter::getFieldIndex(D) !=
+                       ASTImporter::getFieldIndex(FoundField))
         continue;
 
       if (Importer.IsStructurallyEquivalent(D->getType(),
@@ -3718,9 +3676,9 @@
 
       // FIXME: Why is this case not handled with calling HandleNameConflict?
       Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
-        << Name << D->getType() << FoundField->getType();
+          << Name << D->getType() << FoundField->getType();
       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
-        << FoundField->getType();
+          << FoundField->getType();
 
       return make_error<ImportError>(ImportError::NameConflict);
     }
@@ -3734,7 +3692,7 @@
   auto ToInitializer = importChecked(Err, D->getInClassInitializer());
   if (Err)
     return std::move(Err);
-  const Type *ToCapturedVLAType = nullptr;
+  Type const *ToCapturedVLAType = nullptr;
   if (Error Err = Importer.importInto(
           ToCapturedVLAType, cast_or_null<Type>(D->getCapturedVLAType())))
     return std::move(Err);
@@ -3773,27 +3731,25 @@
   for (unsigned I = 0, N = FoundDecls.size(); I != N; ++I) {
     if (auto *FoundField = dyn_cast<IndirectFieldDecl>(FoundDecls[I])) {
       // For anonymous indirect fields, match up by index.
-      if (!Name &&
-          ASTImporter::getFieldIndex(D) !=
-          ASTImporter::getFieldIndex(FoundField))
+      if (!Name && ASTImporter::getFieldIndex(D) !=
+                       ASTImporter::getFieldIndex(FoundField))
         continue;
 
-      if (Importer.IsStructurallyEquivalent(D->getType(),
-                                            FoundField->getType(),
+      if (Importer.IsStructurallyEquivalent(D->getType(), FoundField->getType(),
                                             !Name.isEmpty())) {
         Importer.MapImported(D, FoundField);
         return FoundField;
       }
 
       // If there are more anonymous fields to check, continue.
-      if (!Name && I < N-1)
+      if (!Name && I < N - 1)
         continue;
 
       // FIXME: Why is this case not handled with calling HandleNameConflict?
       Importer.ToDiag(Loc, diag::warn_odr_field_type_inconsistent)
-        << Name << D->getType() << FoundField->getType();
+          << Name << D->getType() << FoundField->getType();
       Importer.ToDiag(FoundField->getLocation(), diag::note_odr_value_here)
-        << FoundField->getType();
+          << FoundField->getType();
 
       return make_error<ImportError>(ImportError::NameConflict);
     }
@@ -3805,7 +3761,7 @@
     return TypeOrErr.takeError();
 
   auto **NamedChain =
-    new (Importer.getToContext()) NamedDecl*[D->getChainingSize()];
+      new (Importer.getToContext()) NamedDecl *[D->getChainingSize()];
 
   unsigned i = 0;
   for (auto *PI : D->chain())
@@ -3837,15 +3793,15 @@
 
 template <class T>
 static FriendCountAndPosition getFriendCountAndPosition(
-    const FriendDecl *FD,
-    llvm::function_ref<T(const FriendDecl *)> GetCanTypeOrDecl) {
+    FriendDecl const *FD,
+    llvm::function_ref<T(FriendDecl const *)> GetCanTypeOrDecl) {
   unsigned int FriendCount = 0;
   llvm::Optional<unsigned int> FriendPosition;
-  const auto *RD = cast<CXXRecordDecl>(FD->getLexicalDeclContext());
+  auto const *RD = cast<CXXRecordDecl>(FD->getLexicalDeclContext());
 
   T TypeOrDecl = GetCanTypeOrDecl(FD);
 
-  for (const FriendDecl *FoundFriend : RD->friends()) {
+  for (FriendDecl const *FoundFriend : RD->friends()) {
     if (FoundFriend == FD) {
       FriendPosition = FriendCount;
       ++FriendCount;
@@ -3860,15 +3816,15 @@
   return {FriendCount, *FriendPosition};
 }
 
-static FriendCountAndPosition getFriendCountAndPosition(const FriendDecl *FD) {
+static FriendCountAndPosition getFriendCountAndPosition(FriendDecl const *FD) {
   if (FD->getFriendType())
-    return getFriendCountAndPosition<QualType>(FD, [](const FriendDecl *F) {
+    return getFriendCountAndPosition<QualType>(FD, [](FriendDecl const *F) {
       if (TypeSourceInfo *TSI = F->getFriendType())
         return TSI->getType().getCanonicalType();
       llvm_unreachable("Wrong friend object type.");
     });
   else
-    return getFriendCountAndPosition<Decl *>(FD, [](const FriendDecl *F) {
+    return getFriendCountAndPosition<Decl *>(FD, [](FriendDecl const *F) {
       if (Decl *D = F->getFriendDecl())
         return D->getCanonicalDecl();
       llvm_unreachable("Wrong friend object type.");
@@ -3884,7 +3840,7 @@
   // Determine whether we've already imported this decl.
   // FriendDecl is not a NamedDecl so we cannot use lookup.
   // We try to maintain order and count of redundant friend declarations.
-  const auto *RD = cast<CXXRecordDecl>(DC);
+  auto const *RD = cast<CXXRecordDecl>(DC);
   FriendDecl *ImportedFriend = RD->getFirstFriend();
   SmallVector<FriendDecl *, 2> ImportedEquivalentFriends;
 
@@ -3950,8 +3906,7 @@
 
   FriendDecl *FrD;
   if (GetImportedOrCreateDecl(FrD, D, Importer.getToContext(), DC,
-                              *LocationOrErr, ToFU,
-                              *FriendLocOrErr, ToTPLists))
+                              *LocationOrErr, ToFU, *FriendLocOrErr, ToTPLists))
     return FrD;
 
   FrD->setAccess(D->getAccess());
@@ -3982,9 +3937,9 @@
       }
 
       Importer.ToDiag(Loc, diag::warn_odr_ivar_type_inconsistent)
-        << Name << D->getType() << FoundIvar->getType();
+          << Name << D->getType() << FoundIvar->getType();
       Importer.ToDiag(FoundIvar->getLocation(), diag::note_odr_value_here)
-        << FoundIvar->getType();
+          << FoundIvar->getType();
 
       return make_error<ImportError>(ImportError::NameConflict);
     }
@@ -3999,11 +3954,11 @@
     return std::move(Err);
 
   ObjCIvarDecl *ToIvar;
-  if (GetImportedOrCreateDecl(
-          ToIvar, D, Importer.getToContext(), cast<ObjCContainerDecl>(DC),
-          ToInnerLocStart, Loc, Name.getAsIdentifierInfo(),
-          ToType, ToTypeSourceInfo,
-          D->getAccessControl(),ToBitWidth, D->getSynthesize()))
+  if (GetImportedOrCreateDecl(ToIvar, D, Importer.getToContext(),
+                              cast<ObjCContainerDecl>(DC), ToInnerLocStart, Loc,
+                              Name.getAsIdentifierInfo(), ToType,
+                              ToTypeSourceInfo, D->getAccessControl(),
+                              ToBitWidth, D->getSynthesize()))
     return ToIvar;
 
   ToIvar->setLexicalDeclContext(LexicalDC);
@@ -4013,7 +3968,7 @@
 
 ExpectedDecl ASTNodeImporter::VisitVarDecl(VarDecl *D) {
 
-  SmallVector<Decl*, 2> Redecls = getCanonicalForwardRedeclChain(D);
+  SmallVector<Decl *, 2> Redecls = getCanonicalForwardRedeclChain(D);
   auto RedeclIt = Redecls.begin();
   // Import the first part of the decl chain. I.e. import all previous
   // declarations starting from the canonical decl.
@@ -4061,19 +4016,19 @@
 
           // The VarDecl in the "From" context has an initializer, but in the
           // "To" context we already have an initializer.
-          const VarDecl *FoundDInit = nullptr;
+          VarDecl const *FoundDInit = nullptr;
           if (D->getInit() && FoundVar->getAnyInitializer(FoundDInit))
             // FIXME Diagnose ODR error if the two initializers are different?
-            return Importer.MapImported(D, const_cast<VarDecl*>(FoundDInit));
+            return Importer.MapImported(D, const_cast<VarDecl *>(FoundDInit));
 
           FoundByLookup = FoundVar;
           break;
         }
 
-        const ArrayType *FoundArray
-          = Importer.getToContext().getAsArrayType(FoundVar->getType());
-        const ArrayType *TArray
-          = Importer.getToContext().getAsArrayType(D->getType());
+        ArrayType const *FoundArray =
+            Importer.getToContext().getAsArrayType(FoundVar->getType());
+        ArrayType const *TArray =
+            Importer.getToContext().getAsArrayType(D->getType());
         if (FoundArray && TArray) {
           if (isa<IncompleteArrayType>(FoundArray) &&
               isa<ConstantArrayType>(TArray)) {
@@ -4093,9 +4048,9 @@
         }
 
         Importer.ToDiag(Loc, diag::warn_odr_variable_type_inconsistent)
-          << Name << D->getType() << FoundVar->getType();
+            << Name << D->getType() << FoundVar->getType();
         Importer.ToDiag(FoundVar->getLocation(), diag::note_odr_value_here)
-          << FoundVar->getType();
+            << FoundVar->getType();
         ConflictingDecls.push_back(FoundDecl);
       }
     }
@@ -4196,7 +4151,7 @@
 }
 
 Error ASTNodeImporter::ImportDefaultArgOfParmVarDecl(
-    const ParmVarDecl *FromParam, ParmVarDecl *ToParam) {
+    ParmVarDecl const *FromParam, ParmVarDecl *ToParam) {
   ToParam->setHasInheritedDefaultArg(FromParam->hasInheritedDefaultArg());
   ToParam->setKNRPromoted(FromParam->isKNRPromoted());
 
@@ -4276,12 +4231,13 @@
       // Check return types.
       if (!Importer.IsStructurallyEquivalent(D->getReturnType(),
                                              FoundMethod->getReturnType())) {
-        Importer.ToDiag(Loc, diag::warn_odr_objc_method_result_type_inconsistent)
+        Importer.ToDiag(Loc,
+                        diag::warn_odr_objc_method_result_type_inconsistent)
             << D->isInstanceMethod() << Name << D->getReturnType()
             << FoundMethod->getReturnType();
         Importer.ToDiag(FoundMethod->getLocation(),
                         diag::note_odr_objc_method_here)
-          << D->isInstanceMethod() << Name;
+            << D->isInstanceMethod() << Name;
 
         return make_error<ImportError>(ImportError::NameConflict);
       }
@@ -4289,27 +4245,28 @@
       // Check the number of parameters.
       if (D->param_size() != FoundMethod->param_size()) {
         Importer.ToDiag(Loc, diag::warn_odr_objc_method_num_params_inconsistent)
-          << D->isInstanceMethod() << Name
-          << D->param_size() << FoundMethod->param_size();
+            << D->isInstanceMethod() << Name << D->param_size()
+            << FoundMethod->param_size();
         Importer.ToDiag(FoundMethod->getLocation(),
                         diag::note_odr_objc_method_here)
-          << D->isInstanceMethod() << Name;
+            << D->isInstanceMethod() << Name;
 
         return make_error<ImportError>(ImportError::NameConflict);
       }
 
       // Check parameter types.
       for (ObjCMethodDecl::param_iterator P = D->param_begin(),
-             PEnd = D->param_end(), FoundP = FoundMethod->param_begin();
+                                          PEnd = D->param_end(),
+                                          FoundP = FoundMethod->param_begin();
            P != PEnd; ++P, ++FoundP) {
         if (!Importer.IsStructurallyEquivalent((*P)->getType(),
                                                (*FoundP)->getType())) {
           Importer.FromDiag((*P)->getLocation(),
                             diag::warn_odr_objc_method_param_type_inconsistent)
-            << D->isInstanceMethod() << Name
-            << (*P)->getType() << (*FoundP)->getType();
+              << D->isInstanceMethod() << Name << (*P)->getType()
+              << (*FoundP)->getType();
           Importer.ToDiag((*FoundP)->getLocation(), diag::note_odr_value_here)
-            << (*FoundP)->getType();
+              << (*FoundP)->getType();
 
           return make_error<ImportError>(ImportError::NameConflict);
         }
@@ -4319,10 +4276,10 @@
       // Check the number of parameters.
       if (D->isVariadic() != FoundMethod->isVariadic()) {
         Importer.ToDiag(Loc, diag::warn_odr_objc_method_variadic_inconsistent)
-          << D->isInstanceMethod() << Name;
+            << D->isInstanceMethod() << Name;
         Importer.ToDiag(FoundMethod->getLocation(),
                         diag::note_odr_objc_method_here)
-          << D->isInstanceMethod() << Name;
+            << D->isInstanceMethod() << Name;
 
         return make_error<ImportError>(ImportError::NameConflict);
       }
@@ -4408,11 +4365,10 @@
     return std::move(Err);
 
   ObjCTypeParamDecl *Result;
-  if (GetImportedOrCreateDecl(
-          Result, D, Importer.getToContext(), DC, D->getVariance(),
-          ToVarianceLoc, D->getIndex(),
-          ToLocation, Name.getAsIdentifierInfo(),
-          ToColonLoc, ToTypeSourceInfo))
+  if (GetImportedOrCreateDecl(Result, D, Importer.getToContext(), DC,
+                              D->getVariance(), ToVarianceLoc, D->getIndex(),
+                              ToLocation, Name.getAsIdentifierInfo(),
+                              ToColonLoc, ToTypeSourceInfo))
     return Result;
 
   Result->setLexicalDeclContext(LexicalDC);
@@ -4435,8 +4391,8 @@
     return std::move(Err);
 
   // Determine if we've already encountered this category.
-  ObjCCategoryDecl *MergeWithCategory
-    = ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
+  ObjCCategoryDecl *MergeWithCategory =
+      ToInterface->FindCategoryDeclaration(Name.getAsIdentifierInfo());
   ObjCCategoryDecl *ToCategory = MergeWithCategory;
   if (!ToCategory) {
 
@@ -4448,13 +4404,10 @@
     if (Err)
       return std::move(Err);
 
-    if (GetImportedOrCreateDecl(ToCategory, D, Importer.getToContext(), DC,
-                                ToAtStartLoc, Loc,
-                                ToCategoryNameLoc,
-                                Name.getAsIdentifierInfo(), ToInterface,
-                                /*TypeParamList=*/nullptr,
-                                ToIvarLBraceLoc,
-                                ToIvarRBraceLoc))
+    if (GetImportedOrCreateDecl(
+            ToCategory, D, Importer.getToContext(), DC, ToAtStartLoc, Loc,
+            ToCategoryNameLoc, Name.getAsIdentifierInfo(), ToInterface,
+            /*TypeParamList=*/nullptr, ToIvarLBraceLoc, ToIvarRBraceLoc))
       return ToCategory;
 
     ToCategory->setLexicalDeclContext(LexicalDC);
@@ -4469,12 +4422,11 @@
     // Import protocols
     SmallVector<ObjCProtocolDecl *, 4> Protocols;
     SmallVector<SourceLocation, 4> ProtocolLocs;
-    ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc
-      = D->protocol_loc_begin();
+    ObjCCategoryDecl::protocol_loc_iterator FromProtoLoc =
+        D->protocol_loc_begin();
     for (ObjCCategoryDecl::protocol_iterator FromProto = D->protocol_begin(),
-                                          FromProtoEnd = D->protocol_end();
-         FromProto != FromProtoEnd;
-         ++FromProto, ++FromProtoLoc) {
+                                             FromProtoEnd = D->protocol_end();
+         FromProto != FromProtoEnd; ++FromProto, ++FromProtoLoc) {
       if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
         Protocols.push_back(*ToProtoOrErr);
       else
@@ -4501,7 +4453,7 @@
   // If we have an implementation, import it as well.
   if (D->getImplementation()) {
     if (Expected<ObjCCategoryImplDecl *> ToImplOrErr =
-        import(D->getImplementation()))
+            import(D->getImplementation()))
       ToCategory->setImplementation(*ToImplOrErr);
     else
       return ToImplOrErr.takeError();
@@ -4510,8 +4462,9 @@
   return ToCategory;
 }
 
-Error ASTNodeImporter::ImportDefinition(
-    ObjCProtocolDecl *From, ObjCProtocolDecl *To, ImportDefinitionKind Kind) {
+Error ASTNodeImporter::ImportDefinition(ObjCProtocolDecl *From,
+                                        ObjCProtocolDecl *To,
+                                        ImportDefinitionKind Kind) {
   if (To->getDefinition()) {
     if (shouldForceImportDeclContext(Kind))
       if (Error Err = ImportDeclContext(From))
@@ -4528,9 +4481,8 @@
   ObjCProtocolDecl::protocol_loc_iterator FromProtoLoc =
       From->protocol_loc_begin();
   for (ObjCProtocolDecl::protocol_iterator FromProto = From->protocol_begin(),
-                                        FromProtoEnd = From->protocol_end();
-       FromProto != FromProtoEnd;
-       ++FromProto, ++FromProtoLoc) {
+                                           FromProtoEnd = From->protocol_end();
+       FromProto != FromProtoEnd; ++FromProto, ++FromProtoLoc) {
     if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
       Protocols.push_back(*ToProtoOrErr);
     else
@@ -4540,12 +4492,11 @@
       ProtocolLocs.push_back(*ToProtoLocOrErr);
     else
       return ToProtoLocOrErr.takeError();
-
   }
 
   // FIXME: If we're merging, make sure that the protocol list is the same.
-  To->setProtocolList(Protocols.data(), Protocols.size(),
-                      ProtocolLocs.data(), Importer.getToContext());
+  To->setProtocolList(Protocols.data(), Protocols.size(), ProtocolLocs.data(),
+                      Importer.getToContext());
 
   if (shouldForceImportDeclContext(Kind)) {
     // Import all of the members of this protocol.
@@ -4628,8 +4579,8 @@
 
   LinkageSpecDecl *ToLinkageSpec;
   if (GetImportedOrCreateDecl(ToLinkageSpec, D, Importer.getToContext(), DC,
-                              *ExternLocOrErr, *LangLocOrErr,
-                              D->getLanguage(), HasBraces))
+                              *ExternLocOrErr, *LangLocOrErr, D->getLanguage(),
+                              HasBraces))
     return ToLinkageSpec;
 
   if (HasBraces) {
@@ -4689,10 +4640,10 @@
   LexicalDC->addDeclInternal(ToUsing);
 
   if (NamedDecl *FromPattern =
-      Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
+          Importer.getFromContext().getInstantiatedFromUsingDecl(D)) {
     if (Expected<NamedDecl *> ToPatternOrErr = import(FromPattern))
-      Importer.getToContext().setInstantiatedFromUsingDecl(
-          ToUsing, *ToPatternOrErr);
+      Importer.getToContext().setInstantiatedFromUsingDecl(ToUsing,
+                                                           *ToPatternOrErr);
     else
       return ToPatternOrErr.takeError();
   }
@@ -4764,7 +4715,7 @@
   ToShadow->setAccess(D->getAccess());
 
   if (UsingShadowDecl *FromPattern =
-      Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
+          Importer.getFromContext().getInstantiatedFromUsingShadowDecl(D)) {
     if (Expected<UsingShadowDecl *> ToPatternOrErr = import(FromPattern))
       Importer.getToContext().setInstantiatedFromUsingShadowDecl(
           ToShadow, *ToPatternOrErr);
@@ -4805,10 +4756,8 @@
 
   UsingDirectiveDecl *ToUsingDir;
   if (GetImportedOrCreateDecl(ToUsingDir, D, Importer.getToContext(), DC,
-                              ToUsingLoc,
-                              ToNamespaceKeyLocation,
-                              ToQualifierLoc,
-                              ToIdentLocation,
+                              ToUsingLoc, ToNamespaceKeyLocation,
+                              ToQualifierLoc, ToIdentLocation,
                               ToNominatedNamespace, *ToComAncestorOrErr))
     return ToUsingDir;
 
@@ -4818,8 +4767,8 @@
   return ToUsingDir;
 }
 
-ExpectedDecl ASTNodeImporter::VisitUnresolvedUsingValueDecl(
-    UnresolvedUsingValueDecl *D) {
+ExpectedDecl
+ASTNodeImporter::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
   DeclContext *DC, *LexicalDC;
   DeclarationName Name;
   SourceLocation Loc;
@@ -4875,8 +4824,8 @@
 
   UnresolvedUsingTypenameDecl *ToUsing;
   if (GetImportedOrCreateDecl(ToUsing, D, Importer.getToContext(), DC,
-                              ToUsingLoc, ToTypenameLoc,
-                              ToQualifierLoc, Loc, Name, ToEllipsisLoc))
+                              ToUsingLoc, ToTypenameLoc, ToQualifierLoc, Loc,
+                              Name, ToEllipsisLoc))
     return ToUsing;
 
   ToUsing->setAccess(D->getAccess());
@@ -4887,7 +4836,7 @@
 }
 
 ExpectedDecl ASTNodeImporter::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
-  Decl* ToD = nullptr;
+  Decl *ToD = nullptr;
   switch (D->getBuiltinTemplateKind()) {
   case BuiltinTemplateKind::BTK__make_integer_seq:
     ToD = Importer.getToContext().getMakeIntegerSeqDecl();
@@ -4901,8 +4850,9 @@
   return ToD;
 }
 
-Error ASTNodeImporter::ImportDefinition(
-    ObjCInterfaceDecl *From, ObjCInterfaceDecl *To, ImportDefinitionKind Kind) {
+Error ASTNodeImporter::ImportDefinition(ObjCInterfaceDecl *From,
+                                        ObjCInterfaceDecl *To,
+                                        ImportDefinitionKind Kind) {
   if (To->getDefinition()) {
     // Check consistency of superclass.
     ObjCInterfaceDecl *FromSuper = From->getSuperClass();
@@ -4918,17 +4868,17 @@
         (FromSuper && !declaresSameEntity(FromSuper, ToSuper))) {
       Importer.ToDiag(To->getLocation(),
                       diag::warn_odr_objc_superclass_inconsistent)
-        << To->getDeclName();
+          << To->getDeclName();
       if (ToSuper)
         Importer.ToDiag(To->getSuperClassLoc(), diag::note_odr_objc_superclass)
-          << To->getSuperClass()->getDeclName();
+            << To->getSuperClass()->getDeclName();
       else
         Importer.ToDiag(To->getLocation(),
                         diag::note_odr_objc_missing_superclass);
       if (From->getSuperClass())
         Importer.FromDiag(From->getSuperClassLoc(),
                           diag::note_odr_objc_superclass)
-        << From->getSuperClass()->getDeclName();
+            << From->getSuperClass()->getDeclName();
       else
         Importer.FromDiag(From->getLocation(),
                           diag::note_odr_objc_missing_superclass);
@@ -4958,9 +4908,8 @@
       From->protocol_loc_begin();
 
   for (ObjCInterfaceDecl::protocol_iterator FromProto = From->protocol_begin(),
-                                         FromProtoEnd = From->protocol_end();
-       FromProto != FromProtoEnd;
-       ++FromProto, ++FromProtoLoc) {
+                                            FromProtoEnd = From->protocol_end();
+       FromProto != FromProtoEnd; ++FromProto, ++FromProtoLoc) {
     if (Expected<ObjCProtocolDecl *> ToProtoOrErr = import(*FromProto))
       Protocols.push_back(*ToProtoOrErr);
     else
@@ -4970,12 +4919,11 @@
       ProtocolLocs.push_back(*ToProtoLocOrErr);
     else
       return ToProtoLocOrErr.takeError();
-
   }
 
   // FIXME: If we're merging, make sure that the protocol list is the same.
-  To->setProtocolList(Protocols.data(), Protocols.size(),
-                      ProtocolLocs.data(), Importer.getToContext());
+  To->setProtocolList(Protocols.data(), Protocols.size(), ProtocolLocs.data(),
+                      Importer.getToContext());
 
   // Import categories. When the categories themselves are imported, they'll
   // hook themselves into this interface.
@@ -4988,7 +4936,7 @@
   // If we have an @implementation, import it as well.
   if (From->getImplementation()) {
     if (Expected<ObjCImplementationDecl *> ToImplOrErr =
-        import(From->getImplementation()))
+            import(From->getImplementation()))
       To->setImplementation(*ToImplOrErr);
     else
       return ToImplOrErr.takeError();
@@ -5022,10 +4970,8 @@
   if (!RAngleLocOrErr)
     return RAngleLocOrErr.takeError();
 
-  return ObjCTypeParamList::create(Importer.getToContext(),
-                                   *LAngleLocOrErr,
-                                   toTypeParams,
-                                   *RAngleLocOrErr);
+  return ObjCTypeParamList::create(Importer.getToContext(), *LAngleLocOrErr,
+                                   toTypeParams, *RAngleLocOrErr);
 }
 
 ExpectedDecl ASTNodeImporter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
@@ -5068,11 +5014,11 @@
     if (!AtBeginLocOrErr)
       return AtBeginLocOrErr.takeError();
 
-    if (GetImportedOrCreateDecl(
-            ToIface, D, Importer.getToContext(), DC,
-            *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
-            /*TypeParamList=*/nullptr,
-            /*PrevDecl=*/nullptr, Loc, D->isImplicitInterfaceDecl()))
+    if (GetImportedOrCreateDecl(ToIface, D, Importer.getToContext(), DC,
+                                *AtBeginLocOrErr, Name.getAsIdentifierInfo(),
+                                /*TypeParamList=*/nullptr,
+                                /*PrevDecl=*/nullptr, Loc,
+                                D->isImplicitInterfaceDecl()))
       return ToIface;
     ToIface->setLexicalDeclContext(LexicalDC);
     LexicalDC->addDeclInternal(ToIface);
@@ -5081,7 +5027,7 @@
   // Import the type parameter list after MapImported, to avoid
   // loops when bringing in their DeclContext.
   if (auto ToPListOrErr =
-      ImportObjCTypeParamList(D->getTypeParamListAsWritten()))
+          ImportObjCTypeParamList(D->getTypeParamListAsWritten()))
     ToIface->setTypeParamList(*ToPListOrErr);
   else
     return ToPListOrErr.takeError();
@@ -5112,10 +5058,10 @@
     if (Err)
       return std::move(Err);
 
-    if (GetImportedOrCreateDecl(
-            ToImpl, D, Importer.getToContext(), DC,
-            Importer.Import(D->getIdentifier()), Category->getClassInterface(),
-            ToLocation, ToAtStartLoc, ToCategoryNameLoc))
+    if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
+                                Importer.Import(D->getIdentifier()),
+                                Category->getClassInterface(), ToLocation,
+                                ToAtStartLoc, ToCategoryNameLoc))
       return ToImpl;
 
     ToImpl->setLexicalDeclContext(LexicalDC);
@@ -5159,13 +5105,9 @@
     if (Err)
       return std::move(Err);
 
-    if (GetImportedOrCreateDecl(Impl, D, Importer.getToContext(),
-                                DC, Iface, Super,
-                                ToLocation,
-                                ToAtStartLoc,
-                                ToSuperClassLoc,
-                                ToIvarLBraceLoc,
-                                ToIvarRBraceLoc))
+    if (GetImportedOrCreateDecl(
+            Impl, D, Importer.getToContext(), DC, Iface, Super, ToLocation,
+            ToAtStartLoc, ToSuperClassLoc, ToIvarLBraceLoc, ToIvarRBraceLoc))
       return Impl;
 
     Impl->setLexicalDeclContext(LexicalDC);
@@ -5184,20 +5126,18 @@
                              Impl->getSuperClass()))) {
       Importer.ToDiag(Impl->getLocation(),
                       diag::warn_odr_objc_superclass_inconsistent)
-        << Iface->getDeclName();
+          << Iface->getDeclName();
       // FIXME: It would be nice to have the location of the superclass
       // below.
       if (Impl->getSuperClass())
-        Importer.ToDiag(Impl->getLocation(),
-                        diag::note_odr_objc_superclass)
-        << Impl->getSuperClass()->getDeclName();
+        Importer.ToDiag(Impl->getLocation(), diag::note_odr_objc_superclass)
+            << Impl->getSuperClass()->getDeclName();
       else
         Importer.ToDiag(Impl->getLocation(),
                         diag::note_odr_objc_missing_superclass);
       if (D->getSuperClass())
-        Importer.FromDiag(D->getLocation(),
-                          diag::note_odr_objc_superclass)
-        << D->getSuperClass()->getDeclName();
+        Importer.FromDiag(D->getLocation(), diag::note_odr_objc_superclass)
+            << D->getSuperClass()->getDeclName();
       else
         Importer.FromDiag(D->getLocation(),
                           diag::note_odr_objc_missing_superclass);
@@ -5237,9 +5177,9 @@
       if (!Importer.IsStructurallyEquivalent(D->getType(),
                                              FoundProp->getType())) {
         Importer.ToDiag(Loc, diag::warn_odr_objc_property_type_inconsistent)
-          << Name << D->getType() << FoundProp->getType();
+            << Name << D->getType() << FoundProp->getType();
         Importer.ToDiag(FoundProp->getLocation(), diag::note_odr_value_here)
-          << FoundProp->getType();
+            << FoundProp->getType();
 
         return make_error<ImportError>(ImportError::NameConflict);
       }
@@ -5262,11 +5202,10 @@
 
   // Create the new property.
   ObjCPropertyDecl *ToProperty;
-  if (GetImportedOrCreateDecl(
-          ToProperty, D, Importer.getToContext(), DC, Loc,
-          Name.getAsIdentifierInfo(), ToAtLoc,
-          ToLParenLoc, ToType,
-          ToTypeSourceInfo, D->getPropertyImplementation()))
+  if (GetImportedOrCreateDecl(ToProperty, D, Importer.getToContext(), DC, Loc,
+                              Name.getAsIdentifierInfo(), ToAtLoc, ToLParenLoc,
+                              ToType, ToTypeSourceInfo,
+                              D->getPropertyImplementation()))
     return ToProperty;
 
   auto ToGetterName = importChecked(Err, D->getGetterName());
@@ -5284,7 +5223,7 @@
 
   ToProperty->setPropertyAttributes(D->getPropertyAttributes());
   ToProperty->setPropertyAttributesAsWritten(
-                                      D->getPropertyAttributesAsWritten());
+      D->getPropertyAttributesAsWritten());
   ToProperty->setGetterName(ToGetterName, ToGetterNameLoc);
   ToProperty->setSetterName(ToSetterName, ToSetterNameLoc);
   ToProperty->setGetterMethodDecl(ToGetterMethodDecl);
@@ -5310,9 +5249,8 @@
   if (Error Err = importInto(Ivar, D->getPropertyIvarDecl()))
     return std::move(Err);
 
-  ObjCPropertyImplDecl *ToImpl
-    = InImpl->FindPropertyImplDecl(Property->getIdentifier(),
-                                   Property->getQueryKind());
+  ObjCPropertyImplDecl *ToImpl = InImpl->FindPropertyImplDecl(
+      Property->getIdentifier(), Property->getQueryKind());
   if (!ToImpl) {
 
     Error Err = Error::success();
@@ -5324,8 +5262,7 @@
       return std::move(Err);
 
     if (GetImportedOrCreateDecl(ToImpl, D, Importer.getToContext(), DC,
-                                ToBeginLoc,
-                                ToLocation, Property,
+                                ToBeginLoc, ToLocation, Property,
                                 D->getPropertyImplementation(), Ivar,
                                 ToPropertyIvarDeclLoc))
       return ToImpl;
@@ -5338,13 +5275,13 @@
     if (D->getPropertyImplementation() != ToImpl->getPropertyImplementation()) {
       Importer.ToDiag(ToImpl->getLocation(),
                       diag::warn_odr_objc_property_impl_kind_inconsistent)
-        << Property->getDeclName()
-        << (ToImpl->getPropertyImplementation()
-                                              == ObjCPropertyImplDecl::Dynamic);
+          << Property->getDeclName()
+          << (ToImpl->getPropertyImplementation() ==
+              ObjCPropertyImplDecl::Dynamic);
       Importer.FromDiag(D->getLocation(),
                         diag::note_odr_objc_property_impl_kind)
-        << D->getPropertyDecl()->getDeclName()
-        << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
+          << D->getPropertyDecl()->getDeclName()
+          << (D->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic);
 
       return make_error<ImportError>(ImportError::NameConflict);
     }
@@ -5354,12 +5291,12 @@
         Ivar != ToImpl->getPropertyIvarDecl()) {
       Importer.ToDiag(ToImpl->getPropertyIvarDeclLoc(),
                       diag::warn_odr_objc_synthesize_ivar_inconsistent)
-        << Property->getDeclName()
-        << ToImpl->getPropertyIvarDecl()->getDeclName()
-        << Ivar->getDeclName();
+          << Property->getDeclName()
+          << ToImpl->getPropertyIvarDecl()->getDeclName()
+          << Ivar->getDeclName();
       Importer.FromDiag(D->getPropertyIvarDeclLoc(),
                         diag::note_odr_objc_synthesize_ivar_here)
-        << D->getPropertyIvarDecl()->getDeclName();
+          << D->getPropertyIvarDecl()->getDeclName();
 
       return make_error<ImportError>(ImportError::NameConflict);
     }
@@ -5387,16 +5324,15 @@
 
   TemplateTypeParmDecl *ToD = nullptr;
   if (GetImportedOrCreateDecl(
-      ToD, D, Importer.getToContext(),
-      Importer.getToContext().getTranslationUnitDecl(),
-      *BeginLocOrErr, *LocationOrErr,
-      D->getDepth(), D->getIndex(), Importer.Import(D->getIdentifier()),
-      D->wasDeclaredWithTypename(), D->isParameterPack(),
-      D->hasTypeConstraint()))
+          ToD, D, Importer.getToContext(),
+          Importer.getToContext().getTranslationUnitDecl(), *BeginLocOrErr,
+          *LocationOrErr, D->getDepth(), D->getIndex(),
+          Importer.Import(D->getIdentifier()), D->wasDeclaredWithTypename(),
+          D->isParameterPack(), D->hasTypeConstraint()))
     return ToD;
 
   // Import the type-constraint
-  if (const TypeConstraint *TC = D->getTypeConstraint()) {
+  if (TypeConstraint const *TC = D->getTypeConstraint()) {
 
     Error Err = Error::success();
     auto ToNNS = importChecked(Err, TC->getNestedNameSpecifierLoc());
@@ -5409,18 +5345,19 @@
       return std::move(Err);
 
     TemplateArgumentListInfo ToTAInfo;
-    const auto *ASTTemplateArgs = TC->getTemplateArgsAsWritten();
+    auto const *ASTTemplateArgs = TC->getTemplateArgsAsWritten();
     if (ASTTemplateArgs)
-      if (Error Err = ImportTemplateArgumentListInfo(*ASTTemplateArgs,
-                                                     ToTAInfo))
+      if (Error Err =
+              ImportTemplateArgumentListInfo(*ASTTemplateArgs, ToTAInfo))
         return std::move(Err);
 
     ToD->setTypeConstraint(ToNNS, DeclarationNameInfo(ToName, ToNameLoc),
-        ToFoundDecl, ToNamedConcept,
-        ASTTemplateArgs ?
-            ASTTemplateArgumentListInfo::Create(Importer.getToContext(),
-                                                ToTAInfo) : nullptr,
-        ToIDC);
+                           ToFoundDecl, ToNamedConcept,
+                           ASTTemplateArgs
+                               ? ASTTemplateArgumentListInfo::Create(
+                                     Importer.getToContext(), ToTAInfo)
+                               : nullptr,
+                           ToIDC);
   }
 
   if (D->hasDefaultArgument()) {
@@ -5625,7 +5562,7 @@
 }
 
 ExpectedDecl ASTNodeImporter::VisitClassTemplateSpecializationDecl(
-                                          ClassTemplateSpecializationDecl *D) {
+    ClassTemplateSpecializationDecl *D) {
   ClassTemplateDecl *ClassTemplate;
   if (Error Err = importInto(ClassTemplate, D->getSpecializedTemplate()))
     return std::move(Err);
@@ -5637,15 +5574,16 @@
 
   // Import template arguments.
   SmallVector<TemplateArgument, 2> TemplateArgs;
-  if (Error Err = ImportTemplateArguments(
-      D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
+  if (Error Err =
+          ImportTemplateArguments(D->getTemplateArgs().data(),
+                                  D->getTemplateArgs().size(), TemplateArgs))
     return std::move(Err);
   // Try to find an existing specialization with these template arguments and
   // template parameter list.
   void *InsertPos = nullptr;
   ClassTemplateSpecializationDecl *PrevDecl = nullptr;
   ClassTemplatePartialSpecializationDecl *PartialSpec =
-            dyn_cast<ClassTemplatePartialSpecializationDecl>(D);
+      dyn_cast<ClassTemplatePartialSpecializationDecl>(D);
 
   // Import template parameters.
   TemplateParameterList *ToTPList = nullptr;
@@ -5655,9 +5593,8 @@
     if (!ToTPListOrErr)
       return ToTPListOrErr.takeError();
     ToTPList = *ToTPListOrErr;
-    PrevDecl = ClassTemplate->findPartialSpecialization(TemplateArgs,
-                                                        *ToTPListOrErr,
-                                                        InsertPos);
+    PrevDecl = ClassTemplate->findPartialSpecialization(
+        TemplateArgs, *ToTPListOrErr, InsertPos);
   } else
     PrevDecl = ClassTemplate->findSpecialization(TemplateArgs, InsertPos);
 
@@ -5708,19 +5645,19 @@
   if (PartialSpec) {
     // Import TemplateArgumentListInfo.
     TemplateArgumentListInfo ToTAInfo;
-    const auto &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
+    auto const &ASTTemplateArgs = *PartialSpec->getTemplateArgsAsWritten();
     if (Error Err = ImportTemplateArgumentListInfo(ASTTemplateArgs, ToTAInfo))
       return std::move(Err);
 
     QualType CanonInjType;
-    if (Error Err = importInto(
-        CanonInjType, PartialSpec->getInjectedSpecializationType()))
+    if (Error Err = importInto(CanonInjType,
+                               PartialSpec->getInjectedSpecializationType()))
       return std::move(Err);
     CanonInjType = CanonInjType.getCanonicalType();
 
     if (GetImportedOrCreateDecl<ClassTemplatePartialSpecializationDecl>(
-            D2, D, Importer.getToContext(), D->getTagKind(), DC,
-            *BeginLocOrErr, *IdLocOrErr, ToTPList, ClassTemplate,
+            D2, D, Importer.getToContext(), D->getTagKind(), DC, *BeginLocOrErr,
+            *IdLocOrErr, ToTPList, ClassTemplate,
             llvm::makeArrayRef(TemplateArgs.data(), TemplateArgs.size()),
             ToTAInfo, CanonInjType,
             cast_or_null<ClassTemplatePartialSpecializationDecl>(PrevDecl)))
@@ -5736,10 +5673,9 @@
 
     updateLookupTableForTemplateParameters(*ToTPList);
   } else { // Not a partial specialization.
-    if (GetImportedOrCreateDecl(
-            D2, D, Importer.getToContext(), D->getTagKind(), DC,
-            *BeginLocOrErr, *IdLocOrErr, ClassTemplate, TemplateArgs,
-            PrevDecl))
+    if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), D->getTagKind(),
+                                DC, *BeginLocOrErr, *IdLocOrErr, ClassTemplate,
+                                TemplateArgs, PrevDecl))
       return D2;
 
     // Update InsertPos, because preceding import calls may have invalidated
@@ -5940,14 +5876,15 @@
 
   // Import template arguments.
   SmallVector<TemplateArgument, 2> TemplateArgs;
-  if (Error Err = ImportTemplateArguments(
-      D->getTemplateArgs().data(), D->getTemplateArgs().size(), TemplateArgs))
+  if (Error Err =
+          ImportTemplateArguments(D->getTemplateArgs().data(),
+                                  D->getTemplateArgs().size(), TemplateArgs))
     return std::move(Err);
 
   // Try to find an existing specialization with these template arguments.
   void *InsertPos = nullptr;
-  VarTemplateSpecializationDecl *D2 = VarTemplate->findSpecialization(
-      TemplateArgs, InsertPos);
+  VarTemplateSpecializationDecl *D2 =
+      VarTemplate->findSpecialization(TemplateArgs, InsertPos);
   if (D2) {
     // We already have a variable template specialization with these template
     // arguments.
@@ -5974,8 +5911,8 @@
       return TInfoOrErr.takeError();
 
     TemplateArgumentListInfo ToTAInfo;
-    if (Error Err = ImportTemplateArgumentListInfo(
-        D->getTemplateArgsInfo(), ToTAInfo))
+    if (Error Err =
+            ImportTemplateArgumentListInfo(D->getTemplateArgsInfo(), ToTAInfo))
       return std::move(Err);
 
     using PartVarSpecDecl = VarTemplatePartialSpecializationDecl;
@@ -5983,10 +5920,10 @@
     if (auto *FromPartial = dyn_cast<PartVarSpecDecl>(D)) {
       // Import TemplateArgumentListInfo
       TemplateArgumentListInfo ArgInfos;
-      const auto *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
+      auto const *FromTAArgsAsWritten = FromPartial->getTemplateArgsAsWritten();
       // NOTE: FromTAArgsAsWritten and template parameter list are non-null.
-      if (Error Err = ImportTemplateArgumentListInfo(
-          *FromTAArgsAsWritten, ArgInfos))
+      if (Error Err =
+              ImportTemplateArgumentListInfo(*FromTAArgsAsWritten, ArgInfos))
         return std::move(Err);
 
       auto ToTPListOrErr = import(FromPartial->getTemplateParameters());
@@ -6000,8 +5937,8 @@
                                   D->getStorageClass(), TemplateArgs, ArgInfos))
         return ToPartial;
 
-      if (Expected<PartVarSpecDecl *> ToInstOrErr = import(
-          FromPartial->getInstantiatedFromMember()))
+      if (Expected<PartVarSpecDecl *> ToInstOrErr =
+              import(FromPartial->getInstantiatedFromMember()))
         ToPartial->setInstantiatedFromMember(*ToInstOrErr);
       else
         return ToInstOrErr.takeError();
@@ -6015,10 +5952,9 @@
       // to adopt template parameters.
       // updateLookupTableForTemplateParameters(**ToTPListOrErr);
     } else { // Full specialization
-      if (GetImportedOrCreateDecl(D2, D, Importer.getToContext(), DC,
-                                  *BeginLocOrErr, *IdLocOrErr, VarTemplate,
-                                  T, *TInfoOrErr,
-                                  D->getStorageClass(), TemplateArgs))
+      if (GetImportedOrCreateDecl(
+              D2, D, Importer.getToContext(), DC, *BeginLocOrErr, *IdLocOrErr,
+              VarTemplate, T, *TInfoOrErr, D->getStorageClass(), TemplateArgs))
         return D2;
     }
 
@@ -6070,7 +6006,7 @@
   if (ToD)
     return ToD;
 
-  const FunctionTemplateDecl *FoundByLookup = nullptr;
+  FunctionTemplateDecl const *FoundByLookup = nullptr;
 
   // Try to find a function in our own ("to") context with the same name, same
   // type, and in the same context as the function we're importing.
@@ -6162,7 +6098,6 @@
   return make_error<ImportError>(ImportError::UnsupportedConstruct);
 }
 
-
 ExpectedStmt ASTNodeImporter::VisitGCCAsmStmt(GCCAsmStmt *S) {
   if (Importer.returnWithErrorInTest())
     return make_error<ImportError>(ImportError::UnsupportedConstruct);
@@ -6187,7 +6122,6 @@
       Clobbers.push_back(*ClobberOrErr);
     else
       return ClobberOrErr.takeError();
-
   }
 
   SmallVector<StringLiteral *, 4> Constraints;
@@ -6229,20 +6163,10 @@
     return RParenLocOrErr.takeError();
 
   return new (Importer.getToContext()) GCCAsmStmt(
-      Importer.getToContext(),
-      *AsmLocOrErr,
-      S->isSimple(),
-      S->isVolatile(),
-      S->getNumOutputs(),
-      S->getNumInputs(),
-      Names.data(),
-      Constraints.data(),
-      Exprs.data(),
-      *AsmStrOrErr,
-      S->getNumClobbers(),
-      Clobbers.data(),
-      S->getNumLabels(),
-      *RParenLocOrErr);
+      Importer.getToContext(), *AsmLocOrErr, S->isSimple(), S->isVolatile(),
+      S->getNumOutputs(), S->getNumInputs(), Names.data(), Constraints.data(),
+      Exprs.data(), *AsmStrOrErr, S->getNumClobbers(), Clobbers.data(),
+      S->getNumLabels(), *RParenLocOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitDeclStmt(DeclStmt *S) {
@@ -6260,8 +6184,8 @@
   ExpectedSLoc ToSemiLocOrErr = import(S->getSemiLoc());
   if (!ToSemiLocOrErr)
     return ToSemiLocOrErr.takeError();
-  return new (Importer.getToContext()) NullStmt(
-      *ToSemiLocOrErr, S->hasLeadingEmptyMacro());
+  return new (Importer.getToContext())
+      NullStmt(*ToSemiLocOrErr, S->hasLeadingEmptyMacro());
 }
 
 ExpectedStmt ASTNodeImporter::VisitCompoundStmt(CompoundStmt *S) {
@@ -6278,9 +6202,8 @@
   if (!ToRBracLocOrErr)
     return ToRBracLocOrErr.takeError();
 
-  return CompoundStmt::Create(
-      Importer.getToContext(), ToStmts,
-      *ToLBracLocOrErr, *ToRBracLocOrErr);
+  return CompoundStmt::Create(Importer.getToContext(), ToStmts,
+                              *ToLBracLocOrErr, *ToRBracLocOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCaseStmt(CaseStmt *S) {
@@ -6311,8 +6234,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) DefaultStmt(
-    ToDefaultLoc, ToColonLoc, ToSubStmt);
+  return new (Importer.getToContext())
+      DefaultStmt(ToDefaultLoc, ToColonLoc, ToSubStmt);
 }
 
 ExpectedStmt ASTNodeImporter::VisitLabelStmt(LabelStmt *S) {
@@ -6324,24 +6247,24 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) LabelStmt(
-      ToIdentLoc, ToLabelDecl, ToSubStmt);
+  return new (Importer.getToContext())
+      LabelStmt(ToIdentLoc, ToLabelDecl, ToSubStmt);
 }
 
 ExpectedStmt ASTNodeImporter::VisitAttributedStmt(AttributedStmt *S) {
   ExpectedSLoc ToAttrLocOrErr = import(S->getAttrLoc());
   if (!ToAttrLocOrErr)
     return ToAttrLocOrErr.takeError();
-  ArrayRef<const Attr*> FromAttrs(S->getAttrs());
-  SmallVector<const Attr *, 1> ToAttrs(FromAttrs.size());
+  ArrayRef<Attr const *> FromAttrs(S->getAttrs());
+  SmallVector<Attr const *, 1> ToAttrs(FromAttrs.size());
   if (Error Err = ImportContainerChecked(FromAttrs, ToAttrs))
     return std::move(Err);
   ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
   if (!ToSubStmtOrErr)
     return ToSubStmtOrErr.takeError();
 
-  return AttributedStmt::Create(
-      Importer.getToContext(), *ToAttrLocOrErr, ToAttrs, *ToSubStmtOrErr);
+  return AttributedStmt::Create(Importer.getToContext(), *ToAttrLocOrErr,
+                                ToAttrs, *ToSubStmtOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) {
@@ -6427,8 +6350,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) DoStmt(
-      ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
+  return new (Importer.getToContext())
+      DoStmt(ToBody, ToCond, ToDoLoc, ToWhileLoc, ToRParenLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitForStmt(ForStmt *S) {
@@ -6445,10 +6368,9 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) ForStmt(
-      Importer.getToContext(),
-      ToInit, ToCond, ToConditionVariable, ToInc, ToBody, ToForLoc, ToLParenLoc,
-      ToRParenLoc);
+  return new (Importer.getToContext())
+      ForStmt(Importer.getToContext(), ToInit, ToCond, ToConditionVariable,
+              ToInc, ToBody, ToForLoc, ToLParenLoc, ToRParenLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitGotoStmt(GotoStmt *S) {
@@ -6460,8 +6382,7 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) GotoStmt(
-      ToLabel, ToGotoLoc, ToLabelLoc);
+  return new (Importer.getToContext()) GotoStmt(ToLabel, ToGotoLoc, ToLabelLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
@@ -6473,8 +6394,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) IndirectGotoStmt(
-      ToGotoLoc, ToStarLoc, ToTarget);
+  return new (Importer.getToContext())
+      IndirectGotoStmt(ToGotoLoc, ToStarLoc, ToTarget);
 }
 
 ExpectedStmt ASTNodeImporter::VisitContinueStmt(ContinueStmt *S) {
@@ -6513,8 +6434,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) CXXCatchStmt (
-      ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
+  return new (Importer.getToContext())
+      CXXCatchStmt(ToCatchLoc, ToExceptionDecl, ToHandlerBlock);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXTryStmt(CXXTryStmt *S) {
@@ -6535,8 +6456,8 @@
       return ToHandlerOrErr.takeError();
   }
 
-  return CXXTryStmt::Create(
-      Importer.getToContext(), *ToTryLocOrErr,*ToTryBlockOrErr, ToHandlers);
+  return CXXTryStmt::Create(Importer.getToContext(), *ToTryLocOrErr,
+                            *ToTryBlockOrErr, ToHandlers);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
@@ -6573,11 +6494,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) ObjCForCollectionStmt(ToElement,
-                                                             ToCollection,
-                                                             ToBody,
-                                                             ToForLoc,
-                                                             ToRParenLoc);
+  return new (Importer.getToContext()) ObjCForCollectionStmt(
+      ToElement, ToCollection, ToBody, ToForLoc, ToRParenLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
@@ -6590,8 +6508,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) ObjCAtCatchStmt (
-      ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
+  return new (Importer.getToContext())
+      ObjCAtCatchStmt(ToAtCatchLoc, ToRParenLoc, ToCatchParamDecl, ToCatchBody);
 }
 
 ExpectedStmt ASTNodeImporter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
@@ -6601,8 +6519,8 @@
   ExpectedStmt ToAtFinallyStmtOrErr = import(S->getFinallyBody());
   if (!ToAtFinallyStmtOrErr)
     return ToAtFinallyStmtOrErr.takeError();
-  return new (Importer.getToContext()) ObjCAtFinallyStmt(*ToAtFinallyLocOrErr,
-                                                         *ToAtFinallyStmtOrErr);
+  return new (Importer.getToContext())
+      ObjCAtFinallyStmt(*ToAtFinallyLocOrErr, *ToAtFinallyStmtOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
@@ -6623,8 +6541,7 @@
       return ToCatchStmtOrErr.takeError();
   }
 
-  return ObjCAtTryStmt::Create(Importer.getToContext(),
-                               ToAtTryLoc, ToTryBody,
+  return ObjCAtTryStmt::Create(Importer.getToContext(), ToAtTryLoc, ToTryBody,
                                ToCatchStmts.begin(), ToCatchStmts.size(),
                                ToFinallyStmt);
 }
@@ -6639,8 +6556,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) ObjCAtSynchronizedStmt(
-    ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
+  return new (Importer.getToContext())
+      ObjCAtSynchronizedStmt(ToAtSynchronizedLoc, ToSynchExpr, ToSynchBody);
 }
 
 ExpectedStmt ASTNodeImporter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
@@ -6650,20 +6567,20 @@
   ExpectedExpr ToThrowExprOrErr = import(S->getThrowExpr());
   if (!ToThrowExprOrErr)
     return ToThrowExprOrErr.takeError();
-  return new (Importer.getToContext()) ObjCAtThrowStmt(
-      *ToThrowLocOrErr, *ToThrowExprOrErr);
+  return new (Importer.getToContext())
+      ObjCAtThrowStmt(*ToThrowLocOrErr, *ToThrowExprOrErr);
 }
 
-ExpectedStmt ASTNodeImporter::VisitObjCAutoreleasePoolStmt(
-    ObjCAutoreleasePoolStmt *S) {
+ExpectedStmt
+ASTNodeImporter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
   ExpectedSLoc ToAtLocOrErr = import(S->getAtLoc());
   if (!ToAtLocOrErr)
     return ToAtLocOrErr.takeError();
   ExpectedStmt ToSubStmtOrErr = import(S->getSubStmt());
   if (!ToSubStmtOrErr)
     return ToSubStmtOrErr.takeError();
-  return new (Importer.getToContext()) ObjCAutoreleasePoolStmt(*ToAtLocOrErr,
-                                                               *ToSubStmtOrErr);
+  return new (Importer.getToContext())
+      ObjCAutoreleasePoolStmt(*ToAtLocOrErr, *ToSubStmtOrErr);
 }
 
 //----------------------------------------------------------------------------
@@ -6701,9 +6618,9 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) VAArgExpr(
-      ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
-      E->isMicrosoftABI());
+  return new (Importer.getToContext())
+      VAArgExpr(ToBuiltinLoc, ToSubExpr, ToWrittenTypeInfo, ToRParenLoc, ToType,
+                E->isMicrosoftABI());
 }
 
 ExpectedStmt ASTNodeImporter::VisitChooseExpr(ChooseExpr *E) {
@@ -6752,17 +6669,17 @@
   if (Err)
     return std::move(Err);
 
-  ArrayRef<const TypeSourceInfo *> FromAssocTypes(E->getAssocTypeSourceInfos());
+  ArrayRef<TypeSourceInfo const *> FromAssocTypes(E->getAssocTypeSourceInfos());
   SmallVector<TypeSourceInfo *, 1> ToAssocTypes(FromAssocTypes.size());
   if (Error Err = ImportContainerChecked(FromAssocTypes, ToAssocTypes))
     return std::move(Err);
 
-  ArrayRef<const Expr *> FromAssocExprs(E->getAssocExprs());
+  ArrayRef<Expr const *> FromAssocExprs(E->getAssocExprs());
   SmallVector<Expr *, 1> ToAssocExprs(FromAssocExprs.size());
   if (Error Err = ImportContainerChecked(FromAssocExprs, ToAssocExprs))
     return std::move(Err);
 
-  const ASTContext &ToCtx = Importer.getToContext();
+  ASTContext const &ToCtx = Importer.getToContext();
   if (E->isResultDependent()) {
     return GenericSelectionExpr::Create(
         ToCtx, ToGenericLoc, ToControllingExpr,
@@ -6827,7 +6744,8 @@
   return ToE;
 }
 
-ExpectedStmt ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
+ExpectedStmt
+ASTNodeImporter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
   ExpectedType TypeOrErr = import(E->getType());
   if (!TypeOrErr)
     return TypeOrErr.takeError();
@@ -6857,10 +6775,9 @@
   if (Error Err = ImportContainerChecked(E->designators(), ToDesignators))
     return std::move(Err);
 
-  return DesignatedInitExpr::Create(
-        Importer.getToContext(), ToDesignators,
-        ToIndexExprs, *ToEqualOrColonLocOrErr,
-        E->usesGNUSyntax(), *ToInitOrErr);
+  return DesignatedInitExpr::Create(Importer.getToContext(), ToDesignators,
+                                    ToIndexExprs, *ToEqualOrColonLocOrErr,
+                                    E->usesGNUSyntax(), *ToInitOrErr);
 }
 
 ExpectedStmt
@@ -6873,8 +6790,8 @@
   if (!ToLocationOrErr)
     return ToLocationOrErr.takeError();
 
-  return new (Importer.getToContext()) CXXNullPtrLiteralExpr(
-      *ToTypeOrErr, *ToLocationOrErr);
+  return new (Importer.getToContext())
+      CXXNullPtrLiteralExpr(*ToTypeOrErr, *ToLocationOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitIntegerLiteral(IntegerLiteral *E) {
@@ -6886,11 +6803,10 @@
   if (!ToLocationOrErr)
     return ToLocationOrErr.takeError();
 
-  return IntegerLiteral::Create(
-      Importer.getToContext(), E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
+  return IntegerLiteral::Create(Importer.getToContext(), E->getValue(),
+                                *ToTypeOrErr, *ToLocationOrErr);
 }
 
-
 ExpectedStmt ASTNodeImporter::VisitFloatingLiteral(FloatingLiteral *E) {
   ExpectedType ToTypeOrErr = import(E->getType());
   if (!ToTypeOrErr)
@@ -6900,9 +6816,8 @@
   if (!ToLocationOrErr)
     return ToLocationOrErr.takeError();
 
-  return FloatingLiteral::Create(
-      Importer.getToContext(), E->getValue(), E->isExact(),
-      *ToTypeOrErr, *ToLocationOrErr);
+  return FloatingLiteral::Create(Importer.getToContext(), E->getValue(),
+                                 E->isExact(), *ToTypeOrErr, *ToLocationOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
@@ -6914,8 +6829,8 @@
   if (!ToSubExprOrErr)
     return ToSubExprOrErr.takeError();
 
-  return new (Importer.getToContext()) ImaginaryLiteral(
-      *ToSubExprOrErr, *ToTypeOrErr);
+  return new (Importer.getToContext())
+      ImaginaryLiteral(*ToSubExprOrErr, *ToTypeOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitFixedPointLiteral(FixedPointLiteral *E) {
@@ -6951,13 +6866,13 @@
     return ToTypeOrErr.takeError();
 
   SmallVector<SourceLocation, 4> ToLocations(E->getNumConcatenated());
-  if (Error Err = ImportArrayChecked(
-      E->tokloc_begin(), E->tokloc_end(), ToLocations.begin()))
+  if (Error Err = ImportArrayChecked(E->tokloc_begin(), E->tokloc_end(),
+                                     ToLocations.begin()))
     return std::move(Err);
 
-  return StringLiteral::Create(
-      Importer.getToContext(), E->getBytes(), E->getKind(), E->isPascal(),
-      *ToTypeOrErr, ToLocations.data(), ToLocations.size());
+  return StringLiteral::Create(Importer.getToContext(), E->getBytes(),
+                               E->getKind(), E->isPascal(), *ToTypeOrErr,
+                               ToLocations.data(), ToLocations.size());
 }
 
 ExpectedStmt ASTNodeImporter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
@@ -6970,9 +6885,9 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) CompoundLiteralExpr(
-        ToLParenLoc, ToTypeSourceInfo, ToType, E->getValueKind(),
-        ToInitializer, E->isFileScope());
+  return new (Importer.getToContext())
+      CompoundLiteralExpr(ToLParenLoc, ToTypeSourceInfo, ToType,
+                          E->getValueKind(), ToInitializer, E->isFileScope());
 }
 
 ExpectedStmt ASTNodeImporter::VisitAtomicExpr(AtomicExpr *E) {
@@ -6985,9 +6900,9 @@
     return std::move(Err);
 
   SmallVector<Expr *, 6> ToExprs(E->getNumSubExprs());
-  if (Error Err = ImportArrayChecked(
-      E->getSubExprs(), E->getSubExprs() + E->getNumSubExprs(),
-      ToExprs.begin()))
+  if (Error Err = ImportArrayChecked(E->getSubExprs(),
+                                     E->getSubExprs() + E->getNumSubExprs(),
+                                     ToExprs.begin()))
     return std::move(Err);
 
   return new (Importer.getToContext()) AtomicExpr(
@@ -7004,8 +6919,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) AddrLabelExpr(
-      ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
+  return new (Importer.getToContext())
+      AddrLabelExpr(ToAmpAmpLoc, ToLabelLoc, ToLabel, ToType);
 }
 ExpectedStmt ASTNodeImporter::VisitConstantExpr(ConstantExpr *E) {
   Error Err = Error::success();
@@ -7024,8 +6939,7 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext())
-      ParenExpr(ToLParen, ToRParen, ToSubExpr);
+  return new (Importer.getToContext()) ParenExpr(ToLParen, ToRParen, ToSubExpr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitParenListExpr(ParenListExpr *E) {
@@ -7054,9 +6968,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext())
-      StmtExpr(ToSubStmt, ToType, ToLParenLoc, ToRParenLoc,
-               E->getTemplateDepth());
+  return new (Importer.getToContext()) StmtExpr(
+      ToSubStmt, ToType, ToLParenLoc, ToRParenLoc, E->getTemplateDepth());
 }
 
 ExpectedStmt ASTNodeImporter::VisitUnaryOperator(UnaryOperator *E) {
@@ -7067,10 +6980,10 @@
   if (Err)
     return std::move(Err);
 
-  return UnaryOperator::Create(
-      Importer.getToContext(), ToSubExpr, E->getOpcode(), ToType,
-      E->getValueKind(), E->getObjectKind(), ToOperatorLoc, E->canOverflow(),
-      E->getFPOptionsOverride());
+  return UnaryOperator::Create(Importer.getToContext(), ToSubExpr,
+                               E->getOpcode(), ToType, E->getValueKind(),
+                               E->getObjectKind(), ToOperatorLoc,
+                               E->canOverflow(), E->getFPOptionsOverride());
 }
 
 ExpectedStmt
@@ -7089,9 +7002,9 @@
     if (!ToArgumentTypeInfoOrErr)
       return ToArgumentTypeInfoOrErr.takeError();
 
-    return new (Importer.getToContext()) UnaryExprOrTypeTraitExpr(
-        E->getKind(), *ToArgumentTypeInfoOrErr, ToType, ToOperatorLoc,
-        ToRParenLoc);
+    return new (Importer.getToContext())
+        UnaryExprOrTypeTraitExpr(E->getKind(), *ToArgumentTypeInfoOrErr, ToType,
+                                 ToOperatorLoc, ToRParenLoc);
   }
 
   ExpectedExpr ToArgumentExprOrErr = import(E->getArgumentExpr());
@@ -7128,9 +7041,9 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) ConditionalOperator(
-      ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS, ToType,
-      E->getValueKind(), E->getObjectKind());
+  return new (Importer.getToContext())
+      ConditionalOperator(ToCond, ToQuestionLoc, ToLHS, ToColonLoc, ToRHS,
+                          ToType, E->getValueKind(), E->getObjectKind());
 }
 
 ExpectedStmt
@@ -7148,9 +7061,8 @@
     return std::move(Err);
 
   return new (Importer.getToContext()) BinaryConditionalOperator(
-      ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr,
-      ToQuestionLoc, ToColonLoc, ToType, E->getValueKind(),
-      E->getObjectKind());
+      ToCommon, ToOpaqueValue, ToCond, ToTrueExpr, ToFalseExpr, ToQuestionLoc,
+      ToColonLoc, ToType, E->getValueKind(), E->getObjectKind());
 }
 
 ExpectedStmt ASTNodeImporter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
@@ -7178,9 +7090,9 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) ExpressionTraitExpr(
-      ToBeginLoc, E->getTrait(), ToQueriedExpression, E->getValue(),
-      ToEndLoc, ToType);
+  return new (Importer.getToContext())
+      ExpressionTraitExpr(ToBeginLoc, E->getTrait(), ToQueriedExpression,
+                          E->getValue(), ToEndLoc, ToType);
 }
 
 ExpectedStmt ASTNodeImporter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
@@ -7204,9 +7116,9 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) ArraySubscriptExpr(
-      ToLHS, ToRHS, ToType, E->getValueKind(), E->getObjectKind(),
-      ToRBracketLoc);
+  return new (Importer.getToContext())
+      ArraySubscriptExpr(ToLHS, ToRHS, ToType, E->getValueKind(),
+                         E->getObjectKind(), ToRBracketLoc);
 }
 
 ExpectedStmt
@@ -7229,8 +7141,7 @@
       ToComputationLHSType, ToComputationResultType);
 }
 
-Expected<CXXCastPath>
-ASTNodeImporter::ImportCastPath(CastExpr *CE) {
+Expected<CXXCastPath> ASTNodeImporter::ImportCastPath(CastExpr *CE) {
   CXXCastPath Path;
   for (auto I = CE->path_begin(), E = CE->path_end(); I != E; ++I) {
     if (auto SpecOrErr = import(*I))
@@ -7322,7 +7233,7 @@
 ExpectedStmt ASTNodeImporter::VisitOffsetOfExpr(OffsetOfExpr *E) {
   SmallVector<OffsetOfNode, 4> ToNodes;
   for (int I = 0, N = E->getNumComponents(); I < N; ++I) {
-    const OffsetOfNode &FromNode = E->getComponent(I);
+    OffsetOfNode const &FromNode = E->getComponent(I);
 
     SourceLocation ToBeginLoc, ToEndLoc;
 
@@ -7377,9 +7288,8 @@
   if (Err)
     return std::move(Err);
 
-  return OffsetOfExpr::Create(
-      Importer.getToContext(), ToType, ToOperatorLoc, ToTypeSourceInfo, ToNodes,
-      ToExprs, ToRParenLoc);
+  return OffsetOfExpr::Create(Importer.getToContext(), ToType, ToOperatorLoc,
+                              ToTypeSourceInfo, ToNodes, ToExprs, ToRParenLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
@@ -7397,8 +7307,8 @@
   else
     ToCanThrow = E->getValue() ? CT_Can : CT_Cannot;
 
-  return new (Importer.getToContext()) CXXNoexceptExpr(
-      ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
+  return new (Importer.getToContext())
+      CXXNoexceptExpr(ToType, ToOperand, ToCanThrow, ToBeginLoc, ToEndLoc);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXThrowExpr(CXXThrowExpr *E) {
@@ -7409,8 +7319,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) CXXThrowExpr(
-      ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope());
+  return new (Importer.getToContext())
+      CXXThrowExpr(ToSubExpr, ToType, ToThrowLoc, E->isThrownVariableInScope());
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
@@ -7454,8 +7364,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) CXXScalarValueInitExpr(
-      ToType, ToTypeSourceInfo, ToRParenLoc);
+  return new (Importer.getToContext())
+      CXXScalarValueInitExpr(ToType, ToTypeSourceInfo, ToRParenLoc);
 }
 
 ExpectedStmt
@@ -7566,19 +7476,17 @@
 
   SmallVector<TemplateArgument, 8> ToPartialArguments;
   if (E->isPartiallySubstituted()) {
-    if (Error Err = ImportTemplateArguments(
-        E->getPartialArguments().data(),
-        E->getPartialArguments().size(),
-        ToPartialArguments))
+    if (Error Err = ImportTemplateArguments(E->getPartialArguments().data(),
+                                            E->getPartialArguments().size(),
+                                            ToPartialArguments))
       return std::move(Err);
   }
 
-  return SizeOfPackExpr::Create(
-      Importer.getToContext(), ToOperatorLoc, ToPack, ToPackLoc, ToRParenLoc,
-      Length, ToPartialArguments);
+  return SizeOfPackExpr::Create(Importer.getToContext(), ToOperatorLoc, ToPack,
+                                ToPackLoc, ToRParenLoc, Length,
+                                ToPartialArguments);
 }
 
-
 ExpectedStmt ASTNodeImporter::VisitCXXNewExpr(CXXNewExpr *E) {
   Error Err = Error::success();
   auto ToOperatorNew = importChecked(Err, E->getOperatorNew());
@@ -7596,7 +7504,7 @@
 
   SmallVector<Expr *, 4> ToPlacementArgs(E->getNumPlacementArgs());
   if (Error Err =
-      ImportContainerChecked(E->placement_arguments(), ToPlacementArgs))
+          ImportContainerChecked(E->placement_arguments(), ToPlacementArgs))
     return std::move(Err);
 
   return CXXNewExpr::Create(
@@ -7652,9 +7560,8 @@
   if (Error Err = ImportContainerChecked(E->getObjects(), ToObjects))
     return std::move(Err);
 
-  return ExprWithCleanups::Create(
-      Importer.getToContext(), *ToSubExprOrErr, E->cleanupsHaveSideEffects(),
-      ToObjects);
+  return ExprWithCleanups::Create(Importer.getToContext(), *ToSubExprOrErr,
+                                  E->cleanupsHaveSideEffects(), ToObjects);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
@@ -7683,8 +7590,8 @@
   if (!ToLocationOrErr)
     return ToLocationOrErr.takeError();
 
-  return new (Importer.getToContext()) CXXThisExpr(
-      *ToLocationOrErr, *ToTypeOrErr, E->isImplicit());
+  return new (Importer.getToContext())
+      CXXThisExpr(*ToLocationOrErr, *ToTypeOrErr, E->isImplicit());
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
@@ -7696,8 +7603,8 @@
   if (!ToLocationOrErr)
     return ToLocationOrErr.takeError();
 
-  return new (Importer.getToContext()) CXXBoolLiteralExpr(
-      E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
+  return new (Importer.getToContext())
+      CXXBoolLiteralExpr(E->getValue(), *ToTypeOrErr, *ToLocationOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitMemberExpr(MemberExpr *E) {
@@ -7832,14 +7739,14 @@
   TemplateArgumentListInfo *ResInfo = nullptr;
   if (E->hasExplicitTemplateArgs()) {
     if (Error Err =
-        ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
+            ImportTemplateArgumentListInfo(E->template_arguments(), ToTAInfo))
       return std::move(Err);
     ResInfo = &ToTAInfo;
   }
 
-  return DependentScopeDeclRefExpr::Create(
-      Importer.getToContext(), ToQualifierLoc, ToTemplateKeywordLoc,
-      ToNameInfo, ResInfo);
+  return DependentScopeDeclRefExpr::Create(Importer.getToContext(),
+                                           ToQualifierLoc, ToTemplateKeywordLoc,
+                                           ToNameInfo, ResInfo);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXUnresolvedConstructExpr(
@@ -7854,7 +7761,7 @@
 
   SmallVector<Expr *, 8> ToArgs(E->getNumArgs());
   if (Error Err =
-      ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
+          ImportArrayChecked(E->arg_begin(), E->arg_end(), ToArgs.begin()))
     return std::move(Err);
 
   return CXXUnresolvedConstructExpr::Create(
@@ -7892,9 +7799,9 @@
 
   if (E->hasExplicitTemplateArgs()) {
     TemplateArgumentListInfo ToTAInfo;
-    if (Error Err = ImportTemplateArgumentListInfo(
-        E->getLAngleLoc(), E->getRAngleLoc(), E->template_arguments(),
-        ToTAInfo))
+    if (Error Err =
+            ImportTemplateArgumentListInfo(E->getLAngleLoc(), E->getRAngleLoc(),
+                                           E->template_arguments(), ToTAInfo))
       return std::move(Err);
 
     ExpectedSLoc ToTemplateKeywordLocOrErr = import(E->getTemplateKeywordLoc());
@@ -7972,9 +7879,9 @@
   unsigned NumArgs = E->getNumArgs();
   llvm::SmallVector<Expr *, 2> ToArgs(NumArgs);
   if (Error Err = ImportContainerChecked(E->arguments(), ToArgs))
-     return std::move(Err);
+    return std::move(Err);
 
-  if (const auto *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
+  if (auto const *OCE = dyn_cast<CXXOperatorCallExpr>(E)) {
     return CXXOperatorCallExpr::Create(
         Importer.getToContext(), OCE->getOperator(), ToCallee, ToArgs, ToType,
         OCE->getValueKind(), ToRParenLoc, OCE->getFPFeatures(),
@@ -8015,7 +7922,6 @@
                             ToEndLoc, E->containsUnexpandedParameterPack());
 }
 
-
 ExpectedStmt ASTNodeImporter::VisitInitListExpr(InitListExpr *E) {
   Error Err = Error::success();
   auto ToLBraceLoc = importChecked(Err, E->getLBraceLoc());
@@ -8029,8 +7935,8 @@
     return std::move(Err);
 
   ASTContext &ToCtx = Importer.getToContext();
-  InitListExpr *To = new (ToCtx) InitListExpr(
-      ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
+  InitListExpr *To =
+      new (ToCtx) InitListExpr(ToCtx, ToLBraceLoc, ToExprs, ToRBraceLoc);
   To->setType(ToType);
 
   if (E->hasArrayFiller()) {
@@ -8061,8 +7967,8 @@
   return To;
 }
 
-ExpectedStmt ASTNodeImporter::VisitCXXStdInitializerListExpr(
-    CXXStdInitializerListExpr *E) {
+ExpectedStmt
+ASTNodeImporter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
   ExpectedType ToTypeOrErr = import(E->getType());
   if (!ToTypeOrErr)
     return ToTypeOrErr.takeError();
@@ -8071,12 +7977,12 @@
   if (!ToSubExprOrErr)
     return ToSubExprOrErr.takeError();
 
-  return new (Importer.getToContext()) CXXStdInitializerListExpr(
-      *ToTypeOrErr, *ToSubExprOrErr);
+  return new (Importer.getToContext())
+      CXXStdInitializerListExpr(*ToTypeOrErr, *ToSubExprOrErr);
 }
 
-ExpectedStmt ASTNodeImporter::VisitCXXInheritedCtorInitExpr(
-    CXXInheritedCtorInitExpr *E) {
+ExpectedStmt
+ASTNodeImporter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
   Error Err = Error::success();
   auto ToLocation = importChecked(Err, E->getLocation());
   auto ToType = importChecked(Err, E->getType());
@@ -8084,9 +7990,9 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) CXXInheritedCtorInitExpr(
-      ToLocation, ToType, ToConstructor, E->constructsVBase(),
-      E->inheritedFromVBase());
+  return new (Importer.getToContext())
+      CXXInheritedCtorInitExpr(ToLocation, ToType, ToConstructor,
+                               E->constructsVBase(), E->inheritedFromVBase());
 }
 
 ExpectedStmt ASTNodeImporter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
@@ -8097,8 +8003,8 @@
   if (Err)
     return std::move(Err);
 
-  return new (Importer.getToContext()) ArrayInitLoopExpr(
-      ToType, ToCommonExpr, ToSubExpr);
+  return new (Importer.getToContext())
+      ArrayInitLoopExpr(ToType, ToCommonExpr, ToSubExpr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
@@ -8121,8 +8027,8 @@
   if (!UsedContextOrErr)
     return UsedContextOrErr.takeError();
 
-  return CXXDefaultInitExpr::Create(
-      Importer.getToContext(), *ToBeginLocOrErr, *ToFieldOrErr, *UsedContextOrErr);
+  return CXXDefaultInitExpr::Create(Importer.getToContext(), *ToBeginLocOrErr,
+                                    *ToFieldOrErr, *UsedContextOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
@@ -8196,9 +8102,8 @@
   // Value is always false.
   bool ToValue = (E->isValueDependent() ? false : E->getValue());
 
-  return TypeTraitExpr::Create(
-      Importer.getToContext(), ToType, ToBeginLoc, E->getTrait(), ToArgs,
-      ToEndLoc, ToValue);
+  return TypeTraitExpr::Create(Importer.getToContext(), ToType, ToBeginLoc,
+                               E->getTrait(), ToArgs, ToEndLoc, ToValue);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
@@ -8212,8 +8117,8 @@
 
   if (E->isTypeOperand()) {
     if (auto ToTSIOrErr = import(E->getTypeOperandSourceInfo()))
-      return new (Importer.getToContext()) CXXTypeidExpr(
-          *ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
+      return new (Importer.getToContext())
+          CXXTypeidExpr(*ToTypeOrErr, *ToTSIOrErr, *ToSourceRangeOrErr);
     else
       return ToTSIOrErr.takeError();
   }
@@ -8222,8 +8127,8 @@
   if (!ToExprOperandOrErr)
     return ToExprOperandOrErr.takeError();
 
-  return new (Importer.getToContext()) CXXTypeidExpr(
-      *ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
+  return new (Importer.getToContext())
+      CXXTypeidExpr(*ToTypeOrErr, *ToExprOperandOrErr, *ToSourceRangeOrErr);
 }
 
 ExpectedStmt ASTNodeImporter::VisitCXXFoldExpr(CXXFoldExpr *E) {
@@ -8250,8 +8155,8 @@
   Error ImportErrors = Error::success();
   for (auto *FromOverriddenMethod : FromMethod->overridden_methods()) {
     if (auto ImportedOrErr = import(FromOverriddenMethod))
-      ToMethod->getCanonicalDecl()->addOverriddenMethod(cast<CXXMethodDecl>(
-          (*ImportedOrErr)->getCanonicalDecl()));
+      ToMethod->getCanonicalDecl()->addOverriddenMethod(
+          cast<CXXMethodDecl>((*ImportedOrErr)->getCanonicalDecl()));
     else
       ImportErrors =
           joinErrors(std::move(ImportErrors), ImportedOrErr.takeError());
@@ -8280,14 +8185,14 @@
 
 Optional<unsigned> ASTImporter::getFieldIndex(Decl *F) {
   assert(F && (isa<FieldDecl>(*F) || isa<IndirectFieldDecl>(*F)) &&
-      "Try to get field index for non-field.");
+         "Try to get field index for non-field.");
 
   auto *Owner = dyn_cast<RecordDecl>(F->getDeclContext());
   if (!Owner)
     return None;
 
   unsigned Index = 0;
-  for (const auto *D : Owner->decls()) {
+  for (auto const *D : Owner->decls()) {
     if (D == F)
       return Index;
 
@@ -8300,8 +8205,8 @@
   return None;
 }
 
-ASTImporter::FoundDeclsTy
-ASTImporter::findDeclsInToCtx(DeclContext *DC, DeclarationName Name) {
+ASTImporter::FoundDeclsTy ASTImporter::findDeclsInToCtx(DeclContext *DC,
+                                                        DeclarationName Name) {
   // We search in the redecl context because of transparent contexts.
   // E.g. a simple C language enum is a transparent context:
   //   enum E { A, B };
@@ -8359,12 +8264,12 @@
   return make_error<ImportError>(ImportError::UnsupportedConstruct);
 }
 
-Expected<const Type *> ASTImporter::Import(const Type *FromT) {
+Expected<Type const *> ASTImporter::Import(Type const *FromT) {
   if (!FromT)
     return FromT;
 
   // Check whether we've already imported this type.
-  llvm::DenseMap<const Type *, const Type *>::iterator Pos =
+  llvm::DenseMap<Type const *, Type const *>::iterator Pos =
       ImportedTypes.find(FromT);
   if (Pos != ImportedTypes.end())
     return Pos->second;
@@ -8385,7 +8290,7 @@
   if (FromT.isNull())
     return QualType{};
 
-  Expected<const Type *> ToTyOrErr = Import(FromT.getTypePtr());
+  Expected<Type const *> ToTyOrErr = Import(FromT.getTypePtr());
   if (!ToTyOrErr)
     return ToTyOrErr.takeError();
 
@@ -8408,7 +8313,7 @@
   return ToContext.getTrivialTypeSourceInfo(*TOrErr, *BeginLocOrErr);
 }
 
-Expected<Attr *> ASTImporter::Import(const Attr *FromAttr) {
+Expected<Attr *> ASTImporter::Import(Attr const *FromAttr) {
   Attr *ToAttr = nullptr;
   SourceRange ToRange;
   if (Error Err = importInto(ToRange, FromAttr->getRange()))
@@ -8442,7 +8347,7 @@
     break;
   }
   case attr::Format: {
-    const auto *From = cast<FormatAttr>(FromAttr);
+    auto const *From = cast<FormatAttr>(FromAttr);
     FormatAttr *To;
     IdentifierInfo *ToAttrType = Import(From->getType());
     To = FormatAttr::Create(ToContext, ToAttrType, From->getFormatIdx(),
@@ -8459,11 +8364,11 @@
     break;
   }
   assert(ToAttr && "Attribute should be created.");
-  
+
   return ToAttr;
 }
 
-Decl *ASTImporter::GetAlreadyImportedOrNull(const Decl *FromD) const {
+Decl *ASTImporter::GetAlreadyImportedOrNull(Decl const *FromD) const {
   auto Pos = ImportedDecls.find(FromD);
   if (Pos != ImportedDecls.end())
     return Pos->second;
@@ -8552,7 +8457,7 @@
     // Get a copy of the error object (any more simple solution for this?).
     ImportError ErrOut;
     handleAllErrors(ToDOrErr.takeError(),
-                    [&ErrOut](const ImportError &E) { ErrOut = E; });
+                    [&ErrOut](ImportError const &E) { ErrOut = E; });
     setImportDeclError(FromD, ErrOut);
     // Set the error for the mapped to Decl, which is in the "to" context.
     if (Pos != ImportedDecls.end())
@@ -8560,16 +8465,16 @@
 
     // Set the error for all nodes which have been created before we
     // recognized the error.
-    for (const auto &Path : SavedImportPaths[FromD])
+    for (auto const &Path : SavedImportPaths[FromD])
       for (Decl *FromDi : Path) {
         setImportDeclError(FromDi, ErrOut);
-        //FIXME Should we remove these Decls from ImportedDecls?
-        // Set the error for the mapped to Decl, which is in the "to" context.
+        // FIXME Should we remove these Decls from ImportedDecls?
+        //  Set the error for the mapped to Decl, which is in the "to" context.
         auto Ii = ImportedDecls.find(FromDi);
         if (Ii != ImportedDecls.end())
           SharedState->setImportDeclError(Ii->second, ErrOut);
-          // FIXME Should we remove these Decls from the LookupTable,
-          // and from ImportedFromDecls?
+        // FIXME Should we remove these Decls from the LookupTable,
+        // and from ImportedFromDecls?
       }
     SavedImportPaths.erase(FromD);
 
@@ -8601,7 +8506,7 @@
   assert(ImportedDecls.count(FromD) != 0 && "Missing call to MapImported?");
 
   if (FromD->hasAttrs())
-    for (const Attr *FromAttr : FromD->getAttrs()) {
+    for (Attr const *FromAttr : FromD->getAttrs()) {
       auto ToAttrOrErr = Import(FromAttr);
       if (ToAttrOrErr)
         ToD->addAttr(*ToAttrOrErr);
@@ -8644,7 +8549,7 @@
 
     if (FromRecord->isCompleteDefinition())
       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
-          FromRecord, ToRecord, ASTNodeImporter::IDK_Basic))
+              FromRecord, ToRecord, ASTNodeImporter::IDK_Basic))
         return std::move(Err);
   } else if (auto *ToEnum = dyn_cast<EnumDecl>(ToDC)) {
     auto *FromEnum = cast<EnumDecl>(FromDC);
@@ -8652,7 +8557,7 @@
       // Do nothing.
     } else if (FromEnum->isCompleteDefinition()) {
       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
-          FromEnum, ToEnum, ASTNodeImporter::IDK_Basic))
+              FromEnum, ToEnum, ASTNodeImporter::IDK_Basic))
         return std::move(Err);
     } else {
       CompleteDecl(ToEnum);
@@ -8663,7 +8568,7 @@
       // Do nothing.
     } else if (ObjCInterfaceDecl *FromDef = FromClass->getDefinition()) {
       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
-          FromDef, ToClass, ASTNodeImporter::IDK_Basic))
+              FromDef, ToClass, ASTNodeImporter::IDK_Basic))
         return std::move(Err);
     } else {
       CompleteDecl(ToClass);
@@ -8674,7 +8579,7 @@
       // Do nothing.
     } else if (ObjCProtocolDecl *FromDef = FromProto->getDefinition()) {
       if (Error Err = ASTNodeImporter(*this).ImportDefinition(
-          FromDef, ToProto, ASTNodeImporter::IDK_Basic))
+              FromDef, ToProto, ASTNodeImporter::IDK_Basic))
         return std::move(Err);
     } else {
       CompleteDecl(ToProto);
@@ -8778,7 +8683,7 @@
 Expected<NestedNameSpecifierLoc>
 ASTImporter::Import(NestedNameSpecifierLoc FromNNS) {
   // Copied from NestedNameSpecifier mostly.
-  SmallVector<NestedNameSpecifierLoc , 8> NestedNames;
+  SmallVector<NestedNameSpecifierLoc, 8> NestedNames;
   NestedNameSpecifierLoc NNS = FromNNS;
 
   // Push each of the nested-name-specifiers's onto a stack for
@@ -8830,7 +8735,7 @@
       if (Error Err = importInto(ToTLoc, NNS.getTypeLoc().getBeginLoc()))
         return std::move(Err);
       TypeSourceInfo *TSI = getToContext().getTrivialTypeSourceInfo(
-            QualType(Spec->getAsType(), 0), ToTLoc);
+          QualType(Spec->getAsType(), 0), ToTLoc);
       if (Kind == NestedNameSpecifier::TypeSpecWithTemplate)
         // ToLocalBeginLoc is here the location of the 'template' keyword.
         Builder.Extend(getToContext(), ToLocalBeginLoc, TSI->getTypeLoc(),
@@ -8855,7 +8760,7 @@
                         ToSourceRangeOrErr->getBegin(),
                         ToSourceRangeOrErr->getEnd());
     }
-  }
+    }
   }
 
   return Builder.getWithLocInContext(getToContext());
@@ -8935,8 +8840,8 @@
   }
 
   case TemplateName::SubstTemplateTemplateParmPack: {
-    SubstTemplateTemplateParmPackStorage *SubstPack
-      = From.getAsSubstTemplateTemplateParmPack();
+    SubstTemplateTemplateParmPackStorage *SubstPack =
+        From.getAsSubstTemplateTemplateParmPack();
     ExpectedDecl ParamOrErr = Import(SubstPack->getParameterPack());
     if (!ParamOrErr)
       return ParamOrErr.takeError();
@@ -8987,12 +8892,12 @@
 
   SourceManager &FromSM = FromContext.getSourceManager();
   SourceManager &ToSM = ToContext.getSourceManager();
-  const SrcMgr::SLocEntry &FromSLoc = FromSM.getSLocEntry(FromID);
+  SrcMgr::SLocEntry const &FromSLoc = FromSM.getSLocEntry(FromID);
 
   // Map the FromID to the "to" source manager.
   FileID ToID;
   if (FromSLoc.isExpansion()) {
-    const SrcMgr::ExpansionInfo &FromEx = FromSLoc.getExpansion();
+    SrcMgr::ExpansionInfo const &FromEx = FromSLoc.getExpansion();
     ExpectedSLoc ToSpLoc = Import(FromEx.getSpellingLoc());
     if (!ToSpLoc)
       return ToSpLoc.takeError();
@@ -9012,7 +8917,7 @@
     }
     ToID = ToSM.getFileID(MLoc);
   } else {
-    const SrcMgr::ContentCache *Cache = &FromSLoc.getFile().getContentCache();
+    SrcMgr::ContentCache const *Cache = &FromSLoc.getFile().getContentCache();
 
     if (!IsBuiltin && !Cache->BufferOverridden) {
       // Include location of this file.
@@ -9132,7 +9037,7 @@
 }
 
 Expected<CXXBaseSpecifier *>
-ASTImporter::Import(const CXXBaseSpecifier *BaseSpec) {
+ASTImporter::Import(CXXBaseSpecifier const *BaseSpec) {
   auto Pos = ImportedCXXBaseSpecifiers.find(BaseSpec);
   if (Pos != ImportedCXXBaseSpecifiers.end())
     return Pos->second;
@@ -9153,7 +9058,7 @@
   return Imported;
 }
 
-llvm::Expected<APValue> ASTImporter::Import(const APValue &FromValue) {
+llvm::Expected<APValue> ASTImporter::Import(APValue const &FromValue) {
   ASTNodeImporter Importer(*this);
   return Importer.ImportAPValue(FromValue);
 }
@@ -9169,32 +9074,29 @@
 
   if (auto *ToRecord = dyn_cast<RecordDecl>(To)) {
     if (!ToRecord->getDefinition()) {
-      return Importer.ImportDefinition(
-          cast<RecordDecl>(FromDC), ToRecord,
-          ASTNodeImporter::IDK_Everything);
+      return Importer.ImportDefinition(cast<RecordDecl>(FromDC), ToRecord,
+                                       ASTNodeImporter::IDK_Everything);
     }
   }
 
   if (auto *ToEnum = dyn_cast<EnumDecl>(To)) {
     if (!ToEnum->getDefinition()) {
-      return Importer.ImportDefinition(
-          cast<EnumDecl>(FromDC), ToEnum, ASTNodeImporter::IDK_Everything);
+      return Importer.ImportDefinition(cast<EnumDecl>(FromDC), ToEnum,
+                                       ASTNodeImporter::IDK_Everything);
     }
   }
 
   if (auto *ToIFace = dyn_cast<ObjCInterfaceDecl>(To)) {
     if (!ToIFace->getDefinition()) {
-      return Importer.ImportDefinition(
-          cast<ObjCInterfaceDecl>(FromDC), ToIFace,
-          ASTNodeImporter::IDK_Everything);
+      return Importer.ImportDefinition(cast<ObjCInterfaceDecl>(FromDC), ToIFace,
+                                       ASTNodeImporter::IDK_Everything);
     }
   }
 
   if (auto *ToProto = dyn_cast<ObjCProtocolDecl>(To)) {
     if (!ToProto->getDefinition()) {
-      return Importer.ImportDefinition(
-          cast<ObjCProtocolDecl>(FromDC), ToProto,
-          ASTNodeImporter::IDK_Everything);
+      return Importer.ImportDefinition(cast<ObjCProtocolDecl>(FromDC), ToProto,
+                                       ASTNodeImporter::IDK_Everything);
     }
   }
 
@@ -9251,7 +9153,7 @@
 
   case DeclarationName::CXXOperatorName:
     return ToContext.DeclarationNames.getCXXOperatorName(
-                                          FromName.getCXXOverloadedOperator());
+        FromName.getCXXOverloadedOperator());
 
   case DeclarationName::CXXLiteralOperatorName:
     return ToContext.DeclarationNames.getCXXLiteralOperatorName(
@@ -9265,7 +9167,7 @@
   llvm_unreachable("Invalid DeclarationName Kind!");
 }
 
-IdentifierInfo *ASTImporter::Import(const IdentifierInfo *FromId) {
+IdentifierInfo *ASTImporter::Import(IdentifierInfo const *FromId) {
   if (!FromId)
     return nullptr;
 
@@ -9289,10 +9191,10 @@
 }
 
 llvm::Expected<APValue>
-ASTNodeImporter::ImportAPValue(const APValue &FromValue) {
+ASTNodeImporter::ImportAPValue(APValue const &FromValue) {
   APValue Result;
   llvm::Error Err = llvm::Error::success();
-  auto ImportLoop = [&](const APValue *From, APValue *To, unsigned Size) {
+  auto ImportLoop = [&](APValue const *From, APValue *To, unsigned Size) {
     for (unsigned Idx = 0; Idx < Size; Idx++) {
       APValue Tmp = importChecked(Err, From[Idx]);
       To[Idx] = Tmp;
@@ -9312,28 +9214,28 @@
     Result.MakeVector();
     MutableArrayRef<APValue> Elts =
         Result.setVectorUninit(FromValue.getVectorLength());
-    ImportLoop(((const APValue::Vec *)(const char *)&FromValue.Data)->Elts,
+    ImportLoop(((APValue::Vec const *)(char const *)&FromValue.Data)->Elts,
                Elts.data(), FromValue.getVectorLength());
     break;
   }
   case APValue::Array:
     Result.MakeArray(FromValue.getArrayInitializedElts(),
                      FromValue.getArraySize());
-    ImportLoop(((const APValue::Arr *)(const char *)&FromValue.Data)->Elts,
-               ((const APValue::Arr *)(const char *)&Result.Data)->Elts,
+    ImportLoop(((APValue::Arr const *)(char const *)&FromValue.Data)->Elts,
+               ((APValue::Arr const *)(char const *)&Result.Data)->Elts,
                FromValue.getArrayInitializedElts());
     break;
   case APValue::Struct:
     Result.MakeStruct(FromValue.getStructNumBases(),
                       FromValue.getStructNumFields());
     ImportLoop(
-        ((const APValue::StructData *)(const char *)&FromValue.Data)->Elts,
-        ((const APValue::StructData *)(const char *)&Result.Data)->Elts,
+        ((APValue::StructData const *)(char const *)&FromValue.Data)->Elts,
+        ((APValue::StructData const *)(char const *)&Result.Data)->Elts,
         FromValue.getStructNumBases() + FromValue.getStructNumFields());
     break;
   case APValue::Union: {
     Result.MakeUnion();
-    const Decl *ImpFDecl = importChecked(Err, FromValue.getUnionField());
+    Decl const *ImpFDecl = importChecked(Err, FromValue.getUnionField());
     APValue ImpValue = importChecked(Err, FromValue.getUnionValue());
     if (Err)
       return std::move(Err);
@@ -9342,8 +9244,8 @@
   }
   case APValue::AddrLabelDiff: {
     Result.MakeAddrLabelDiff();
-    const Expr *ImpLHS = importChecked(Err, FromValue.getAddrLabelDiffLHS());
-    const Expr *ImpRHS = importChecked(Err, FromValue.getAddrLabelDiffRHS());
+    Expr const *ImpLHS = importChecked(Err, FromValue.getAddrLabelDiffLHS());
+    Expr const *ImpRHS = importChecked(Err, FromValue.getAddrLabelDiffRHS());
     if (Err)
       return std::move(Err);
     Result.setAddrLabelDiff(cast<AddrLabelExpr>(ImpLHS),
@@ -9351,20 +9253,20 @@
     break;
   }
   case APValue::MemberPointer: {
-    const Decl *ImpMemPtrDecl =
+    Decl const *ImpMemPtrDecl =
         importChecked(Err, FromValue.getMemberPointerDecl());
     if (Err)
       return std::move(Err);
-    MutableArrayRef<const CXXRecordDecl *> ToPath =
+    MutableArrayRef<CXXRecordDecl const *> ToPath =
         Result.setMemberPointerUninit(
             cast<const ValueDecl>(ImpMemPtrDecl),
             FromValue.isMemberPointerToDerivedMember(),
             FromValue.getMemberPointerPath().size());
-    llvm::ArrayRef<const CXXRecordDecl *> FromPath =
+    llvm::ArrayRef<CXXRecordDecl const *> FromPath =
         Result.getMemberPointerPath();
     for (unsigned Idx = 0; Idx < FromValue.getMemberPointerPath().size();
          Idx++) {
-      const Decl *ImpDecl = importChecked(Err, FromPath[Idx]);
+      Decl const *ImpDecl = importChecked(Err, FromPath[Idx]);
       if (Err)
         return std::move(Err);
       ToPath[Idx] = cast<const CXXRecordDecl>(ImpDecl->getCanonicalDecl());
@@ -9379,10 +9281,10 @@
              "in C++20 dynamic allocation are transient so they shouldn't "
              "appear in the AST");
       if (!FromValue.getLValueBase().is<TypeInfoLValue>()) {
-        if (const auto *E =
-                FromValue.getLValueBase().dyn_cast<const Expr *>()) {
+        if (auto const *E =
+                FromValue.getLValueBase().dyn_cast<Expr const *>()) {
           FromElemTy = E->getType();
-          const Expr *ImpExpr = importChecked(Err, E);
+          Expr const *ImpExpr = importChecked(Err, E);
           if (Err)
             return std::move(Err);
           Base = APValue::LValueBase(ImpExpr,
@@ -9390,9 +9292,9 @@
                                      FromValue.getLValueBase().getVersion());
         } else {
           FromElemTy =
-              FromValue.getLValueBase().get<const ValueDecl *>()->getType();
-          const Decl *ImpDecl = importChecked(
-              Err, FromValue.getLValueBase().get<const ValueDecl *>());
+              FromValue.getLValueBase().get<ValueDecl const *>()->getType();
+          Decl const *ImpDecl = importChecked(
+              Err, FromValue.getLValueBase().get<ValueDecl const *>());
           if (Err)
             return std::move(Err);
           Base = APValue::LValueBase(cast<ValueDecl>(ImpDecl),
@@ -9424,9 +9326,9 @@
           FromValue.getLValuePath();
       for (unsigned LoopIdx = 0; LoopIdx < PathLength; LoopIdx++) {
         if (FromElemTy->isRecordType()) {
-          const Decl *FromDecl =
+          Decl const *FromDecl =
               FromPath[LoopIdx].getAsBaseOrMember().getPointer();
-          const Decl *ImpDecl = importChecked(Err, FromDecl);
+          Decl const *ImpDecl = importChecked(Err, FromDecl);
           if (Err)
             return std::move(Err);
           if (auto *RD = dyn_cast<CXXRecordDecl>(FromDecl))
@@ -9467,7 +9369,7 @@
 DiagnosticBuilder ASTImporter::ToDiag(SourceLocation Loc, unsigned DiagID) {
   if (LastDiagFromFrom)
     ToContext.getDiagnostics().notePriorDiagnosticFrom(
-      FromContext.getDiagnostics());
+        FromContext.getDiagnostics());
   LastDiagFromFrom = false;
   return ToContext.getDiagnostics().Report(Loc, DiagID);
 }
@@ -9475,27 +9377,24 @@
 DiagnosticBuilder ASTImporter::FromDiag(SourceLocation Loc, unsigned DiagID) {
   if (!LastDiagFromFrom)
     FromContext.getDiagnostics().notePriorDiagnosticFrom(
-      ToContext.getDiagnostics());
+        ToContext.getDiagnostics());
   LastDiagFromFrom = true;
   return FromContext.getDiagnostics().Report(Loc, DiagID);
 }
 
-void ASTImporter::CompleteDecl (Decl *D) {
+void ASTImporter::CompleteDecl(Decl *D) {
   if (auto *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
     if (!ID->getDefinition())
       ID->startDefinition();
-  }
-  else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
+  } else if (auto *PD = dyn_cast<ObjCProtocolDecl>(D)) {
     if (!PD->getDefinition())
       PD->startDefinition();
-  }
-  else if (auto *TD = dyn_cast<TagDecl>(D)) {
+  } else if (auto *TD = dyn_cast<TagDecl>(D)) {
     if (!TD->getDefinition() && !TD->isBeingDefined()) {
       TD->startDefinition();
       TD->setCompleteDefinition(true);
     }
-  }
-  else {
+  } else {
     assert(0 && "CompleteDecl called on a Decl that can't be completed");
   }
 }
@@ -9503,7 +9402,7 @@
 Decl *ASTImporter::MapImported(Decl *From, Decl *To) {
   llvm::DenseMap<Decl *, Decl *>::iterator Pos = ImportedDecls.find(From);
   assert((Pos == ImportedDecls.end() || Pos->second == To) &&
-      "Try to import an already imported Decl");
+         "Try to import an already imported Decl");
   if (Pos != ImportedDecls.end())
     return Pos->second;
   ImportedDecls[From] = To;
@@ -9537,7 +9436,7 @@
 
 bool ASTImporter::IsStructurallyEquivalent(QualType From, QualType To,
                                            bool Complain) {
-  llvm::DenseMap<const Type *, const Type *>::iterator Pos =
+  llvm::DenseMap<Type const *, Type const *>::iterator Pos =
       ImportedTypes.find(From.getTypePtr());
   if (Pos != ImportedTypes.end()) {
     if (ExpectedType ToFromOrErr = Import(From)) {
Index: clang/lib/AST/ASTImporterLookupTable.cpp
===================================================================
--- clang/lib/AST/ASTImporterLookupTable.cpp
+++ clang/lib/AST/ASTImporterLookupTable.cpp
@@ -26,7 +26,7 @@
   bool VisitTypedefNameDecl(TypedefNameDecl *D) {
     QualType Ty = D->getUnderlyingType();
     Ty = Ty.getCanonicalType();
-    if (const auto *RTy = dyn_cast<RecordType>(Ty)) {
+    if (auto const *RTy = dyn_cast<RecordType>(Ty)) {
       LT.add(RTy->getAsRecordDecl());
       // iterate over the field decls, adding them
       for (auto *it : RTy->getAsRecordDecl()->fields()) {
@@ -55,11 +55,11 @@
       // However, there are non-dependent cases which does not have the
       // type as a child node. We have to dig up that type now.
       if (!Ty->isDependentType()) {
-        if (const auto *RTy = dyn_cast<RecordType>(Ty))
+        if (auto const *RTy = dyn_cast<RecordType>(Ty))
           LT.add(RTy->getAsCXXRecordDecl());
-        else if (const auto *SpecTy = dyn_cast<TemplateSpecializationType>(Ty))
+        else if (auto const *SpecTy = dyn_cast<TemplateSpecializationType>(Ty))
           LT.add(SpecTy->getAsCXXRecordDecl());
-        else if (const auto *SubstTy =
+        else if (auto const *SubstTy =
                      dyn_cast<SubstTemplateTypeParmType>(Ty)) {
           if (SubstTy->getAsCXXRecordDecl())
             LT.add(SubstTy->getAsCXXRecordDecl());
@@ -136,7 +136,7 @@
   if (DCI == LookupTable.end())
     return {};
 
-  const auto &FoundNameMap = DCI->second;
+  auto const &FoundNameMap = DCI->second;
   auto NamesI = FoundNameMap.find(Name);
   if (NamesI == FoundNameMap.end())
     return {};
@@ -152,12 +152,12 @@
   auto DCI = LookupTable.find(DC->getPrimaryContext());
   if (DCI == LookupTable.end())
     llvm::errs() << "empty\n";
-  const auto &FoundNameMap = DCI->second;
-  for (const auto &Entry : FoundNameMap) {
+  auto const &FoundNameMap = DCI->second;
+  for (auto const &Entry : FoundNameMap) {
     DeclarationName Name = Entry.first;
     llvm::errs() << "==== Name: ";
     Name.dump();
-    const DeclList& List = Entry.second;
+    DeclList const &List = Entry.second;
     for (NamedDecl *ND : List) {
       ND->dump();
     }
@@ -165,7 +165,7 @@
 }
 
 void ASTImporterLookupTable::dump() const {
-  for (const auto &Entry : LookupTable) {
+  for (auto const &Entry : LookupTable) {
     DeclContext *DC = Entry.first;
     StringRef Primary = DC->getPrimaryContext() ? " primary" : "";
     llvm::errs() << "== DC:" << cast<Decl>(DC) << Primary << "\n";
Index: clang/lib/AST/ASTStructuralEquivalence.cpp
===================================================================
--- clang/lib/AST/ASTStructuralEquivalence.cpp
+++ clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -100,13 +100,13 @@
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      Decl *D1, Decl *D2);
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
-                                     const TemplateArgument &Arg1,
-                                     const TemplateArgument &Arg2);
+                                     TemplateArgument const &Arg1,
+                                     TemplateArgument const &Arg2);
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      NestedNameSpecifier *NNS1,
                                      NestedNameSpecifier *NNS2);
-static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
-                                     const IdentifierInfo *Name2);
+static bool IsStructurallyEquivalent(IdentifierInfo const *Name1,
+                                     IdentifierInfo const *Name2);
 
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      const DeclarationName Name1,
@@ -165,19 +165,19 @@
   // and only has to compare the data that is specific to the specific statement
   // class. Should only be called from TraverseStmt.
 
-  bool IsStmtEquivalent(const AddrLabelExpr *E1, const AddrLabelExpr *E2) {
+  bool IsStmtEquivalent(AddrLabelExpr const *E1, AddrLabelExpr const *E2) {
     return IsStructurallyEquivalent(Context, E1->getLabel(), E2->getLabel());
   }
 
-  bool IsStmtEquivalent(const AtomicExpr *E1, const AtomicExpr *E2) {
+  bool IsStmtEquivalent(AtomicExpr const *E1, AtomicExpr const *E2) {
     return E1->getOp() == E2->getOp();
   }
 
-  bool IsStmtEquivalent(const BinaryOperator *E1, const BinaryOperator *E2) {
+  bool IsStmtEquivalent(BinaryOperator const *E1, BinaryOperator const *E2) {
     return E1->getOpcode() == E2->getOpcode();
   }
 
-  bool IsStmtEquivalent(const CallExpr *E1, const CallExpr *E2) {
+  bool IsStmtEquivalent(CallExpr const *E1, CallExpr const *E2) {
     // FIXME: IsStructurallyEquivalent requires non-const Decls.
     Decl *Callee1 = const_cast<Decl *>(E1->getCalleeDecl());
     Decl *Callee2 = const_cast<Decl *>(E2->getCalleeDecl());
@@ -194,16 +194,16 @@
     return IsStructurallyEquivalent(Context, Callee1, Callee2);
   }
 
-  bool IsStmtEquivalent(const CharacterLiteral *E1,
-                        const CharacterLiteral *E2) {
+  bool IsStmtEquivalent(CharacterLiteral const *E1,
+                        CharacterLiteral const *E2) {
     return E1->getValue() == E2->getValue() && E1->getKind() == E2->getKind();
   }
 
-  bool IsStmtEquivalent(const ChooseExpr *E1, const ChooseExpr *E2) {
+  bool IsStmtEquivalent(ChooseExpr const *E1, ChooseExpr const *E2) {
     return true; // Semantics only depend on children.
   }
 
-  bool IsStmtEquivalent(const CompoundStmt *E1, const CompoundStmt *E2) {
+  bool IsStmtEquivalent(CompoundStmt const *E1, CompoundStmt const *E2) {
     // Number of children is actually checked by the generic children comparison
     // code, but a CompoundStmt is one of the few statements where the number of
     // children frequently differs and the number of statements is also always
@@ -212,8 +212,8 @@
     return E1->size() == E2->size();
   }
 
-  bool IsStmtEquivalent(const DependentScopeDeclRefExpr *DE1,
-                        const DependentScopeDeclRefExpr *DE2) {
+  bool IsStmtEquivalent(DependentScopeDeclRefExpr const *DE1,
+                        DependentScopeDeclRefExpr const *DE2) {
     if (!IsStructurallyEquivalent(Context, DE1->getDeclName(),
                                   DE2->getDeclName()))
       return false;
@@ -221,21 +221,21 @@
                                     DE2->getQualifier());
   }
 
-  bool IsStmtEquivalent(const Expr *E1, const Expr *E2) {
+  bool IsStmtEquivalent(Expr const *E1, Expr const *E2) {
     return IsStructurallyEquivalent(Context, E1->getType(), E2->getType());
   }
 
-  bool IsStmtEquivalent(const ExpressionTraitExpr *E1,
-                        const ExpressionTraitExpr *E2) {
+  bool IsStmtEquivalent(ExpressionTraitExpr const *E1,
+                        ExpressionTraitExpr const *E2) {
     return E1->getTrait() == E2->getTrait() && E1->getValue() == E2->getValue();
   }
 
-  bool IsStmtEquivalent(const FloatingLiteral *E1, const FloatingLiteral *E2) {
+  bool IsStmtEquivalent(FloatingLiteral const *E1, FloatingLiteral const *E2) {
     return E1->isExact() == E2->isExact() && E1->getValue() == E2->getValue();
   }
 
-  bool IsStmtEquivalent(const GenericSelectionExpr *E1,
-                        const GenericSelectionExpr *E2) {
+  bool IsStmtEquivalent(GenericSelectionExpr const *E1,
+                        GenericSelectionExpr const *E2) {
     for (auto Pair : zip_longest(E1->getAssocTypeSourceInfos(),
                                  E2->getAssocTypeSourceInfos())) {
       Optional<TypeSourceInfo *> Child1 = std::get<0>(Pair);
@@ -252,54 +252,54 @@
     return true;
   }
 
-  bool IsStmtEquivalent(const ImplicitCastExpr *CastE1,
-                        const ImplicitCastExpr *CastE2) {
+  bool IsStmtEquivalent(ImplicitCastExpr const *CastE1,
+                        ImplicitCastExpr const *CastE2) {
     return IsStructurallyEquivalent(Context, CastE1->getType(),
                                     CastE2->getType());
   }
 
-  bool IsStmtEquivalent(const IntegerLiteral *E1, const IntegerLiteral *E2) {
+  bool IsStmtEquivalent(IntegerLiteral const *E1, IntegerLiteral const *E2) {
     return E1->getValue() == E2->getValue();
   }
 
-  bool IsStmtEquivalent(const MemberExpr *E1, const MemberExpr *E2) {
+  bool IsStmtEquivalent(MemberExpr const *E1, MemberExpr const *E2) {
     return IsStructurallyEquivalent(Context, E1->getFoundDecl(),
                                     E2->getFoundDecl());
   }
 
-  bool IsStmtEquivalent(const ObjCStringLiteral *E1,
-                        const ObjCStringLiteral *E2) {
+  bool IsStmtEquivalent(ObjCStringLiteral const *E1,
+                        ObjCStringLiteral const *E2) {
     // Just wraps a StringLiteral child.
     return true;
   }
 
-  bool IsStmtEquivalent(const Stmt *S1, const Stmt *S2) { return true; }
+  bool IsStmtEquivalent(Stmt const *S1, Stmt const *S2) { return true; }
 
-  bool IsStmtEquivalent(const SourceLocExpr *E1, const SourceLocExpr *E2) {
+  bool IsStmtEquivalent(SourceLocExpr const *E1, SourceLocExpr const *E2) {
     return E1->getIdentKind() == E2->getIdentKind();
   }
 
-  bool IsStmtEquivalent(const StmtExpr *E1, const StmtExpr *E2) {
+  bool IsStmtEquivalent(StmtExpr const *E1, StmtExpr const *E2) {
     return E1->getTemplateDepth() == E2->getTemplateDepth();
   }
 
-  bool IsStmtEquivalent(const StringLiteral *E1, const StringLiteral *E2) {
+  bool IsStmtEquivalent(StringLiteral const *E1, StringLiteral const *E2) {
     return E1->getBytes() == E2->getBytes();
   }
 
-  bool IsStmtEquivalent(const SubstNonTypeTemplateParmExpr *E1,
-                        const SubstNonTypeTemplateParmExpr *E2) {
+  bool IsStmtEquivalent(SubstNonTypeTemplateParmExpr const *E1,
+                        SubstNonTypeTemplateParmExpr const *E2) {
     return IsStructurallyEquivalent(Context, E1->getParameter(),
                                     E2->getParameter());
   }
 
-  bool IsStmtEquivalent(const SubstNonTypeTemplateParmPackExpr *E1,
-                        const SubstNonTypeTemplateParmPackExpr *E2) {
+  bool IsStmtEquivalent(SubstNonTypeTemplateParmPackExpr const *E1,
+                        SubstNonTypeTemplateParmPackExpr const *E2) {
     return IsStructurallyEquivalent(Context, E1->getArgumentPack(),
                                     E2->getArgumentPack());
   }
 
-  bool IsStmtEquivalent(const TypeTraitExpr *E1, const TypeTraitExpr *E2) {
+  bool IsStmtEquivalent(TypeTraitExpr const *E1, TypeTraitExpr const *E2) {
     if (E1->getTrait() != E2->getTrait())
       return false;
 
@@ -317,25 +317,25 @@
     return true;
   }
 
-  bool IsStmtEquivalent(const UnaryExprOrTypeTraitExpr *E1,
-                        const UnaryExprOrTypeTraitExpr *E2) {
+  bool IsStmtEquivalent(UnaryExprOrTypeTraitExpr const *E1,
+                        UnaryExprOrTypeTraitExpr const *E2) {
     if (E1->getKind() != E2->getKind())
       return false;
     return IsStructurallyEquivalent(Context, E1->getTypeOfArgument(),
                                     E2->getTypeOfArgument());
   }
 
-  bool IsStmtEquivalent(const UnaryOperator *E1, const UnaryOperator *E2) {
+  bool IsStmtEquivalent(UnaryOperator const *E1, UnaryOperator const *E2) {
     return E1->getOpcode() == E2->getOpcode();
   }
 
-  bool IsStmtEquivalent(const VAArgExpr *E1, const VAArgExpr *E2) {
+  bool IsStmtEquivalent(VAArgExpr const *E1, VAArgExpr const *E2) {
     // Semantics only depend on children.
     return true;
   }
 
   /// End point of the traversal chain.
-  bool TraverseStmt(const Stmt *S1, const Stmt *S2) { return true; }
+  bool TraverseStmt(Stmt const *S1, Stmt const *S2) { return true; }
 
   // Create traversal methods that traverse the class hierarchy and return
   // the accumulated result of the comparison. Each TraverseStmt overload
@@ -357,7 +357,7 @@
   /// Determine whether two statements are equivalent. The statements have to
   /// be of the same kind. The children of the statements and their properties
   /// are not compared by this function.
-  bool IsEquivalent(const Stmt *S1, const Stmt *S2) {
+  bool IsEquivalent(Stmt const *S1, Stmt const *S2) {
     if (S1->getStmtClass() != S2->getStmtClass())
       return false;
 
@@ -383,7 +383,7 @@
 
 /// Determine structural equivalence of two statements.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
-                                     const Stmt *S1, const Stmt *S2) {
+                                     Stmt const *S1, Stmt const *S2) {
   if (!S1 || !S2)
     return S1 == S2;
 
@@ -394,8 +394,8 @@
 
   // Iterate over the children of both statements and also compare them.
   for (auto Pair : zip_longest(S1->children(), S2->children())) {
-    Optional<const Stmt *> Child1 = std::get<0>(Pair);
-    Optional<const Stmt *> Child2 = std::get<1>(Pair);
+    Optional<Stmt const *> Child1 = std::get<0>(Pair);
+    Optional<Stmt const *> Child2 = std::get<1>(Pair);
     // One of the statements has a different amount of children than the other,
     // so the statements can't be equivalent.
     if (!Child1 || !Child2)
@@ -407,8 +407,8 @@
 }
 
 /// Determine whether two identifiers are equivalent.
-static bool IsStructurallyEquivalent(const IdentifierInfo *Name1,
-                                     const IdentifierInfo *Name2) {
+static bool IsStructurallyEquivalent(IdentifierInfo const *Name1,
+                                     IdentifierInfo const *Name2) {
   if (!Name1 || !Name2)
     return Name1 == Name2;
 
@@ -455,8 +455,8 @@
 }
 
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
-                                     const TemplateName &N1,
-                                     const TemplateName &N2) {
+                                     TemplateName const &N1,
+                                     TemplateName const &N2) {
   TemplateDecl *TemplateDeclN1 = N1.getAsTemplateDecl();
   TemplateDecl *TemplateDeclN2 = N2.getAsTemplateDecl();
   if (TemplateDeclN1 && TemplateDeclN2) {
@@ -514,12 +514,11 @@
                                     P2->getParameterPack());
   }
 
-   case TemplateName::Template:
-   case TemplateName::QualifiedTemplate:
-   case TemplateName::SubstTemplateTemplateParm:
-     // It is sufficient to check value of getAsTemplateDecl.
-     break;
-
+  case TemplateName::Template:
+  case TemplateName::QualifiedTemplate:
+  case TemplateName::SubstTemplateTemplateParm:
+    // It is sufficient to check value of getAsTemplateDecl.
+    break;
   }
 
   return true;
@@ -527,8 +526,8 @@
 
 /// Determine whether two template arguments are equivalent.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
-                                     const TemplateArgument &Arg1,
-                                     const TemplateArgument &Arg2) {
+                                     TemplateArgument const &Arg1,
+                                     TemplateArgument const &Arg2) {
   if (Arg1.getKind() != Arg2.getKind())
     return false;
 
@@ -537,18 +536,20 @@
     return true;
 
   case TemplateArgument::Type:
-    return IsStructurallyEquivalent(Context, Arg1.getAsType(), Arg2.getAsType());
+    return IsStructurallyEquivalent(Context, Arg1.getAsType(),
+                                    Arg2.getAsType());
 
   case TemplateArgument::Integral:
     if (!IsStructurallyEquivalent(Context, Arg1.getIntegralType(),
-                                          Arg2.getIntegralType()))
+                                  Arg2.getIntegralType()))
       return false;
 
     return llvm::APSInt::isSameValue(Arg1.getAsIntegral(),
                                      Arg2.getAsIntegral());
 
   case TemplateArgument::Declaration:
-    return IsStructurallyEquivalent(Context, Arg1.getAsDecl(), Arg2.getAsDecl());
+    return IsStructurallyEquivalent(Context, Arg1.getAsDecl(),
+                                    Arg2.getAsDecl());
 
   case TemplateArgument::NullPtr:
     return true; // FIXME: Is this correct?
@@ -584,8 +585,8 @@
 /// Determine structural equivalence for the common part of array
 /// types.
 static bool IsArrayStructurallyEquivalent(StructuralEquivalenceContext &Context,
-                                          const ArrayType *Array1,
-                                          const ArrayType *Array2) {
+                                          ArrayType const *Array1,
+                                          ArrayType const *Array2) {
   if (!IsStructurallyEquivalent(Context, Array1->getElementType(),
                                 Array2->getElementType()))
     return false;
@@ -625,8 +626,8 @@
 
 /// Check the equivalence of exception specifications.
 static bool IsEquivalentExceptionSpec(StructuralEquivalenceContext &Context,
-                                      const FunctionProtoType *Proto1,
-                                      const FunctionProtoType *Proto2) {
+                                      FunctionProtoType const *Proto1,
+                                      FunctionProtoType const *Proto2) {
 
   auto Spec1 = Proto1->getExceptionSpecType();
   auto Spec2 = Proto2->getExceptionSpecType();
@@ -725,8 +726,8 @@
 
   case Type::LValueReference:
   case Type::RValueReference: {
-    const auto *Ref1 = cast<ReferenceType>(T1);
-    const auto *Ref2 = cast<ReferenceType>(T2);
+    auto const *Ref1 = cast<ReferenceType>(T1);
+    auto const *Ref2 = cast<ReferenceType>(T2);
     if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
       return false;
     if (Ref1->isInnerRef() != Ref2->isInnerRef())
@@ -738,8 +739,8 @@
   }
 
   case Type::MemberPointer: {
-    const auto *MemPtr1 = cast<MemberPointerType>(T1);
-    const auto *MemPtr2 = cast<MemberPointerType>(T2);
+    auto const *MemPtr1 = cast<MemberPointerType>(T1);
+    auto const *MemPtr2 = cast<MemberPointerType>(T2);
     if (!IsStructurallyEquivalent(Context, MemPtr1->getPointeeType(),
                                   MemPtr2->getPointeeType()))
       return false;
@@ -750,8 +751,8 @@
   }
 
   case Type::ConstantArray: {
-    const auto *Array1 = cast<ConstantArrayType>(T1);
-    const auto *Array2 = cast<ConstantArrayType>(T2);
+    auto const *Array1 = cast<ConstantArrayType>(T1);
+    auto const *Array2 = cast<ConstantArrayType>(T2);
     if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
       return false;
 
@@ -767,8 +768,8 @@
     break;
 
   case Type::VariableArray: {
-    const auto *Array1 = cast<VariableArrayType>(T1);
-    const auto *Array2 = cast<VariableArrayType>(T2);
+    auto const *Array1 = cast<VariableArrayType>(T1);
+    auto const *Array2 = cast<VariableArrayType>(T2);
     if (!IsStructurallyEquivalent(Context, Array1->getSizeExpr(),
                                   Array2->getSizeExpr()))
       return false;
@@ -780,8 +781,8 @@
   }
 
   case Type::DependentSizedArray: {
-    const auto *Array1 = cast<DependentSizedArrayType>(T1);
-    const auto *Array2 = cast<DependentSizedArrayType>(T2);
+    auto const *Array1 = cast<DependentSizedArrayType>(T1);
+    auto const *Array2 = cast<DependentSizedArrayType>(T2);
     if (!IsStructurallyEquivalent(Context, Array1->getSizeExpr(),
                                   Array2->getSizeExpr()))
       return false;
@@ -793,8 +794,8 @@
   }
 
   case Type::DependentAddressSpace: {
-    const auto *DepAddressSpace1 = cast<DependentAddressSpaceType>(T1);
-    const auto *DepAddressSpace2 = cast<DependentAddressSpaceType>(T2);
+    auto const *DepAddressSpace1 = cast<DependentAddressSpaceType>(T1);
+    auto const *DepAddressSpace2 = cast<DependentAddressSpaceType>(T2);
     if (!IsStructurallyEquivalent(Context, DepAddressSpace1->getAddrSpaceExpr(),
                                   DepAddressSpace2->getAddrSpaceExpr()))
       return false;
@@ -806,8 +807,8 @@
   }
 
   case Type::DependentSizedExtVector: {
-    const auto *Vec1 = cast<DependentSizedExtVectorType>(T1);
-    const auto *Vec2 = cast<DependentSizedExtVectorType>(T2);
+    auto const *Vec1 = cast<DependentSizedExtVectorType>(T1);
+    auto const *Vec2 = cast<DependentSizedExtVectorType>(T2);
     if (!IsStructurallyEquivalent(Context, Vec1->getSizeExpr(),
                                   Vec2->getSizeExpr()))
       return false;
@@ -818,8 +819,8 @@
   }
 
   case Type::DependentVector: {
-    const auto *Vec1 = cast<DependentVectorType>(T1);
-    const auto *Vec2 = cast<DependentVectorType>(T2);
+    auto const *Vec1 = cast<DependentVectorType>(T1);
+    auto const *Vec2 = cast<DependentVectorType>(T2);
     if (Vec1->getVectorKind() != Vec2->getVectorKind())
       return false;
     if (!IsStructurallyEquivalent(Context, Vec1->getSizeExpr(),
@@ -833,8 +834,8 @@
 
   case Type::Vector:
   case Type::ExtVector: {
-    const auto *Vec1 = cast<VectorType>(T1);
-    const auto *Vec2 = cast<VectorType>(T2);
+    auto const *Vec1 = cast<VectorType>(T1);
+    auto const *Vec2 = cast<VectorType>(T2);
     if (!IsStructurallyEquivalent(Context, Vec1->getElementType(),
                                   Vec2->getElementType()))
       return false;
@@ -846,8 +847,8 @@
   }
 
   case Type::DependentSizedMatrix: {
-    const DependentSizedMatrixType *Mat1 = cast<DependentSizedMatrixType>(T1);
-    const DependentSizedMatrixType *Mat2 = cast<DependentSizedMatrixType>(T2);
+    DependentSizedMatrixType const *Mat1 = cast<DependentSizedMatrixType>(T1);
+    DependentSizedMatrixType const *Mat2 = cast<DependentSizedMatrixType>(T2);
     // The element types, row and column expressions must be structurally
     // equivalent.
     if (!IsStructurallyEquivalent(Context, Mat1->getRowExpr(),
@@ -861,8 +862,8 @@
   }
 
   case Type::ConstantMatrix: {
-    const ConstantMatrixType *Mat1 = cast<ConstantMatrixType>(T1);
-    const ConstantMatrixType *Mat2 = cast<ConstantMatrixType>(T2);
+    ConstantMatrixType const *Mat1 = cast<ConstantMatrixType>(T1);
+    ConstantMatrixType const *Mat2 = cast<ConstantMatrixType>(T2);
     // The element types must be structurally equivalent and the number of rows
     // and columns must match.
     if (!IsStructurallyEquivalent(Context, Mat1->getElementType(),
@@ -874,8 +875,8 @@
   }
 
   case Type::FunctionProto: {
-    const auto *Proto1 = cast<FunctionProtoType>(T1);
-    const auto *Proto2 = cast<FunctionProtoType>(T2);
+    auto const *Proto1 = cast<FunctionProtoType>(T1);
+    auto const *Proto2 = cast<FunctionProtoType>(T2);
 
     if (Proto1->getNumParams() != Proto2->getNumParams())
       return false;
@@ -891,9 +892,9 @@
       return false;
 
     // Check exceptions, this information is lost in canonical type.
-    const auto *OrigProto1 =
+    auto const *OrigProto1 =
         cast<FunctionProtoType>(OrigT1.getDesugaredType(Context.FromCtx));
-    const auto *OrigProto2 =
+    auto const *OrigProto2 =
         cast<FunctionProtoType>(OrigT2.getDesugaredType(Context.ToCtx));
     if (!IsEquivalentExceptionSpec(Context, OrigProto1, OrigProto2))
       return false;
@@ -903,8 +904,8 @@
   }
 
   case Type::FunctionNoProto: {
-    const auto *Function1 = cast<FunctionType>(T1);
-    const auto *Function2 = cast<FunctionType>(T2);
+    auto const *Function1 = cast<FunctionType>(T1);
+    auto const *Function2 = cast<FunctionType>(T2);
     if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
                                   Function2->getReturnType()))
       return false;
@@ -1006,8 +1007,8 @@
   }
 
   case Type::DeducedTemplateSpecialization: {
-    const auto *DT1 = cast<DeducedTemplateSpecializationType>(T1);
-    const auto *DT2 = cast<DeducedTemplateSpecializationType>(T2);
+    auto const *DT1 = cast<DeducedTemplateSpecializationType>(T1);
+    auto const *DT2 = cast<DeducedTemplateSpecializationType>(T2);
     if (!IsStructurallyEquivalent(Context, DT1->getTemplateName(),
                                   DT2->getTemplateName()))
       return false;
@@ -1025,8 +1026,8 @@
     break;
 
   case Type::TemplateTypeParm: {
-    const auto *Parm1 = cast<TemplateTypeParmType>(T1);
-    const auto *Parm2 = cast<TemplateTypeParmType>(T2);
+    auto const *Parm1 = cast<TemplateTypeParmType>(T1);
+    auto const *Parm2 = cast<TemplateTypeParmType>(T2);
     if (Parm1->getDepth() != Parm2->getDepth())
       return false;
     if (Parm1->getIndex() != Parm2->getIndex())
@@ -1039,8 +1040,8 @@
   }
 
   case Type::SubstTemplateTypeParm: {
-    const auto *Subst1 = cast<SubstTemplateTypeParmType>(T1);
-    const auto *Subst2 = cast<SubstTemplateTypeParmType>(T2);
+    auto const *Subst1 = cast<SubstTemplateTypeParmType>(T1);
+    auto const *Subst2 = cast<SubstTemplateTypeParmType>(T2);
     if (!IsStructurallyEquivalent(Context,
                                   QualType(Subst1->getReplacedParameter(), 0),
                                   QualType(Subst2->getReplacedParameter(), 0)))
@@ -1052,8 +1053,8 @@
   }
 
   case Type::SubstTemplateTypeParmPack: {
-    const auto *Subst1 = cast<SubstTemplateTypeParmPackType>(T1);
-    const auto *Subst2 = cast<SubstTemplateTypeParmPackType>(T2);
+    auto const *Subst1 = cast<SubstTemplateTypeParmPackType>(T1);
+    auto const *Subst2 = cast<SubstTemplateTypeParmPackType>(T2);
     if (!IsStructurallyEquivalent(Context,
                                   QualType(Subst1->getReplacedParameter(), 0),
                                   QualType(Subst2->getReplacedParameter(), 0)))
@@ -1065,8 +1066,8 @@
   }
 
   case Type::TemplateSpecialization: {
-    const auto *Spec1 = cast<TemplateSpecializationType>(T1);
-    const auto *Spec2 = cast<TemplateSpecializationType>(T2);
+    auto const *Spec1 = cast<TemplateSpecializationType>(T1);
+    auto const *Spec2 = cast<TemplateSpecializationType>(T2);
     if (!IsStructurallyEquivalent(Context, Spec1->getTemplateName(),
                                   Spec2->getTemplateName()))
       return false;
@@ -1081,8 +1082,8 @@
   }
 
   case Type::Elaborated: {
-    const auto *Elab1 = cast<ElaboratedType>(T1);
-    const auto *Elab2 = cast<ElaboratedType>(T2);
+    auto const *Elab1 = cast<ElaboratedType>(T1);
+    auto const *Elab2 = cast<ElaboratedType>(T2);
     // CHECKME: what if a keyword is ETK_None or ETK_typename ?
     if (Elab1->getKeyword() != Elab2->getKeyword())
       return false;
@@ -1096,8 +1097,8 @@
   }
 
   case Type::InjectedClassName: {
-    const auto *Inj1 = cast<InjectedClassNameType>(T1);
-    const auto *Inj2 = cast<InjectedClassNameType>(T2);
+    auto const *Inj1 = cast<InjectedClassNameType>(T1);
+    auto const *Inj2 = cast<InjectedClassNameType>(T2);
     if (!IsStructurallyEquivalent(Context,
                                   Inj1->getInjectedSpecializationType(),
                                   Inj2->getInjectedSpecializationType()))
@@ -1106,8 +1107,8 @@
   }
 
   case Type::DependentName: {
-    const auto *Typename1 = cast<DependentNameType>(T1);
-    const auto *Typename2 = cast<DependentNameType>(T2);
+    auto const *Typename1 = cast<DependentNameType>(T1);
+    auto const *Typename2 = cast<DependentNameType>(T2);
     if (!IsStructurallyEquivalent(Context, Typename1->getQualifier(),
                                   Typename2->getQualifier()))
       return false;
@@ -1119,8 +1120,8 @@
   }
 
   case Type::DependentTemplateSpecialization: {
-    const auto *Spec1 = cast<DependentTemplateSpecializationType>(T1);
-    const auto *Spec2 = cast<DependentTemplateSpecializationType>(T2);
+    auto const *Spec1 = cast<DependentTemplateSpecializationType>(T1);
+    auto const *Spec2 = cast<DependentTemplateSpecializationType>(T2);
     if (!IsStructurallyEquivalent(Context, Spec1->getQualifier(),
                                   Spec2->getQualifier()))
       return false;
@@ -1145,8 +1146,8 @@
     break;
 
   case Type::ObjCInterface: {
-    const auto *Iface1 = cast<ObjCInterfaceType>(T1);
-    const auto *Iface2 = cast<ObjCInterfaceType>(T2);
+    auto const *Iface1 = cast<ObjCInterfaceType>(T1);
+    auto const *Iface2 = cast<ObjCInterfaceType>(T2);
     if (!IsStructurallyEquivalent(Context, Iface1->getDecl(),
                                   Iface2->getDecl()))
       return false;
@@ -1154,8 +1155,8 @@
   }
 
   case Type::ObjCTypeParam: {
-    const auto *Obj1 = cast<ObjCTypeParamType>(T1);
-    const auto *Obj2 = cast<ObjCTypeParamType>(T2);
+    auto const *Obj1 = cast<ObjCTypeParamType>(T1);
+    auto const *Obj2 = cast<ObjCTypeParamType>(T2);
     if (!IsStructurallyEquivalent(Context, Obj1->getDecl(), Obj2->getDecl()))
       return false;
 
@@ -1170,8 +1171,8 @@
   }
 
   case Type::ObjCObject: {
-    const auto *Obj1 = cast<ObjCObjectType>(T1);
-    const auto *Obj2 = cast<ObjCObjectType>(T2);
+    auto const *Obj1 = cast<ObjCObjectType>(T1);
+    auto const *Obj2 = cast<ObjCObjectType>(T2);
     if (!IsStructurallyEquivalent(Context, Obj1->getBaseType(),
                                   Obj2->getBaseType()))
       return false;
@@ -1186,8 +1187,8 @@
   }
 
   case Type::ObjCObjectPointer: {
-    const auto *Ptr1 = cast<ObjCObjectPointerType>(T1);
-    const auto *Ptr2 = cast<ObjCObjectPointerType>(T2);
+    auto const *Ptr1 = cast<ObjCObjectPointerType>(T1);
+    auto const *Ptr2 = cast<ObjCObjectPointerType>(T2);
     if (!IsStructurallyEquivalent(Context, Ptr1->getPointeeType(),
                                   Ptr2->getPointeeType()))
       return false;
@@ -1206,8 +1207,8 @@
       return false;
     break;
   case Type::ExtInt: {
-    const auto *Int1 = cast<ExtIntType>(T1);
-    const auto *Int2 = cast<ExtIntType>(T2);
+    auto const *Int1 = cast<ExtIntType>(T1);
+    auto const *Int2 = cast<ExtIntType>(T2);
 
     if (Int1->isUnsigned() != Int2->isUnsigned() ||
         Int1->getNumBits() != Int2->getNumBits())
@@ -1215,8 +1216,8 @@
     break;
   }
   case Type::DependentExtInt: {
-    const auto *Int1 = cast<DependentExtIntType>(T1);
-    const auto *Int2 = cast<DependentExtIntType>(T2);
+    auto const *Int1 = cast<DependentExtIntType>(T1);
+    auto const *Int2 = cast<DependentExtIntType>(T2);
 
     if (Int1->isUnsigned() != Int2->isUnsigned() ||
         !IsStructurallyEquivalent(Context, Int1->getNumBitsExpr(),
@@ -1231,7 +1232,7 @@
 /// Determine structural equivalence of two fields.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      FieldDecl *Field1, FieldDecl *Field2) {
-  const auto *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
+  auto const *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
 
   // For anonymous structs/unions, match up the anonymous struct/union type
   // declarations directly, so that we don't go off searching for anonymous
@@ -1319,16 +1320,16 @@
       return false;
   }
 
-  const IdentifierInfo *Name1 = Method1->getIdentifier();
-  const IdentifierInfo *Name2 = Method2->getIdentifier();
+  IdentifierInfo const *Name1 = Method1->getIdentifier();
+  IdentifierInfo const *Name2 = Method2->getIdentifier();
   if (!::IsStructurallyEquivalent(Name1, Name2)) {
     return false;
     // TODO: Names do not match, add warning like at check for FieldDecl.
   }
 
   // Check the prototypes.
-  if (!::IsStructurallyEquivalent(Context,
-                                  Method1->getType(), Method2->getType()))
+  if (!::IsStructurallyEquivalent(Context, Method1->getType(),
+                                  Method2->getType()))
     return false;
 
   return true;
@@ -1388,8 +1389,8 @@
 
   // If both declarations are class template specializations, we know
   // the ODR applies, so check the template and template arguments.
-  const auto *Spec1 = dyn_cast<ClassTemplateSpecializationDecl>(D1);
-  const auto *Spec2 = dyn_cast<ClassTemplateSpecializationDecl>(D2);
+  auto const *Spec1 = dyn_cast<ClassTemplateSpecializationDecl>(D1);
+  auto const *Spec2 = dyn_cast<ClassTemplateSpecializationDecl>(D2);
   if (Spec1 && Spec2) {
     // Check that the specialized templates are the same.
     if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
@@ -1544,7 +1545,7 @@
                       Context.getApplicableDiagnostic(
                           diag::err_odr_tag_type_inconsistent))
             << Context.ToCtx.getTypeDeclType(D2);
-        const CXXBaseSpecifier *Base1 = D1CXX->bases_begin();
+        CXXBaseSpecifier const *Base1 = D1CXX->bases_begin();
         Context.Diag1(Base1->getBeginLoc(), diag::note_odr_base)
             << Base1->getType() << Base1->getSourceRange();
         Context.Diag2(D2->getLocation(), diag::note_odr_missing_base);
@@ -1767,8 +1768,9 @@
                                   D2->getTemplateParameters());
 }
 
-static bool IsTemplateDeclCommonStructurallyEquivalent(
-    StructuralEquivalenceContext &Ctx, TemplateDecl *D1, TemplateDecl *D2) {
+static bool
+IsTemplateDeclCommonStructurallyEquivalent(StructuralEquivalenceContext &Ctx,
+                                           TemplateDecl *D1, TemplateDecl *D2) {
   if (!IsStructurallyEquivalent(D1->getIdentifier(), D2->getIdentifier()))
     return false;
   if (!D1->getIdentifier()) // Special name
@@ -1803,8 +1805,7 @@
 }
 
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
-                                     ConceptDecl *D1,
-                                     ConceptDecl *D2) {
+                                     ConceptDecl *D1, ConceptDecl *D2) {
   // Check template parameters.
   if (!IsTemplateDeclCommonStructurallyEquivalent(Context, D1, D2))
     return false;
@@ -1818,11 +1819,10 @@
                                      FriendDecl *D1, FriendDecl *D2) {
   if ((D1->getFriendType() && D2->getFriendDecl()) ||
       (D1->getFriendDecl() && D2->getFriendType())) {
-      return false;
+    return false;
   }
   if (D1->getFriendType() && D2->getFriendType())
-    return IsStructurallyEquivalent(Context,
-                                    D1->getFriendType()->getType(),
+    return IsStructurallyEquivalent(Context, D1->getFriendType()->getType(),
                                     D2->getFriendType()->getType());
   if (D1->getFriendDecl() && D2->getFriendDecl())
     return IsStructurallyEquivalent(Context, D1->getFriendDecl(),
@@ -1907,13 +1907,13 @@
   ASTContext &Context = Anon->getASTContext();
   QualType AnonTy = Context.getRecordType(Anon);
 
-  const auto *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
+  auto const *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
   if (!Owner)
     return None;
 
   unsigned Index = 0;
-  for (const auto *D : Owner->noload_decls()) {
-    const auto *F = dyn_cast<FieldDecl>(D);
+  for (auto const *D : Owner->noload_decls()) {
+    auto const *F = dyn_cast<FieldDecl>(D);
     if (!F)
       continue;
 
@@ -1928,11 +1928,11 @@
     // struct { ... } A;
     QualType FieldType = F->getType();
     // In case of nested structs.
-    while (const auto *ElabType = dyn_cast<ElaboratedType>(FieldType))
+    while (auto const *ElabType = dyn_cast<ElaboratedType>(FieldType))
       FieldType = ElabType->getNamedType();
 
-    if (const auto *RecType = dyn_cast<RecordType>(FieldType)) {
-      const RecordDecl *RecDecl = RecType->getDecl();
+    if (auto const *RecType = dyn_cast<RecordType>(FieldType)) {
+      RecordDecl const *RecDecl = RecType->getDecl();
       if (RecDecl->getDeclContext() == Owner && !RecDecl->getIdentifier()) {
         if (Context.hasSameType(FieldType, AnonTy))
           break;
@@ -2042,8 +2042,8 @@
   return true;
 }
 
-bool StructuralEquivalenceContext::CheckKindSpecificEquivalence(
-    Decl *D1, Decl *D2) {
+bool StructuralEquivalenceContext::CheckKindSpecificEquivalence(Decl *D1,
+                                                                Decl *D2) {
 
   // Kind mismatch.
   if (D1->getKind() != D2->getKind())
Index: clang/lib/AST/ASTTypeTraits.cpp
===================================================================
--- clang/lib/AST/ASTTypeTraits.cpp
+++ clang/lib/AST/ASTTypeTraits.cpp
@@ -33,13 +33,13 @@
     {NKI_None, "CXXCtorInitializer"},
     {NKI_None, "NestedNameSpecifier"},
     {NKI_None, "Decl"},
-#define DECL(DERIVED, BASE) { NKI_##BASE, #DERIVED "Decl" },
+#define DECL(DERIVED, BASE) {NKI_##BASE, #DERIVED "Decl"},
 #include "clang/AST/DeclNodes.inc"
     {NKI_None, "Stmt"},
-#define STMT(DERIVED, BASE) { NKI_##BASE, #DERIVED },
+#define STMT(DERIVED, BASE) {NKI_##BASE, #DERIVED},
 #include "clang/AST/StmtNodes.inc"
     {NKI_None, "Type"},
-#define TYPE(DERIVED, BASE) { NKI_##BASE, #DERIVED "Type" },
+#define TYPE(DERIVED, BASE) {NKI_##BASE, #DERIVED "Type"},
 #include "clang/AST/TypeNodes.inc"
     {NKI_None, "OMPClause"},
 #define GEN_CLANG_CLAUSE_CLASS
@@ -56,7 +56,8 @@
 
 bool ASTNodeKind::isBaseOf(NodeKindId Base, NodeKindId Derived,
                            unsigned *Distance) {
-  if (Base == NKI_None || Derived == NKI_None) return false;
+  if (Base == NKI_None || Derived == NKI_None)
+    return false;
   unsigned Dist = 0;
   while (Derived != Base && Derived != NKI_None) {
     Derived = AllKindInfo[Derived].ParentId;
@@ -82,8 +83,10 @@
 
 ASTNodeKind ASTNodeKind::getMostDerivedType(ASTNodeKind Kind1,
                                             ASTNodeKind Kind2) {
-  if (Kind1.isBaseOf(Kind2)) return Kind2;
-  if (Kind2.isBaseOf(Kind1)) return Kind1;
+  if (Kind1.isBaseOf(Kind2))
+    return Kind2;
+  if (Kind2.isBaseOf(Kind1))
+    return Kind1;
   return ASTNodeKind();
 }
 
@@ -96,38 +99,42 @@
   return ASTNodeKind(Parent);
 }
 
-ASTNodeKind ASTNodeKind::getFromNode(const Decl &D) {
+ASTNodeKind ASTNodeKind::getFromNode(Decl const &D) {
   switch (D.getKind()) {
 #define DECL(DERIVED, BASE)                                                    \
-    case Decl::DERIVED: return ASTNodeKind(NKI_##DERIVED##Decl);
+  case Decl::DERIVED:                                                          \
+    return ASTNodeKind(NKI_##DERIVED##Decl);
 #define ABSTRACT_DECL(D)
 #include "clang/AST/DeclNodes.inc"
   };
   llvm_unreachable("invalid decl kind");
 }
 
-ASTNodeKind ASTNodeKind::getFromNode(const Stmt &S) {
+ASTNodeKind ASTNodeKind::getFromNode(Stmt const &S) {
   switch (S.getStmtClass()) {
-    case Stmt::NoStmtClass: return NKI_None;
+  case Stmt::NoStmtClass:
+    return NKI_None;
 #define STMT(CLASS, PARENT)                                                    \
-    case Stmt::CLASS##Class: return ASTNodeKind(NKI_##CLASS);
+  case Stmt::CLASS##Class:                                                     \
+    return ASTNodeKind(NKI_##CLASS);
 #define ABSTRACT_STMT(S)
 #include "clang/AST/StmtNodes.inc"
   }
   llvm_unreachable("invalid stmt kind");
 }
 
-ASTNodeKind ASTNodeKind::getFromNode(const Type &T) {
+ASTNodeKind ASTNodeKind::getFromNode(Type const &T) {
   switch (T.getTypeClass()) {
 #define TYPE(Class, Base)                                                      \
-    case Type::Class: return ASTNodeKind(NKI_##Class##Type);
+  case Type::Class:                                                            \
+    return ASTNodeKind(NKI_##Class##Type);
 #define ABSTRACT_TYPE(Class, Base)
 #include "clang/AST/TypeNodes.inc"
   }
   llvm_unreachable("invalid type kind");
- }
+}
 
-ASTNodeKind ASTNodeKind::getFromNode(const OMPClause &C) {
+ASTNodeKind ASTNodeKind::getFromNode(OMPClause const &C) {
   switch (C.getClauseKind()) {
 #define GEN_CLANG_CLAUSE_CLASS
 #define CLAUSE_CLASS(Enum, Str, Class)                                         \
@@ -141,7 +148,7 @@
   llvm_unreachable("invalid omp clause kind");
 }
 
-ASTNodeKind ASTNodeKind::getFromNode(const Attr &A) {
+ASTNodeKind ASTNodeKind::getFromNode(Attr const &A) {
   switch (A.getKind()) {
 #define ATTR(A)                                                                \
   case attr::A:                                                                \
@@ -152,66 +159,66 @@
 }
 
 void DynTypedNode::print(llvm::raw_ostream &OS,
-                         const PrintingPolicy &PP) const {
-  if (const TemplateArgument *TA = get<TemplateArgument>())
+                         PrintingPolicy const &PP) const {
+  if (TemplateArgument const *TA = get<TemplateArgument>())
     TA->print(PP, OS, /*IncludeType*/ true);
-  else if (const TemplateArgumentLoc *TAL = get<TemplateArgumentLoc>())
+  else if (TemplateArgumentLoc const *TAL = get<TemplateArgumentLoc>())
     TAL->getArgument().print(PP, OS, /*IncludeType*/ true);
-  else if (const TemplateName *TN = get<TemplateName>())
+  else if (TemplateName const *TN = get<TemplateName>())
     TN->print(OS, PP);
-  else if (const NestedNameSpecifier *NNS = get<NestedNameSpecifier>())
+  else if (NestedNameSpecifier const *NNS = get<NestedNameSpecifier>())
     NNS->print(OS, PP);
-  else if (const NestedNameSpecifierLoc *NNSL = get<NestedNameSpecifierLoc>()) {
-    if (const NestedNameSpecifier *NNS = NNSL->getNestedNameSpecifier())
+  else if (NestedNameSpecifierLoc const *NNSL = get<NestedNameSpecifierLoc>()) {
+    if (NestedNameSpecifier const *NNS = NNSL->getNestedNameSpecifier())
       NNS->print(OS, PP);
     else
       OS << "(empty NestedNameSpecifierLoc)";
-  } else if (const QualType *QT = get<QualType>())
+  } else if (QualType const *QT = get<QualType>())
     QT->print(OS, PP);
-  else if (const TypeLoc *TL = get<TypeLoc>())
+  else if (TypeLoc const *TL = get<TypeLoc>())
     TL->getType().print(OS, PP);
-  else if (const Decl *D = get<Decl>())
+  else if (Decl const *D = get<Decl>())
     D->print(OS, PP);
-  else if (const Stmt *S = get<Stmt>())
+  else if (Stmt const *S = get<Stmt>())
     S->printPretty(OS, nullptr, PP);
-  else if (const Type *T = get<Type>())
+  else if (Type const *T = get<Type>())
     QualType(T, 0).print(OS, PP);
-  else if (const Attr *A = get<Attr>())
+  else if (Attr const *A = get<Attr>())
     A->printPretty(OS, PP);
   else
     OS << "Unable to print values of type " << NodeKind.asStringRef() << "\n";
 }
 
 void DynTypedNode::dump(llvm::raw_ostream &OS,
-                        const ASTContext &Context) const {
-  if (const Decl *D = get<Decl>())
+                        ASTContext const &Context) const {
+  if (Decl const *D = get<Decl>())
     D->dump(OS);
-  else if (const Stmt *S = get<Stmt>())
+  else if (Stmt const *S = get<Stmt>())
     S->dump(OS, Context);
-  else if (const Type *T = get<Type>())
+  else if (Type const *T = get<Type>())
     T->dump(OS, Context);
   else
     OS << "Unable to dump values of type " << NodeKind.asStringRef() << "\n";
 }
 
 SourceRange DynTypedNode::getSourceRange() const {
-  if (const CXXCtorInitializer *CCI = get<CXXCtorInitializer>())
+  if (CXXCtorInitializer const *CCI = get<CXXCtorInitializer>())
     return CCI->getSourceRange();
-  if (const NestedNameSpecifierLoc *NNSL = get<NestedNameSpecifierLoc>())
+  if (NestedNameSpecifierLoc const *NNSL = get<NestedNameSpecifierLoc>())
     return NNSL->getSourceRange();
-  if (const TypeLoc *TL = get<TypeLoc>())
+  if (TypeLoc const *TL = get<TypeLoc>())
     return TL->getSourceRange();
-  if (const Decl *D = get<Decl>())
+  if (Decl const *D = get<Decl>())
     return D->getSourceRange();
-  if (const Stmt *S = get<Stmt>())
+  if (Stmt const *S = get<Stmt>())
     return S->getSourceRange();
-  if (const TemplateArgumentLoc *TAL = get<TemplateArgumentLoc>())
+  if (TemplateArgumentLoc const *TAL = get<TemplateArgumentLoc>())
     return TAL->getSourceRange();
-  if (const auto *C = get<OMPClause>())
+  if (auto const *C = get<OMPClause>())
     return SourceRange(C->getBeginLoc(), C->getEndLoc());
-  if (const auto *CBS = get<CXXBaseSpecifier>())
+  if (auto const *CBS = get<CXXBaseSpecifier>())
     return CBS->getSourceRange();
-  if (const auto *A = get<Attr>())
+  if (auto const *A = get<Attr>())
     return A->getRange();
   return SourceRange();
 }
Index: clang/lib/AST/AttrDocTable.cpp
===================================================================
--- clang/lib/AST/AttrDocTable.cpp
+++ clang/lib/AST/AttrDocTable.cpp
@@ -21,7 +21,7 @@
 };
 
 llvm::StringRef clang::Attr::getDocumentation(clang::attr::Kind K) {
-  if(K < llvm::array_lengthof(AttrDoc))
+  if (K < llvm::array_lengthof(AttrDoc))
     return AttrDoc[K];
   return "";
 }
Index: clang/lib/AST/AttrImpl.cpp
===================================================================
--- clang/lib/AST/AttrImpl.cpp
+++ clang/lib/AST/AttrImpl.cpp
@@ -17,7 +17,7 @@
 using namespace clang;
 
 void LoopHintAttr::printPrettyPragma(raw_ostream &OS,
-                                     const PrintingPolicy &Policy) const {
+                                     PrintingPolicy const &Policy) const {
   unsigned SpellingIndex = getAttributeSpellingListIndex();
   // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
   // "nounroll" is already emitted as the pragma name.
@@ -36,7 +36,7 @@
 
 // Return a string containing the loop hint argument including the
 // enclosing parentheses.
-std::string LoopHintAttr::getValueString(const PrintingPolicy &Policy) const {
+std::string LoopHintAttr::getValueString(PrintingPolicy const &Policy) const {
   std::string ValueName;
   llvm::raw_string_ostream OS(ValueName);
   OS << "(";
@@ -65,7 +65,7 @@
 
 // Return a string suitable for identifying this attribute in diagnostics.
 std::string
-LoopHintAttr::getDiagnosticName(const PrintingPolicy &Policy) const {
+LoopHintAttr::getDiagnosticName(PrintingPolicy const &Policy) const {
   unsigned SpellingIndex = getAttributeSpellingListIndex();
   if (SpellingIndex == Pragma_nounroll)
     return "#pragma nounroll";
@@ -83,7 +83,7 @@
 }
 
 void OMPDeclareSimdDeclAttr::printPrettyPragma(
-    raw_ostream &OS, const PrintingPolicy &Policy) const {
+    raw_ostream &OS, PrintingPolicy const &Policy) const {
   if (getBranchState() != BS_Undefined)
     OS << ' ' << ConvertBranchStateTyToStr(getBranchState());
   if (auto *E = getSimdlen()) {
@@ -133,7 +133,7 @@
 }
 
 void OMPDeclareTargetDeclAttr::printPrettyPragma(
-    raw_ostream &OS, const PrintingPolicy &Policy) const {
+    raw_ostream &OS, PrintingPolicy const &Policy) const {
   // Use fake syntax because it is for testing and debugging purpose only.
   if (getDevType() != DT_Any)
     OS << " device_type(" << ConvertDevTypeTyToStr(getDevType()) << ")";
@@ -142,7 +142,7 @@
 }
 
 llvm::Optional<OMPDeclareTargetDeclAttr *>
-OMPDeclareTargetDeclAttr::getActiveAttr(const ValueDecl *VD) {
+OMPDeclareTargetDeclAttr::getActiveAttr(ValueDecl const *VD) {
   if (!VD->hasAttrs())
     return llvm::None;
   unsigned Level = 0;
@@ -159,7 +159,7 @@
 }
 
 llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy>
-OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(const ValueDecl *VD) {
+OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(ValueDecl const *VD) {
   llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
   if (ActiveAttr.hasValue())
     return ActiveAttr.getValue()->getMapType();
@@ -167,7 +167,7 @@
 }
 
 llvm::Optional<OMPDeclareTargetDeclAttr::DevTypeTy>
-OMPDeclareTargetDeclAttr::getDeviceType(const ValueDecl *VD) {
+OMPDeclareTargetDeclAttr::getDeviceType(ValueDecl const *VD) {
   llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
   if (ActiveAttr.hasValue())
     return ActiveAttr.getValue()->getDevType();
@@ -175,7 +175,7 @@
 }
 
 llvm::Optional<SourceLocation>
-OMPDeclareTargetDeclAttr::getLocation(const ValueDecl *VD) {
+OMPDeclareTargetDeclAttr::getLocation(ValueDecl const *VD) {
   llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD);
   if (ActiveAttr.hasValue())
     return ActiveAttr.getValue()->getRange().getBegin();
@@ -183,13 +183,13 @@
 }
 
 namespace clang {
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo &TI);
-llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const OMPTraitInfo *TI);
-}
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, OMPTraitInfo const &TI);
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, OMPTraitInfo const *TI);
+} // namespace clang
 
 void OMPDeclareVariantAttr::printPrettyPragma(
-    raw_ostream &OS, const PrintingPolicy &Policy) const {
-  if (const Expr *E = getVariantFuncRef()) {
+    raw_ostream &OS, PrintingPolicy const &Policy) const {
+  if (Expr const *E = getVariantFuncRef()) {
     OS << "(";
     E->printPretty(OS, nullptr, Policy);
     OS << ")";
Index: clang/lib/AST/CXXInheritance.cpp
===================================================================
--- clang/lib/AST/CXXInheritance.cpp
+++ clang/lib/AST/CXXInheritance.cpp
@@ -27,8 +27,8 @@
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include <algorithm>
-#include <utility>
 #include <cassert>
+#include <utility>
 #include <vector>
 
 using namespace clang;
@@ -65,28 +65,28 @@
   std::swap(DetectedVirtual, Other.DetectedVirtual);
 }
 
-bool CXXRecordDecl::isDerivedFrom(const CXXRecordDecl *Base) const {
+bool CXXRecordDecl::isDerivedFrom(CXXRecordDecl const *Base) const {
   CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/false,
                      /*DetectVirtual=*/false);
   return isDerivedFrom(Base, Paths);
 }
 
-bool CXXRecordDecl::isDerivedFrom(const CXXRecordDecl *Base,
+bool CXXRecordDecl::isDerivedFrom(CXXRecordDecl const *Base,
                                   CXXBasePaths &Paths) const {
   if (getCanonicalDecl() == Base->getCanonicalDecl())
     return false;
 
-  Paths.setOrigin(const_cast<CXXRecordDecl*>(this));
+  Paths.setOrigin(const_cast<CXXRecordDecl *>(this));
 
-  const CXXRecordDecl *BaseDecl = Base->getCanonicalDecl();
+  CXXRecordDecl const *BaseDecl = Base->getCanonicalDecl();
   return lookupInBases(
-      [BaseDecl](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
+      [BaseDecl](CXXBaseSpecifier const *Specifier, CXXBasePath &Path) {
         return FindBaseClass(Specifier, Path, BaseDecl);
       },
       Paths);
 }
 
-bool CXXRecordDecl::isVirtuallyDerivedFrom(const CXXRecordDecl *Base) const {
+bool CXXRecordDecl::isVirtuallyDerivedFrom(CXXRecordDecl const *Base) const {
   if (!getNumVBases())
     return false;
 
@@ -96,25 +96,25 @@
   if (getCanonicalDecl() == Base->getCanonicalDecl())
     return false;
 
-  Paths.setOrigin(const_cast<CXXRecordDecl*>(this));
+  Paths.setOrigin(const_cast<CXXRecordDecl *>(this));
 
-  const CXXRecordDecl *BaseDecl = Base->getCanonicalDecl();
+  CXXRecordDecl const *BaseDecl = Base->getCanonicalDecl();
   return lookupInBases(
-      [BaseDecl](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
+      [BaseDecl](CXXBaseSpecifier const *Specifier, CXXBasePath &Path) {
         return FindVirtualBaseClass(Specifier, Path, BaseDecl);
       },
       Paths);
 }
 
-bool CXXRecordDecl::isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const {
-  const CXXRecordDecl *TargetDecl = Base->getCanonicalDecl();
-  return forallBases([TargetDecl](const CXXRecordDecl *Base) {
+bool CXXRecordDecl::isProvablyNotDerivedFrom(CXXRecordDecl const *Base) const {
+  CXXRecordDecl const *TargetDecl = Base->getCanonicalDecl();
+  return forallBases([TargetDecl](CXXRecordDecl const *Base) {
     return Base->getCanonicalDecl() != TargetDecl;
   });
 }
 
-bool
-CXXRecordDecl::isCurrentInstantiation(const DeclContext *CurContext) const {
+bool CXXRecordDecl::isCurrentInstantiation(
+    DeclContext const *CurContext) const {
   assert(isDependentContext());
 
   for (; !CurContext->isFileContext(); CurContext = CurContext->getParent())
@@ -125,20 +125,19 @@
 }
 
 bool CXXRecordDecl::forallBases(ForallBasesCallback BaseMatches) const {
-  SmallVector<const CXXRecordDecl*, 8> Queue;
+  SmallVector<CXXRecordDecl const *, 8> Queue;
 
-  const CXXRecordDecl *Record = this;
+  CXXRecordDecl const *Record = this;
   while (true) {
-    for (const auto &I : Record->bases()) {
-      const RecordType *Ty = I.getType()->getAs<RecordType>();
+    for (auto const &I : Record->bases()) {
+      RecordType const *Ty = I.getType()->getAs<RecordType>();
       if (!Ty)
         return false;
 
       CXXRecordDecl *Base =
-            cast_or_null<CXXRecordDecl>(Ty->getDecl()->getDefinition());
-      if (!Base ||
-          (Base->isDependentContext() &&
-           !Base->isCurrentInstantiation(Record))) {
+          cast_or_null<CXXRecordDecl>(Ty->getDecl()->getDefinition());
+      if (!Base || (Base->isDependentContext() &&
+                    !Base->isCurrentInstantiation(Record))) {
         return false;
       }
 
@@ -156,7 +155,7 @@
 }
 
 bool CXXBasePaths::lookupInBases(ASTContext &Context,
-                                 const CXXRecordDecl *Record,
+                                 CXXRecordDecl const *Record,
                                  CXXRecordDecl::BaseMatchesCallback BaseMatches,
                                  bool LookupInDependent) {
   bool FoundPath = false;
@@ -165,7 +164,7 @@
   AccessSpecifier AccessToHere = ScratchPath.Access;
   bool IsFirstStep = ScratchPath.empty();
 
-  for (const auto &BaseSpec : Record->bases()) {
+  for (auto const &BaseSpec : Record->bases()) {
     // Find the record of the base class subobjects for this type.
     QualType BaseType =
         Context.getCanonicalType(BaseSpec.getType()).getUnqualifiedType();
@@ -225,8 +224,8 @@
       if (IsFirstStep)
         ScratchPath.Access = BaseSpec.getAccessSpecifier();
       else
-        ScratchPath.Access = CXXRecordDecl::MergeAccess(AccessToHere,
-                                                 BaseSpec.getAccessSpecifier());
+        ScratchPath.Access = CXXRecordDecl::MergeAccess(
+            AccessToHere, BaseSpec.getAccessSpecifier());
     }
 
     // Track whether there's a path involving this specific base.
@@ -247,7 +246,7 @@
       CXXRecordDecl *BaseRecord;
       if (LookupInDependent) {
         BaseRecord = nullptr;
-        const TemplateSpecializationType *TST =
+        TemplateSpecializationType const *TST =
             BaseSpec.getType()->getAs<TemplateSpecializationType>();
         if (!TST) {
           if (auto *RT = BaseSpec.getType()->getAs<RecordType>())
@@ -327,7 +326,7 @@
   //
   // FIXME: This is an O(N^2) algorithm, but DPG doesn't see an easy
   // way to make it any faster.
-  Paths.Paths.remove_if([&Paths](const CXXBasePath &Path) {
+  Paths.Paths.remove_if([&Paths](CXXBasePath const &Path) {
     for (const CXXBasePathElement &PE : Path) {
       if (!PE.Base->isVirtual())
         continue;
@@ -360,31 +359,34 @@
   return true;
 }
 
-bool CXXRecordDecl::FindBaseClass(const CXXBaseSpecifier *Specifier,
+bool CXXRecordDecl::FindBaseClass(CXXBaseSpecifier const *Specifier,
                                   CXXBasePath &Path,
-                                  const CXXRecordDecl *BaseRecord) {
+                                  CXXRecordDecl const *BaseRecord) {
   assert(BaseRecord->getCanonicalDecl() == BaseRecord &&
          "User data for FindBaseClass is not canonical!");
-  return Specifier->getType()->castAs<RecordType>()->getDecl()
-            ->getCanonicalDecl() == BaseRecord;
+  return Specifier->getType()
+             ->castAs<RecordType>()
+             ->getDecl()
+             ->getCanonicalDecl() == BaseRecord;
 }
 
-bool CXXRecordDecl::FindVirtualBaseClass(const CXXBaseSpecifier *Specifier,
+bool CXXRecordDecl::FindVirtualBaseClass(CXXBaseSpecifier const *Specifier,
                                          CXXBasePath &Path,
-                                         const CXXRecordDecl *BaseRecord) {
+                                         CXXRecordDecl const *BaseRecord) {
   assert(BaseRecord->getCanonicalDecl() == BaseRecord &&
          "User data for FindBaseClass is not canonical!");
-  return Specifier->isVirtual() &&
-         Specifier->getType()->castAs<RecordType>()->getDecl()
-            ->getCanonicalDecl() == BaseRecord;
+  return Specifier->isVirtual() && Specifier->getType()
+                                           ->castAs<RecordType>()
+                                           ->getDecl()
+                                           ->getCanonicalDecl() == BaseRecord;
 }
 
-static bool isOrdinaryMember(const NamedDecl *ND) {
+static bool isOrdinaryMember(NamedDecl const *ND) {
   return ND->isInIdentifierNamespace(Decl::IDNS_Ordinary | Decl::IDNS_Tag |
                                      Decl::IDNS_Member);
 }
 
-static bool findOrdinaryMember(const CXXRecordDecl *RD, CXXBasePath &Path,
+static bool findOrdinaryMember(CXXRecordDecl const *RD, CXXBasePath &Path,
                                DeclarationName Name) {
   Path.Decls = RD->lookup(Name).begin();
   for (DeclContext::lookup_iterator I = Path.Decls, E = I.end(); I != E; ++I)
@@ -401,7 +403,7 @@
 
   CXXBasePaths Paths(false, false, false);
   return lookupInBases(
-      [Name](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
+      [Name](CXXBaseSpecifier const *Specifier, CXXBasePath &Path) {
         return findOrdinaryMember(Specifier->getType()->getAsCXXRecordDecl(),
                                   Path, Name);
       },
@@ -409,9 +411,9 @@
 }
 
 static bool
-findOrdinaryMemberInDependentClasses(const CXXBaseSpecifier *Specifier,
+findOrdinaryMemberInDependentClasses(CXXBaseSpecifier const *Specifier,
                                      CXXBasePath &Path, DeclarationName Name) {
-  const TemplateSpecializationType *TST =
+  TemplateSpecializationType const *TST =
       Specifier->getType()->getAs<TemplateSpecializationType>();
   if (!TST) {
     auto *RT = Specifier->getType()->getAs<RecordType>();
@@ -420,7 +422,7 @@
     return findOrdinaryMember(cast<CXXRecordDecl>(RT->getDecl()), Path, Name);
   }
   TemplateName TN = TST->getTemplateName();
-  const auto *TD = dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl());
+  auto const *TD = dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl());
   if (!TD)
     return false;
   CXXRecordDecl *RD = TD->getTemplatedDecl();
@@ -429,13 +431,13 @@
   return findOrdinaryMember(RD, Path, Name);
 }
 
-std::vector<const NamedDecl *> CXXRecordDecl::lookupDependentName(
+std::vector<NamedDecl const *> CXXRecordDecl::lookupDependentName(
     DeclarationName Name,
-    llvm::function_ref<bool(const NamedDecl *ND)> Filter) {
-  std::vector<const NamedDecl *> Results;
+    llvm::function_ref<bool(NamedDecl const *ND)> Filter) {
+  std::vector<NamedDecl const *> Results;
   // Lookup in the class.
   bool AnyOrdinaryMembers = false;
-  for (const NamedDecl *ND : lookup(Name)) {
+  for (NamedDecl const *ND : lookup(Name)) {
     if (isOrdinaryMember(ND))
       AnyOrdinaryMembers = true;
     if (Filter(ND))
@@ -448,7 +450,7 @@
   CXXBasePaths Paths;
   Paths.setOrigin(this);
   if (!lookupInBases(
-          [&](const CXXBaseSpecifier *Specifier, CXXBasePath &Path) {
+          [&](CXXBaseSpecifier const *Specifier, CXXBasePath &Path) {
             return findOrdinaryMemberInDependentClasses(Specifier, Path, Name);
           },
           Paths, /*LookupInDependent=*/true))
@@ -463,18 +465,17 @@
 
 void OverridingMethods::add(unsigned OverriddenSubobject,
                             UniqueVirtualMethod Overriding) {
-  SmallVectorImpl<UniqueVirtualMethod> &SubobjectOverrides
-    = Overrides[OverriddenSubobject];
+  SmallVectorImpl<UniqueVirtualMethod> &SubobjectOverrides =
+      Overrides[OverriddenSubobject];
   if (llvm::find(SubobjectOverrides, Overriding) == SubobjectOverrides.end())
     SubobjectOverrides.push_back(Overriding);
 }
 
-void OverridingMethods::add(const OverridingMethods &Other) {
+void OverridingMethods::add(OverridingMethods const &Other) {
   for (const_iterator I = Other.begin(), IE = Other.end(); I != IE; ++I) {
     for (overriding_const_iterator M = I->second.begin(),
-                                MEnd = I->second.end();
-         M != MEnd;
-         ++M)
+                                   MEnd = I->second.end();
+         M != MEnd; ++M)
       add(I->first, *M);
   }
 }
@@ -491,35 +492,35 @@
 class FinalOverriderCollector {
   /// The number of subobjects of a given class type that
   /// occur within the class hierarchy.
-  llvm::DenseMap<const CXXRecordDecl *, unsigned> SubobjectCount;
+  llvm::DenseMap<CXXRecordDecl const *, unsigned> SubobjectCount;
 
   /// Overriders for each virtual base subobject.
-  llvm::DenseMap<const CXXRecordDecl *, CXXFinalOverriderMap *> VirtualOverriders;
+  llvm::DenseMap<CXXRecordDecl const *, CXXFinalOverriderMap *>
+      VirtualOverriders;
 
   CXXFinalOverriderMap FinalOverriders;
 
 public:
   ~FinalOverriderCollector();
 
-  void Collect(const CXXRecordDecl *RD, bool VirtualBase,
-               const CXXRecordDecl *InVirtualSubobject,
+  void Collect(CXXRecordDecl const *RD, bool VirtualBase,
+               CXXRecordDecl const *InVirtualSubobject,
                CXXFinalOverriderMap &Overriders);
 };
 
 } // namespace
 
-void FinalOverriderCollector::Collect(const CXXRecordDecl *RD,
-                                      bool VirtualBase,
-                                      const CXXRecordDecl *InVirtualSubobject,
+void FinalOverriderCollector::Collect(CXXRecordDecl const *RD, bool VirtualBase,
+                                      CXXRecordDecl const *InVirtualSubobject,
                                       CXXFinalOverriderMap &Overriders) {
   unsigned SubobjectNumber = 0;
   if (!VirtualBase)
-    SubobjectNumber
-      = ++SubobjectCount[cast<CXXRecordDecl>(RD->getCanonicalDecl())];
+    SubobjectNumber =
+        ++SubobjectCount[cast<CXXRecordDecl>(RD->getCanonicalDecl())];
 
-  for (const auto &Base : RD->bases()) {
-    if (const RecordType *RT = Base.getType()->getAs<RecordType>()) {
-      const CXXRecordDecl *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
+  for (auto const &Base : RD->bases()) {
+    if (RecordType const *RT = Base.getType()->getAs<RecordType>()) {
+      CXXRecordDecl const *BaseDecl = cast<CXXRecordDecl>(RT->getDecl());
       if (!BaseDecl->isPolymorphic())
         continue;
 
@@ -538,7 +539,8 @@
       CXXFinalOverriderMap ComputedBaseOverriders;
       CXXFinalOverriderMap *BaseOverriders = &ComputedBaseOverriders;
       if (Base.isVirtual()) {
-        CXXFinalOverriderMap *&MyVirtualOverriders = VirtualOverriders[BaseDecl];
+        CXXFinalOverriderMap *&MyVirtualOverriders =
+            VirtualOverriders[BaseDecl];
         BaseOverriders = MyVirtualOverriders;
         if (!MyVirtualOverriders) {
           MyVirtualOverriders = new CXXFinalOverriderMap;
@@ -556,10 +558,9 @@
       // Merge the overriders from this base class into our own set of
       // overriders.
       for (CXXFinalOverriderMap::iterator OM = BaseOverriders->begin(),
-                               OMEnd = BaseOverriders->end();
-           OM != OMEnd;
-           ++OM) {
-        const CXXMethodDecl *CanonOM = OM->first->getCanonicalDecl();
+                                          OMEnd = BaseOverriders->end();
+           OM != OMEnd; ++OM) {
+        CXXMethodDecl const *CanonOM = OM->first->getCanonicalDecl();
         Overriders[CanonOM].add(OM->second);
       }
     }
@@ -582,9 +583,9 @@
 
       // C++ [class.virtual]p2:
       //   For convenience we say that any virtual function overrides itself.
-      Overriders[CanonM].add(SubobjectNumber,
-                             UniqueVirtualMethod(CanonM, SubobjectNumber,
-                                                 InVirtualSubobject));
+      Overriders[CanonM].add(
+          SubobjectNumber,
+          UniqueVirtualMethod(CanonM, SubobjectNumber, InVirtualSubobject));
       continue;
     }
 
@@ -596,8 +597,8 @@
     // overrides.
     SmallVector<OverriddenMethodsRange, 4> Stack(1, OverriddenMethods);
     while (!Stack.empty()) {
-      for (const CXXMethodDecl *OM : Stack.pop_back_val()) {
-        const CXXMethodDecl *CanonOM = OM->getCanonicalDecl();
+      for (CXXMethodDecl const *OM : Stack.pop_back_val()) {
+        CXXMethodDecl const *CanonOM = OM->getCanonicalDecl();
 
         // C++ [class.virtual]p2:
         //   A virtual member function C::vf of a class object S is
@@ -609,8 +610,7 @@
         // replace any overrides from base classes with this
         // overriding virtual function.
         Overriders[CanonOM].replaceAll(
-                               UniqueVirtualMethod(CanonM, SubobjectNumber,
-                                                   InVirtualSubobject));
+            UniqueVirtualMethod(CanonM, SubobjectNumber, InVirtualSubobject));
 
         auto OverriddenMethods = CanonOM->overridden_methods();
         if (OverriddenMethods.begin() == OverriddenMethods.end())
@@ -624,22 +624,22 @@
 
     // C++ [class.virtual]p2:
     //   For convenience we say that any virtual function overrides itself.
-    Overriders[CanonM].add(SubobjectNumber,
-                           UniqueVirtualMethod(CanonM, SubobjectNumber,
-                                               InVirtualSubobject));
+    Overriders[CanonM].add(
+        SubobjectNumber,
+        UniqueVirtualMethod(CanonM, SubobjectNumber, InVirtualSubobject));
   }
 }
 
 FinalOverriderCollector::~FinalOverriderCollector() {
-  for (llvm::DenseMap<const CXXRecordDecl *, CXXFinalOverriderMap *>::iterator
-         VO = VirtualOverriders.begin(), VOEnd = VirtualOverriders.end();
-       VO != VOEnd;
-       ++VO)
+  for (llvm::DenseMap<CXXRecordDecl const *, CXXFinalOverriderMap *>::iterator
+           VO = VirtualOverriders.begin(),
+           VOEnd = VirtualOverriders.end();
+       VO != VOEnd; ++VO)
     delete VO->second;
 }
 
-void
-CXXRecordDecl::getFinalOverriders(CXXFinalOverriderMap &FinalOverriders) const {
+void CXXRecordDecl::getFinalOverriders(
+    CXXFinalOverriderMap &FinalOverriders) const {
   FinalOverriderCollector Collector;
   Collector.Collect(this, false, nullptr, FinalOverriders);
 
@@ -652,7 +652,7 @@
       if (Overriding.size() < 2)
         continue;
 
-      auto IsHidden = [&Overriding](const UniqueVirtualMethod &M) {
+      auto IsHidden = [&Overriding](UniqueVirtualMethod const &M) {
         if (!M.InVirtualSubobject)
           return false;
 
@@ -662,9 +662,8 @@
         // in a base class subobject that hides the virtual base class
         // subobject.
         for (const UniqueVirtualMethod &OP : Overriding)
-          if (&M != &OP &&
-              OP.Method->getParent()->isVirtuallyDerivedFrom(
-                  M.InVirtualSubobject))
+          if (&M != &OP && OP.Method->getParent()->isVirtuallyDerivedFrom(
+                               M.InVirtualSubobject))
             return true;
         return false;
       };
@@ -678,42 +677,41 @@
   }
 }
 
-static void
-AddIndirectPrimaryBases(const CXXRecordDecl *RD, ASTContext &Context,
-                        CXXIndirectPrimaryBaseSet& Bases) {
+static void AddIndirectPrimaryBases(CXXRecordDecl const *RD,
+                                    ASTContext &Context,
+                                    CXXIndirectPrimaryBaseSet &Bases) {
   // If the record has a virtual primary base class, add it to our set.
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
   if (Layout.isPrimaryBaseVirtual())
     Bases.insert(Layout.getPrimaryBase());
 
-  for (const auto &I : RD->bases()) {
+  for (auto const &I : RD->bases()) {
     assert(!I.getType()->isDependentType() &&
            "Cannot get indirect primary bases for class with dependent bases.");
 
-    const CXXRecordDecl *BaseDecl =
-      cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
+    CXXRecordDecl const *BaseDecl =
+        cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
 
     // Only bases with virtual bases participate in computing the
     // indirect primary virtual base classes.
     if (BaseDecl->getNumVBases())
       AddIndirectPrimaryBases(BaseDecl, Context, Bases);
   }
-
 }
 
-void
-CXXRecordDecl::getIndirectPrimaryBases(CXXIndirectPrimaryBaseSet& Bases) const {
+void CXXRecordDecl::getIndirectPrimaryBases(
+    CXXIndirectPrimaryBaseSet &Bases) const {
   ASTContext &Context = getASTContext();
 
   if (!getNumVBases())
     return;
 
-  for (const auto &I : bases()) {
+  for (auto const &I : bases()) {
     assert(!I.getType()->isDependentType() &&
            "Cannot get indirect primary bases for class with dependent bases.");
 
-    const CXXRecordDecl *BaseDecl =
-      cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
+    CXXRecordDecl const *BaseDecl =
+        cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
 
     // Only bases with virtual bases participate in computing the
     // indirect primary virtual base classes.
Index: clang/lib/AST/Comment.cpp
===================================================================
--- clang/lib/AST/Comment.cpp
+++ clang/lib/AST/Comment.cpp
@@ -32,12 +32,13 @@
 static_assert(std::is_trivially_destructible<DeclInfo>::value,
               "DeclInfo should be trivially destructible!");
 
-const char *Comment::getCommentKindName() const {
+char const *Comment::getCommentKindName() const {
   switch (getCommentKind()) {
-  case NoCommentKind: return "NoCommentKind";
+  case NoCommentKind:
+    return "NoCommentKind";
 #define ABSTRACT_COMMENT(COMMENT)
-#define COMMENT(CLASS, PARENT) \
-  case CLASS##Kind: \
+#define COMMENT(CLASS, PARENT)                                                 \
+  case CLASS##Kind:                                                            \
     return #CLASS;
 #include "clang/AST/CommentNodes.inc"
 #undef COMMENT
@@ -56,19 +57,19 @@
 }
 
 LLVM_ATTRIBUTE_UNUSED
-static inline bad implements_child_begin_end(
-                      Comment::child_iterator (Comment::*)() const) {
+inline static bad
+implements_child_begin_end(Comment::child_iterator (Comment::*)() const) {
   return bad();
 }
 
-#define ASSERT_IMPLEMENTS_child_begin(function) \
-  (void) good(implements_child_begin_end(function))
+#define ASSERT_IMPLEMENTS_child_begin(function)                                \
+  (void)good(implements_child_begin_end(function))
 
 LLVM_ATTRIBUTE_UNUSED
-static inline void CheckCommentASTNodes() {
+inline static void CheckCommentASTNodes() {
 #define ABSTRACT_COMMENT(COMMENT)
-#define COMMENT(CLASS, PARENT) \
-  ASSERT_IMPLEMENTS_child_begin(&CLASS::child_begin); \
+#define COMMENT(CLASS, PARENT)                                                 \
+  ASSERT_IMPLEMENTS_child_begin(&CLASS::child_begin);                          \
   ASSERT_IMPLEMENTS_child_begin(&CLASS::child_end);
 #include "clang/AST/CommentNodes.inc"
 #undef COMMENT
@@ -81,10 +82,11 @@
 
 Comment::child_iterator Comment::child_begin() const {
   switch (getCommentKind()) {
-  case NoCommentKind: llvm_unreachable("comment without a kind");
+  case NoCommentKind:
+    llvm_unreachable("comment without a kind");
 #define ABSTRACT_COMMENT(COMMENT)
-#define COMMENT(CLASS, PARENT) \
-  case CLASS##Kind: \
+#define COMMENT(CLASS, PARENT)                                                 \
+  case CLASS##Kind:                                                            \
     return static_cast<const CLASS *>(this)->child_begin();
 #include "clang/AST/CommentNodes.inc"
 #undef COMMENT
@@ -95,10 +97,11 @@
 
 Comment::child_iterator Comment::child_end() const {
   switch (getCommentKind()) {
-  case NoCommentKind: llvm_unreachable("comment without a kind");
+  case NoCommentKind:
+    llvm_unreachable("comment without a kind");
 #define ABSTRACT_COMMENT(COMMENT)
-#define COMMENT(CLASS, PARENT) \
-  case CLASS##Kind: \
+#define COMMENT(CLASS, PARENT)                                                 \
+  case CLASS##Kind:                                                            \
     return static_cast<const CLASS *>(this)->child_end();
 #include "clang/AST/CommentNodes.inc"
 #undef COMMENT
@@ -108,8 +111,8 @@
 }
 
 bool TextComment::isWhitespaceNoCache() const {
-  for (StringRef::const_iterator I = Text.begin(), E = Text.end();
-       I != E; ++I) {
+  for (StringRef::const_iterator I = Text.begin(), E = Text.end(); I != E;
+       ++I) {
     if (!clang::isWhitespace(*I))
       return false;
   }
@@ -118,7 +121,7 @@
 
 bool ParagraphComment::isWhitespaceNoCache() const {
   for (child_iterator I = child_begin(), E = child_end(); I != E; ++I) {
-    if (const TextComment *TC = dyn_cast<TextComment>(*I)) {
+    if (TextComment const *TC = dyn_cast<TextComment>(*I)) {
       if (!TC->isWhitespace())
         return false;
     } else
@@ -189,7 +192,7 @@
   return false;
 }
 
-const char *ParamCommandComment::getDirectionAsString(PassDirection D) {
+char const *ParamCommandComment::getDirectionAsString(PassDirection D) {
   switch (D) {
   case ParamCommandComment::In:
     return "[in]";
@@ -230,27 +233,26 @@
   case Decl::CXXConstructor:
   case Decl::CXXDestructor:
   case Decl::CXXConversion: {
-    const FunctionDecl *FD = cast<FunctionDecl>(CommentDecl);
+    FunctionDecl const *FD = cast<FunctionDecl>(CommentDecl);
     Kind = FunctionKind;
     ParamVars = FD->parameters();
     ReturnType = FD->getReturnType();
     unsigned NumLists = FD->getNumTemplateParameterLists();
     if (NumLists != 0) {
       TemplateKind = TemplateSpecialization;
-      TemplateParameters =
-          FD->getTemplateParameterList(NumLists - 1);
+      TemplateParameters = FD->getTemplateParameterList(NumLists - 1);
     }
 
     if (K == Decl::CXXMethod || K == Decl::CXXConstructor ||
         K == Decl::CXXDestructor || K == Decl::CXXConversion) {
-      const CXXMethodDecl *MD = cast<CXXMethodDecl>(CommentDecl);
+      CXXMethodDecl const *MD = cast<CXXMethodDecl>(CommentDecl);
       IsInstanceMethod = MD->isInstance();
       IsClassMethod = !IsInstanceMethod;
     }
     break;
   }
   case Decl::ObjCMethod: {
-    const ObjCMethodDecl *MD = cast<ObjCMethodDecl>(CommentDecl);
+    ObjCMethodDecl const *MD = cast<ObjCMethodDecl>(CommentDecl);
     Kind = FunctionKind;
     ParamVars = MD->parameters();
     ReturnType = MD->getReturnType();
@@ -260,24 +262,24 @@
     break;
   }
   case Decl::FunctionTemplate: {
-    const FunctionTemplateDecl *FTD = cast<FunctionTemplateDecl>(CommentDecl);
+    FunctionTemplateDecl const *FTD = cast<FunctionTemplateDecl>(CommentDecl);
     Kind = FunctionKind;
     TemplateKind = Template;
-    const FunctionDecl *FD = FTD->getTemplatedDecl();
+    FunctionDecl const *FD = FTD->getTemplatedDecl();
     ParamVars = FD->parameters();
     ReturnType = FD->getReturnType();
     TemplateParameters = FTD->getTemplateParameters();
     break;
   }
   case Decl::ClassTemplate: {
-    const ClassTemplateDecl *CTD = cast<ClassTemplateDecl>(CommentDecl);
+    ClassTemplateDecl const *CTD = cast<ClassTemplateDecl>(CommentDecl);
     Kind = ClassKind;
     TemplateKind = Template;
     TemplateParameters = CTD->getTemplateParameters();
     break;
   }
   case Decl::ClassTemplatePartialSpecialization: {
-    const ClassTemplatePartialSpecializationDecl *CTPSD =
+    ClassTemplatePartialSpecializationDecl const *CTPSD =
         cast<ClassTemplatePartialSpecializationDecl>(CommentDecl);
     Kind = ClassKind;
     TemplateKind = TemplatePartialSpecialization;
@@ -298,10 +300,10 @@
   case Decl::ObjCIvar:
   case Decl::ObjCAtDefsField:
   case Decl::ObjCProperty: {
-    const TypeSourceInfo *TSI;
-    if (const auto *VD = dyn_cast<DeclaratorDecl>(CommentDecl))
+    TypeSourceInfo const *TSI;
+    if (auto const *VD = dyn_cast<DeclaratorDecl>(CommentDecl))
       TSI = VD->getTypeSourceInfo();
-    else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(CommentDecl))
+    else if (auto const *PD = dyn_cast<ObjCPropertyDecl>(CommentDecl))
       TSI = PD->getTypeSourceInfo();
     else
       TSI = nullptr;
@@ -324,7 +326,7 @@
     Kind = TypedefKind;
     // If this is a typedef / using to something we consider a function, extract
     // arguments and return type.
-    const TypeSourceInfo *TSI =
+    TypeSourceInfo const *TSI =
         K == Decl::Typedef
             ? cast<TypedefDecl>(CommentDecl)->getTypeSourceInfo()
             : cast<TypeAliasDecl>(CommentDecl)->getTypeSourceInfo();
@@ -340,7 +342,7 @@
     break;
   }
   case Decl::TypeAliasTemplate: {
-    const TypeAliasTemplateDecl *TAT = cast<TypeAliasTemplateDecl>(CommentDecl);
+    TypeAliasTemplateDecl const *TAT = cast<TypeAliasTemplateDecl>(CommentDecl);
     Kind = TypedefKind;
     TemplateKind = Template;
     TemplateParameters = TAT->getTemplateParameters();
@@ -348,7 +350,7 @@
     if (!TAD)
       break;
 
-    const TypeSourceInfo *TSI = TAD->getTypeSourceInfo();
+    TypeSourceInfo const *TSI = TAD->getTypeSourceInfo();
     if (!TSI)
       break;
     TypeLoc TL = TSI->getTypeLoc().getUnqualifiedLoc();
@@ -368,21 +370,21 @@
   IsFilled = true;
 }
 
-StringRef ParamCommandComment::getParamName(const FullComment *FC) const {
+StringRef ParamCommandComment::getParamName(FullComment const *FC) const {
   assert(isParamIndexValid());
   if (isVarArgParam())
     return "...";
   return FC->getDeclInfo()->ParamVars[getParamIndex()]->getName();
 }
 
-StringRef TParamCommandComment::getParamName(const FullComment *FC) const {
+StringRef TParamCommandComment::getParamName(FullComment const *FC) const {
   assert(isPositionValid());
-  const TemplateParameterList *TPL = FC->getDeclInfo()->TemplateParameters;
+  TemplateParameterList const *TPL = FC->getDeclInfo()->TemplateParameters;
   for (unsigned i = 0, e = getDepth(); i != e; ++i) {
     assert(TPL && "Unknown TemplateParameterList");
     if (i == e - 1)
       return TPL->getParam(getIndex(i))->getName();
-    const NamedDecl *Param = TPL->getParam(getIndex(i));
+    NamedDecl const *Param = TPL->getParam(getIndex(i));
     if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param))
       TPL = TTP->getTemplateParameters();
   }
@@ -391,4 +393,3 @@
 
 } // end namespace comments
 } // end namespace clang
-
Index: clang/lib/AST/CommentBriefParser.cpp
===================================================================
--- clang/lib/AST/CommentBriefParser.cpp
+++ clang/lib/AST/CommentBriefParser.cpp
@@ -14,8 +14,8 @@
 
 namespace {
 inline bool isWhitespace(char C) {
-  return C == ' ' || C == '\n' || C == '\r' ||
-         C == '\t' || C == '\f' || C == '\v';
+  return C == ' ' || C == '\n' || C == '\r' || C == '\t' || C == '\f' ||
+         C == '\v';
 }
 
 /// Convert all whitespace into spaces, remove leading and trailing spaces,
@@ -23,9 +23,8 @@
 void cleanupBrief(std::string &S) {
   bool PrevWasSpace = true;
   std::string::iterator O = S.begin();
-  for (std::string::iterator I = S.begin(), E = S.end();
-       I != E; ++I) {
-    const char C = *I;
+  for (std::string::iterator I = S.begin(), E = S.end(); I != E; ++I) {
+    char const C = *I;
     if (isWhitespace(C)) {
       if (!PrevWasSpace) {
         *O++ = ' ';
@@ -44,8 +43,8 @@
 }
 
 bool isWhitespace(StringRef Text) {
-  for (StringRef::const_iterator I = Text.begin(), E = Text.end();
-       I != E; ++I) {
+  for (StringRef::const_iterator I = Text.begin(), E = Text.end(); I != E;
+       ++I) {
     if (!isWhitespace(*I))
       return false;
   }
@@ -53,8 +52,8 @@
 }
 } // unnamed namespace
 
-BriefParser::BriefParser(Lexer &L, const CommandTraits &Traits) :
-    L(L), Traits(Traits) {
+BriefParser::BriefParser(Lexer &L, CommandTraits const &Traits)
+    : L(L), Traits(Traits) {
   // Get lookahead token.
   ConsumeToken();
 }
@@ -77,7 +76,7 @@
     }
 
     if (Tok.is(tok::backslash_command) || Tok.is(tok::at_command)) {
-      const CommandInfo *Info = Traits.getCommandInfo(Tok.getCommandID());
+      CommandInfo const *Info = Traits.getCommandInfo(Tok.getCommandID());
       if (Info->IsBriefCommand) {
         FirstParagraphOrBrief.clear();
         InBrief = true;
@@ -149,5 +148,3 @@
 
 } // end namespace comments
 } // end namespace clang
-
-
Index: clang/lib/AST/CommentCommandTraits.cpp
===================================================================
--- clang/lib/AST/CommentCommandTraits.cpp
+++ clang/lib/AST/CommentCommandTraits.cpp
@@ -16,13 +16,13 @@
 #include "clang/AST/CommentCommandInfo.inc"
 
 CommandTraits::CommandTraits(llvm::BumpPtrAllocator &Allocator,
-                             const CommentOptions &CommentOptions) :
-    NextID(llvm::array_lengthof(Commands)), Allocator(Allocator) {
+                             CommentOptions const &CommentOptions)
+    : NextID(llvm::array_lengthof(Commands)), Allocator(Allocator) {
   registerCommentOptions(CommentOptions);
 }
 
 void CommandTraits::registerCommentOptions(
-    const CommentOptions &CommentOptions) {
+    CommentOptions const &CommentOptions) {
   for (CommentOptions::BlockCommandNamesTy::const_iterator
            I = CommentOptions.BlockCommandNames.begin(),
            E = CommentOptions.BlockCommandNames.end();
@@ -31,19 +31,19 @@
   }
 }
 
-const CommandInfo *CommandTraits::getCommandInfoOrNULL(StringRef Name) const {
-  if (const CommandInfo *Info = getBuiltinCommandInfo(Name))
+CommandInfo const *CommandTraits::getCommandInfoOrNULL(StringRef Name) const {
+  if (CommandInfo const *Info = getBuiltinCommandInfo(Name))
     return Info;
   return getRegisteredCommandInfo(Name);
 }
 
-const CommandInfo *CommandTraits::getCommandInfo(unsigned CommandID) const {
-  if (const CommandInfo *Info = getBuiltinCommandInfo(CommandID))
+CommandInfo const *CommandTraits::getCommandInfo(unsigned CommandID) const {
+  if (CommandInfo const *Info = getBuiltinCommandInfo(CommandID))
     return Info;
   return getRegisteredCommandInfo(CommandID);
 }
 
-const CommandInfo *
+CommandInfo const *
 CommandTraits::getTypoCorrectCommandInfo(StringRef Typo) const {
   // Single-character command impostures, such as \t or \n, should not go
   // through the fixit logic.
@@ -51,12 +51,12 @@
     return nullptr;
 
   // The maximum edit distance we're prepared to accept.
-  const unsigned MaxEditDistance = 1;
+  unsigned const MaxEditDistance = 1;
 
   unsigned BestEditDistance = MaxEditDistance;
-  SmallVector<const CommandInfo *, 2> BestCommand;
+  SmallVector<CommandInfo const *, 2> BestCommand;
 
-  auto ConsiderCorrection = [&](const CommandInfo *Command) {
+  auto ConsiderCorrection = [&](CommandInfo const *Command) {
     StringRef Name = Command->Name;
 
     unsigned MinPossibleEditDistance = abs((int)Name.size() - (int)Typo.size());
@@ -71,10 +71,10 @@
     }
   };
 
-  for (const auto &Command : Commands)
+  for (auto const &Command : Commands)
     ConsiderCorrection(&Command);
 
-  for (const auto *Command : RegisteredCommands)
+  for (auto const *Command : RegisteredCommands)
     if (!Command->IsUnknownCommand)
       ConsiderCorrection(Command);
 
@@ -91,8 +91,8 @@
   Info->Name = Name;
   // We only have a limited number of bits to encode command IDs in the
   // CommandInfo structure, so the ID numbers can potentially wrap around.
-  assert((NextID < (1 << CommandInfo::NumCommandIDBits))
-         && "Too many commands. We have limited bits for the command ID.");
+  assert((NextID < (1 << CommandInfo::NumCommandIDBits)) &&
+         "Too many commands. We have limited bits for the command ID.");
   Info->ID = NextID++;
 
   RegisteredCommands.push_back(Info);
@@ -100,28 +100,27 @@
   return Info;
 }
 
-const CommandInfo *CommandTraits::registerUnknownCommand(
-                                                  StringRef CommandName) {
+CommandInfo const *
+CommandTraits::registerUnknownCommand(StringRef CommandName) {
   CommandInfo *Info = createCommandInfoWithName(CommandName);
   Info->IsUnknownCommand = true;
   return Info;
 }
 
-const CommandInfo *CommandTraits::registerBlockCommand(StringRef CommandName) {
+CommandInfo const *CommandTraits::registerBlockCommand(StringRef CommandName) {
   CommandInfo *Info = createCommandInfoWithName(CommandName);
   Info->IsBlockCommand = true;
   return Info;
 }
 
-const CommandInfo *CommandTraits::getBuiltinCommandInfo(
-                                                  unsigned CommandID) {
+CommandInfo const *CommandTraits::getBuiltinCommandInfo(unsigned CommandID) {
   if (CommandID < llvm::array_lengthof(Commands))
     return &Commands[CommandID];
   return nullptr;
 }
 
-const CommandInfo *CommandTraits::getRegisteredCommandInfo(
-                                                  StringRef Name) const {
+CommandInfo const *
+CommandTraits::getRegisteredCommandInfo(StringRef Name) const {
   for (unsigned i = 0, e = RegisteredCommands.size(); i != e; ++i) {
     if (RegisteredCommands[i]->Name == Name)
       return RegisteredCommands[i];
@@ -129,11 +128,10 @@
   return nullptr;
 }
 
-const CommandInfo *CommandTraits::getRegisteredCommandInfo(
-                                                  unsigned CommandID) const {
+CommandInfo const *
+CommandTraits::getRegisteredCommandInfo(unsigned CommandID) const {
   return RegisteredCommands[CommandID - llvm::array_lengthof(Commands)];
 }
 
 } // end namespace comments
 } // end namespace clang
-
Index: clang/lib/AST/CommentLexer.cpp
===================================================================
--- clang/lib/AST/CommentLexer.cpp
+++ clang/lib/AST/CommentLexer.cpp
@@ -18,27 +18,26 @@
 namespace clang {
 namespace comments {
 
-void Token::dump(const Lexer &L, const SourceManager &SM) const {
+void Token::dump(Lexer const &L, SourceManager const &SM) const {
   llvm::errs() << "comments::Token Kind=" << Kind << " ";
   Loc.print(llvm::errs(), SM);
   llvm::errs() << " " << Length << " \"" << L.getSpelling(*this, SM) << "\"\n";
 }
 
-static inline bool isHTMLNamedCharacterReferenceCharacter(char C) {
+inline static bool isHTMLNamedCharacterReferenceCharacter(char C) {
   return isLetter(C);
 }
 
-static inline bool isHTMLDecimalCharacterReferenceCharacter(char C) {
+inline static bool isHTMLDecimalCharacterReferenceCharacter(char C) {
   return isDigit(C);
 }
 
-static inline bool isHTMLHexCharacterReferenceCharacter(char C) {
+inline static bool isHTMLHexCharacterReferenceCharacter(char C) {
   return isHexDigit(C);
 }
 
-static inline StringRef convertCodePointToUTF8(
-                                      llvm::BumpPtrAllocator &Allocator,
-                                      unsigned CodePoint) {
+inline static StringRef
+convertCodePointToUTF8(llvm::BumpPtrAllocator &Allocator, unsigned CodePoint) {
   char *Resolved = Allocator.Allocate<char>(UNI_MAX_UTF8_BYTES_PER_CODE_POINT);
   char *ResolvedPtr = Resolved;
   if (llvm::ConvertCodePointToUTF8(CodePoint, ResolvedPtr))
@@ -49,8 +48,8 @@
 
 namespace {
 
-#include "clang/AST/CommentHTMLTags.inc"
 #include "clang/AST/CommentHTMLNamedCharacterReferences.inc"
+#include "clang/AST/CommentHTMLTags.inc"
 
 } // end anonymous namespace
 
@@ -80,7 +79,7 @@
   unsigned CodePoint = 0;
   for (unsigned i = 0, e = Name.size(); i != e; ++i) {
     CodePoint *= 16;
-    const char C = Name[i];
+    char const C = Name[i];
     assert(isHTMLHexCharacterReferenceCharacter(C));
     CodePoint += llvm::hexDigitValue(C);
   }
@@ -99,7 +98,7 @@
   case '\t':
   case '\f':
   case '\v': {
-    const char *NewBufferPtr = BufferPtr;
+    char const *NewBufferPtr = BufferPtr;
     NewBufferPtr++;
     if (NewBufferPtr == CommentEnd)
       return;
@@ -123,15 +122,15 @@
 
 namespace {
 /// Returns pointer to the first newline character in the string.
-const char *findNewline(const char *BufferPtr, const char *BufferEnd) {
-  for ( ; BufferPtr != BufferEnd; ++BufferPtr) {
+char const *findNewline(char const *BufferPtr, char const *BufferEnd) {
+  for (; BufferPtr != BufferEnd; ++BufferPtr) {
     if (isVerticalWhitespace(*BufferPtr))
       return BufferPtr;
   }
   return BufferEnd;
 }
 
-const char *skipNewline(const char *BufferPtr, const char *BufferEnd) {
+char const *skipNewline(char const *BufferPtr, char const *BufferEnd) {
   if (BufferPtr == BufferEnd)
     return BufferPtr;
 
@@ -146,43 +145,39 @@
   return BufferPtr;
 }
 
-const char *skipNamedCharacterReference(const char *BufferPtr,
-                                        const char *BufferEnd) {
-  for ( ; BufferPtr != BufferEnd; ++BufferPtr) {
+char const *skipNamedCharacterReference(char const *BufferPtr,
+                                        char const *BufferEnd) {
+  for (; BufferPtr != BufferEnd; ++BufferPtr) {
     if (!isHTMLNamedCharacterReferenceCharacter(*BufferPtr))
       return BufferPtr;
   }
   return BufferEnd;
 }
 
-const char *skipDecimalCharacterReference(const char *BufferPtr,
-                                          const char *BufferEnd) {
-  for ( ; BufferPtr != BufferEnd; ++BufferPtr) {
+char const *skipDecimalCharacterReference(char const *BufferPtr,
+                                          char const *BufferEnd) {
+  for (; BufferPtr != BufferEnd; ++BufferPtr) {
     if (!isHTMLDecimalCharacterReferenceCharacter(*BufferPtr))
       return BufferPtr;
   }
   return BufferEnd;
 }
 
-const char *skipHexCharacterReference(const char *BufferPtr,
-                                      const char *BufferEnd) {
-  for ( ; BufferPtr != BufferEnd; ++BufferPtr) {
+char const *skipHexCharacterReference(char const *BufferPtr,
+                                      char const *BufferEnd) {
+  for (; BufferPtr != BufferEnd; ++BufferPtr) {
     if (!isHTMLHexCharacterReferenceCharacter(*BufferPtr))
       return BufferPtr;
   }
   return BufferEnd;
 }
 
-bool isHTMLIdentifierStartingCharacter(char C) {
-  return isLetter(C);
-}
+bool isHTMLIdentifierStartingCharacter(char C) { return isLetter(C); }
 
-bool isHTMLIdentifierCharacter(char C) {
-  return isAlphanumeric(C);
-}
+bool isHTMLIdentifierCharacter(char C) { return isAlphanumeric(C); }
 
-const char *skipHTMLIdentifier(const char *BufferPtr, const char *BufferEnd) {
-  for ( ; BufferPtr != BufferEnd; ++BufferPtr) {
+char const *skipHTMLIdentifier(char const *BufferPtr, char const *BufferEnd) {
+  for (; BufferPtr != BufferEnd; ++BufferPtr) {
     if (!isHTMLIdentifierCharacter(*BufferPtr))
       return BufferPtr;
   }
@@ -193,42 +188,37 @@
 /// string allowed.
 ///
 /// Returns pointer to closing quote.
-const char *skipHTMLQuotedString(const char *BufferPtr, const char *BufferEnd)
-{
-  const char Quote = *BufferPtr;
+char const *skipHTMLQuotedString(char const *BufferPtr, char const *BufferEnd) {
+  char const Quote = *BufferPtr;
   assert(Quote == '\"' || Quote == '\'');
 
   BufferPtr++;
-  for ( ; BufferPtr != BufferEnd; ++BufferPtr) {
-    const char C = *BufferPtr;
+  for (; BufferPtr != BufferEnd; ++BufferPtr) {
+    char const C = *BufferPtr;
     if (C == Quote && BufferPtr[-1] != '\\')
       return BufferPtr;
   }
   return BufferEnd;
 }
 
-const char *skipWhitespace(const char *BufferPtr, const char *BufferEnd) {
-  for ( ; BufferPtr != BufferEnd; ++BufferPtr) {
+char const *skipWhitespace(char const *BufferPtr, char const *BufferEnd) {
+  for (; BufferPtr != BufferEnd; ++BufferPtr) {
     if (!isWhitespace(*BufferPtr))
       return BufferPtr;
   }
   return BufferEnd;
 }
 
-bool isWhitespace(const char *BufferPtr, const char *BufferEnd) {
+bool isWhitespace(char const *BufferPtr, char const *BufferEnd) {
   return skipWhitespace(BufferPtr, BufferEnd) == BufferEnd;
 }
 
-bool isCommandNameStartCharacter(char C) {
-  return isLetter(C);
-}
+bool isCommandNameStartCharacter(char C) { return isLetter(C); }
 
-bool isCommandNameCharacter(char C) {
-  return isAlphanumeric(C);
-}
+bool isCommandNameCharacter(char C) { return isAlphanumeric(C); }
 
-const char *skipCommandName(const char *BufferPtr, const char *BufferEnd) {
-  for ( ; BufferPtr != BufferEnd; ++BufferPtr) {
+char const *skipCommandName(char const *BufferPtr, char const *BufferEnd) {
+  for (; BufferPtr != BufferEnd; ++BufferPtr) {
     if (!isCommandNameCharacter(*BufferPtr))
       return BufferPtr;
   }
@@ -237,8 +227,8 @@
 
 /// Return the one past end pointer for BCPL comments.
 /// Handles newlines escaped with backslash or trigraph for backslahs.
-const char *findBCPLCommentEnd(const char *BufferPtr, const char *BufferEnd) {
-  const char *CurPtr = BufferPtr;
+char const *findBCPLCommentEnd(char const *BufferPtr, char const *BufferEnd) {
+  char const *CurPtr = BufferPtr;
   while (CurPtr != BufferEnd) {
     while (!isVerticalWhitespace(*CurPtr)) {
       CurPtr++;
@@ -246,8 +236,8 @@
         return BufferEnd;
     }
     // We found a newline, check if it is escaped.
-    const char *EscapePtr = CurPtr - 1;
-    while(isHorizontalWhitespace(*EscapePtr))
+    char const *EscapePtr = CurPtr - 1;
+    while (isHorizontalWhitespace(*EscapePtr))
       EscapePtr--;
 
     if (*EscapePtr == '\\' ||
@@ -263,8 +253,8 @@
 
 /// Return the one past end pointer for C comments.
 /// Very dumb, does not handle escaped newlines or trigraphs.
-const char *findCCommentEnd(const char *BufferPtr, const char *BufferEnd) {
-  for ( ; BufferPtr != BufferEnd; ++BufferPtr) {
+char const *findCCommentEnd(char const *BufferPtr, char const *BufferEnd) {
+  for (; BufferPtr != BufferEnd; ++BufferPtr) {
     if (*BufferPtr == '*') {
       assert(BufferPtr + 1 != BufferEnd);
       if (*(BufferPtr + 1) == '/')
@@ -276,9 +266,9 @@
 
 } // end anonymous namespace
 
-void Lexer::formTokenWithChars(Token &Result, const char *TokEnd,
+void Lexer::formTokenWithChars(Token &Result, char const *TokEnd,
                                tok::TokenKind Kind) {
-  const unsigned TokLen = TokEnd - BufferPtr;
+  unsigned const TokLen = TokEnd - BufferPtr;
   Result.setLocation(getSourceLocation(BufferPtr));
   Result.setKind(Kind);
   Result.setLength(TokLen);
@@ -300,26 +290,26 @@
     const char *TokenPtr = BufferPtr;
     assert(TokenPtr < CommentEnd);
     switch (*TokenPtr) {
-      case '\n':
-      case '\r':
-          TokenPtr = skipNewline(TokenPtr, CommentEnd);
-          formTokenWithChars(T, TokenPtr, tok::newline);
-
-          if (CommentState == LCS_InsideCComment)
-            skipLineStartingDecorations();
-          return;
-
-      default: {
-          StringRef TokStartSymbols = ParseCommands ? "\n\r\\@&<" : "\n\r";
-          size_t End = StringRef(TokenPtr, CommentEnd - TokenPtr)
-                           .find_first_of(TokStartSymbols);
-          if (End != StringRef::npos)
-            TokenPtr += End;
-          else
-            TokenPtr = CommentEnd;
-          formTextToken(T, TokenPtr);
-          return;
-      }
+    case '\n':
+    case '\r':
+      TokenPtr = skipNewline(TokenPtr, CommentEnd);
+      formTokenWithChars(T, TokenPtr, tok::newline);
+
+      if (CommentState == LCS_InsideCComment)
+        skipLineStartingDecorations();
+      return;
+
+    default: {
+      StringRef TokStartSymbols = ParseCommands ? "\n\r\\@&<" : "\n\r";
+      size_t End = StringRef(TokenPtr, CommentEnd - TokenPtr)
+                       .find_first_of(TokStartSymbols);
+      if (End != StringRef::npos)
+        TokenPtr += End;
+      else
+        TokenPtr = CommentEnd;
+      formTextToken(T, TokenPtr);
+      return;
+    }
     }
   };
 
@@ -347,122 +337,129 @@
   }
 
   assert(State == LS_Normal);
-  const char *TokenPtr = BufferPtr;
+  char const *TokenPtr = BufferPtr;
   assert(TokenPtr < CommentEnd);
-  switch(*TokenPtr) {
+  switch (*TokenPtr) {
+  case '\\':
+  case '@': {
+    // Commands that start with a backslash and commands that start with
+    // 'at' have equivalent semantics.  But we keep information about the
+    // exact syntax in AST for comments.
+    tok::TokenKind CommandKind =
+        (*TokenPtr == '@') ? tok::at_command : tok::backslash_command;
+    TokenPtr++;
+    if (TokenPtr == CommentEnd) {
+      formTextToken(T, TokenPtr);
+      return;
+    }
+    char C = *TokenPtr;
+    switch (C) {
+    default:
+      break;
+
     case '\\':
-    case '@': {
-      // Commands that start with a backslash and commands that start with
-      // 'at' have equivalent semantics.  But we keep information about the
-      // exact syntax in AST for comments.
-      tok::TokenKind CommandKind =
-          (*TokenPtr == '@') ? tok::at_command : tok::backslash_command;
+    case '@':
+    case '&':
+    case '$':
+    case '#':
+    case '<':
+    case '>':
+    case '%':
+    case '\"':
+    case '.':
+    case ':':
+      // This is one of \\ \@ \& \$ etc escape sequences.
       TokenPtr++;
-      if (TokenPtr == CommentEnd) {
-        formTextToken(T, TokenPtr);
-        return;
-      }
-      char C = *TokenPtr;
-      switch (C) {
-      default:
-        break;
-
-      case '\\': case '@': case '&': case '$':
-      case '#':  case '<': case '>': case '%':
-      case '\"': case '.': case ':':
-        // This is one of \\ \@ \& \$ etc escape sequences.
+      if (C == ':' && TokenPtr != CommentEnd && *TokenPtr == ':') {
+        // This is the \:: escape sequence.
         TokenPtr++;
-        if (C == ':' && TokenPtr != CommentEnd && *TokenPtr == ':') {
-          // This is the \:: escape sequence.
-          TokenPtr++;
-        }
-        StringRef UnescapedText(BufferPtr + 1, TokenPtr - (BufferPtr + 1));
-        formTokenWithChars(T, TokenPtr, tok::text);
-        T.setText(UnescapedText);
-        return;
       }
+      StringRef UnescapedText(BufferPtr + 1, TokenPtr - (BufferPtr + 1));
+      formTokenWithChars(T, TokenPtr, tok::text);
+      T.setText(UnescapedText);
+      return;
+    }
 
-      // Don't make zero-length commands.
-      if (!isCommandNameStartCharacter(*TokenPtr)) {
-        formTextToken(T, TokenPtr);
-        return;
-      }
+    // Don't make zero-length commands.
+    if (!isCommandNameStartCharacter(*TokenPtr)) {
+      formTextToken(T, TokenPtr);
+      return;
+    }
+
+    TokenPtr = skipCommandName(TokenPtr, CommentEnd);
+    unsigned Length = TokenPtr - (BufferPtr + 1);
 
-      TokenPtr = skipCommandName(TokenPtr, CommentEnd);
-      unsigned Length = TokenPtr - (BufferPtr + 1);
-
-      // Hardcoded support for lexing LaTeX formula commands
-      // \f$ \f[ \f] \f{ \f} as a single command.
-      if (Length == 1 && TokenPtr[-1] == 'f' && TokenPtr != CommentEnd) {
-        C = *TokenPtr;
-        if (C == '$' || C == '[' || C == ']' || C == '{' || C == '}') {
-          TokenPtr++;
-          Length++;
-        }
+    // Hardcoded support for lexing LaTeX formula commands
+    // \f$ \f[ \f] \f{ \f} as a single command.
+    if (Length == 1 && TokenPtr[-1] == 'f' && TokenPtr != CommentEnd) {
+      C = *TokenPtr;
+      if (C == '$' || C == '[' || C == ']' || C == '{' || C == '}') {
+        TokenPtr++;
+        Length++;
       }
+    }
 
-      StringRef CommandName(BufferPtr + 1, Length);
-
-      const CommandInfo *Info = Traits.getCommandInfoOrNULL(CommandName);
-      if (!Info) {
-        if ((Info = Traits.getTypoCorrectCommandInfo(CommandName))) {
-          StringRef CorrectedName = Info->Name;
-          SourceLocation Loc = getSourceLocation(BufferPtr);
-          SourceLocation EndLoc = getSourceLocation(TokenPtr);
-          SourceRange FullRange = SourceRange(Loc, EndLoc);
-          SourceRange CommandRange(Loc.getLocWithOffset(1), EndLoc);
-          Diag(Loc, diag::warn_correct_comment_command_name)
+    StringRef CommandName(BufferPtr + 1, Length);
+
+    CommandInfo const *Info = Traits.getCommandInfoOrNULL(CommandName);
+    if (!Info) {
+      if ((Info = Traits.getTypoCorrectCommandInfo(CommandName))) {
+        StringRef CorrectedName = Info->Name;
+        SourceLocation Loc = getSourceLocation(BufferPtr);
+        SourceLocation EndLoc = getSourceLocation(TokenPtr);
+        SourceRange FullRange = SourceRange(Loc, EndLoc);
+        SourceRange CommandRange(Loc.getLocWithOffset(1), EndLoc);
+        Diag(Loc, diag::warn_correct_comment_command_name)
             << FullRange << CommandName << CorrectedName
             << FixItHint::CreateReplacement(CommandRange, CorrectedName);
-        } else {
-          formTokenWithChars(T, TokenPtr, tok::unknown_command);
-          T.setUnknownCommandName(CommandName);
-          Diag(T.getLocation(), diag::warn_unknown_comment_command_name)
-              << SourceRange(T.getLocation(), T.getEndLocation());
-          return;
-        }
-      }
-      if (Info->IsVerbatimBlockCommand) {
-        setupAndLexVerbatimBlock(T, TokenPtr, *BufferPtr, Info);
-        return;
-      }
-      if (Info->IsVerbatimLineCommand) {
-        setupAndLexVerbatimLine(T, TokenPtr, Info);
+      } else {
+        formTokenWithChars(T, TokenPtr, tok::unknown_command);
+        T.setUnknownCommandName(CommandName);
+        Diag(T.getLocation(), diag::warn_unknown_comment_command_name)
+            << SourceRange(T.getLocation(), T.getEndLocation());
         return;
       }
-      formTokenWithChars(T, TokenPtr, CommandKind);
-      T.setCommandID(Info->getID());
+    }
+    if (Info->IsVerbatimBlockCommand) {
+      setupAndLexVerbatimBlock(T, TokenPtr, *BufferPtr, Info);
       return;
     }
-
-    case '&':
-      lexHTMLCharacterReference(T);
+    if (Info->IsVerbatimLineCommand) {
+      setupAndLexVerbatimLine(T, TokenPtr, Info);
       return;
+    }
+    formTokenWithChars(T, TokenPtr, CommandKind);
+    T.setCommandID(Info->getID());
+    return;
+  }
 
-    case '<': {
-      TokenPtr++;
-      if (TokenPtr == CommentEnd) {
-        formTextToken(T, TokenPtr);
-        return;
-      }
-      const char C = *TokenPtr;
-      if (isHTMLIdentifierStartingCharacter(C))
-        setupAndLexHTMLStartTag(T);
-      else if (C == '/')
-        setupAndLexHTMLEndTag(T);
-      else
-        formTextToken(T, TokenPtr);
+  case '&':
+    lexHTMLCharacterReference(T);
+    return;
+
+  case '<': {
+    TokenPtr++;
+    if (TokenPtr == CommentEnd) {
+      formTextToken(T, TokenPtr);
       return;
     }
+    char const C = *TokenPtr;
+    if (isHTMLIdentifierStartingCharacter(C))
+      setupAndLexHTMLStartTag(T);
+    else if (C == '/')
+      setupAndLexHTMLEndTag(T);
+    else
+      formTextToken(T, TokenPtr);
+    return;
+  }
 
-    default:
-      return HandleNonCommandToken();
+  default:
+    return HandleNonCommandToken();
   }
 }
 
-void Lexer::setupAndLexVerbatimBlock(Token &T,
-                                     const char *TextBegin,
-                                     char Marker, const CommandInfo *Info) {
+void Lexer::setupAndLexVerbatimBlock(Token &T, char const *TextBegin,
+                                     char Marker, CommandInfo const *Info) {
   assert(Info->IsVerbatimBlockCommand);
 
   VerbatimBlockEndCommandName.clear();
@@ -475,8 +472,7 @@
   // If there is a newline following the verbatim opening command, skip the
   // newline so that we don't create an tok::verbatim_block_line with empty
   // text content.
-  if (BufferPtr != CommentEnd &&
-      isVerticalWhitespace(*BufferPtr)) {
+  if (BufferPtr != CommentEnd && isVerticalWhitespace(*BufferPtr)) {
     BufferPtr = skipNewline(BufferPtr, CommentEnd);
     State = LS_VerbatimBlockBody;
     return;
@@ -493,20 +489,20 @@
   // end command or newline.
   //
   // Extract current line.
-  const char *Newline = findNewline(BufferPtr, CommentEnd);
+  char const *Newline = findNewline(BufferPtr, CommentEnd);
   StringRef Line(BufferPtr, Newline - BufferPtr);
 
   // Look for end command in current line.
   size_t Pos = Line.find(VerbatimBlockEndCommandName);
-  const char *TextEnd;
-  const char *NextLine;
+  char const *TextEnd;
+  char const *NextLine;
   if (Pos == StringRef::npos) {
     // Current line is completely verbatim.
     TextEnd = Newline;
     NextLine = skipNewline(Newline, CommentEnd);
   } else if (Pos == 0) {
     // Current line contains just an end command.
-    const char *End = BufferPtr + VerbatimBlockEndCommandName.size();
+    char const *End = BufferPtr + VerbatimBlockEndCommandName.size();
     StringRef Name(BufferPtr + 1, End - (BufferPtr + 1));
     formTokenWithChars(T, End, tok::verbatim_block_end);
     T.setVerbatimBlockID(Traits.getCommandInfo(Name)->getID());
@@ -545,8 +541,8 @@
   lexVerbatimBlockFirstLine(T);
 }
 
-void Lexer::setupAndLexVerbatimLine(Token &T, const char *TextBegin,
-                                    const CommandInfo *Info) {
+void Lexer::setupAndLexVerbatimLine(Token &T, char const *TextBegin,
+                                    CommandInfo const *Info) {
   assert(Info->IsVerbatimLineCommand);
   formTokenWithChars(T, TextBegin, tok::verbatim_line_name);
   T.setVerbatimLineID(Info->getID());
@@ -558,7 +554,7 @@
   assert(State == LS_VerbatimLineText);
 
   // Extract current line.
-  const char *Newline = findNewline(BufferPtr, CommentEnd);
+  char const *Newline = findNewline(BufferPtr, CommentEnd);
   StringRef Text(BufferPtr, Newline - BufferPtr);
   formTokenWithChars(T, Newline, tok::verbatim_line_text);
   T.setVerbatimLineText(Text);
@@ -567,14 +563,14 @@
 }
 
 void Lexer::lexHTMLCharacterReference(Token &T) {
-  const char *TokenPtr = BufferPtr;
+  char const *TokenPtr = BufferPtr;
   assert(*TokenPtr == '&');
   TokenPtr++;
   if (TokenPtr == CommentEnd) {
     formTextToken(T, TokenPtr);
     return;
   }
-  const char *NamePtr;
+  char const *NamePtr;
   bool isNamed = false;
   bool isDecimal = false;
   char C = *TokenPtr;
@@ -605,8 +601,7 @@
     formTextToken(T, TokenPtr);
     return;
   }
-  if (NamePtr == TokenPtr || TokenPtr == CommentEnd ||
-      *TokenPtr != ';') {
+  if (NamePtr == TokenPtr || TokenPtr == CommentEnd || *TokenPtr != ';') {
     formTextToken(T, TokenPtr);
     return;
   }
@@ -631,7 +626,7 @@
 void Lexer::setupAndLexHTMLStartTag(Token &T) {
   assert(BufferPtr[0] == '<' &&
          isHTMLIdentifierStartingCharacter(BufferPtr[1]));
-  const char *TagNameEnd = skipHTMLIdentifier(BufferPtr + 2, CommentEnd);
+  char const *TagNameEnd = skipHTMLIdentifier(BufferPtr + 2, CommentEnd);
   StringRef Name(BufferPtr + 1, TagNameEnd - (BufferPtr + 1));
   if (!isHTMLTagName(Name)) {
     formTextToken(T, TagNameEnd);
@@ -643,7 +638,7 @@
 
   BufferPtr = skipWhitespace(BufferPtr, CommentEnd);
 
-  const char C = *BufferPtr;
+  char const C = *BufferPtr;
   if (BufferPtr != CommentEnd &&
       (C == '>' || C == '/' || isHTMLIdentifierStartingCharacter(C)))
     State = LS_HTMLStartTag;
@@ -652,7 +647,7 @@
 void Lexer::lexHTMLStartTag(Token &T) {
   assert(State == LS_HTMLStartTag);
 
-  const char *TokenPtr = BufferPtr;
+  char const *TokenPtr = BufferPtr;
   char C = *TokenPtr;
   if (isHTMLIdentifierCharacter(C)) {
     TokenPtr = skipHTMLIdentifier(TokenPtr, CommentEnd);
@@ -667,14 +662,14 @@
       break;
     case '\"':
     case '\'': {
-      const char *OpenQuote = TokenPtr;
+      char const *OpenQuote = TokenPtr;
       TokenPtr = skipHTMLQuotedString(TokenPtr, CommentEnd);
-      const char *ClosingQuote = TokenPtr;
+      char const *ClosingQuote = TokenPtr;
       if (TokenPtr != CommentEnd) // Skip closing quote.
         TokenPtr++;
       formTokenWithChars(T, TokenPtr, tok::html_quoted_string);
-      T.setHTMLQuotedString(StringRef(OpenQuote + 1,
-                                      ClosingQuote - (OpenQuote + 1)));
+      T.setHTMLQuotedString(
+          StringRef(OpenQuote + 1, ClosingQuote - (OpenQuote + 1)));
       break;
     }
     case '>':
@@ -704,8 +699,8 @@
   }
 
   C = *BufferPtr;
-  if (!isHTMLIdentifierStartingCharacter(C) &&
-      C != '=' && C != '\"' && C != '\'' && C != '>') {
+  if (!isHTMLIdentifierStartingCharacter(C) && C != '=' && C != '\"' &&
+      C != '\'' && C != '>') {
     State = LS_Normal;
     return;
   }
@@ -714,15 +709,15 @@
 void Lexer::setupAndLexHTMLEndTag(Token &T) {
   assert(BufferPtr[0] == '<' && BufferPtr[1] == '/');
 
-  const char *TagNameBegin = skipWhitespace(BufferPtr + 2, CommentEnd);
-  const char *TagNameEnd = skipHTMLIdentifier(TagNameBegin, CommentEnd);
+  char const *TagNameBegin = skipWhitespace(BufferPtr + 2, CommentEnd);
+  char const *TagNameEnd = skipHTMLIdentifier(TagNameBegin, CommentEnd);
   StringRef Name(TagNameBegin, TagNameEnd - TagNameBegin);
   if (!isHTMLTagName(Name)) {
     formTextToken(T, TagNameEnd);
     return;
   }
 
-  const char *End = skipWhitespace(TagNameEnd, CommentEnd);
+  char const *End = skipWhitespace(TagNameEnd, CommentEnd);
 
   formTokenWithChars(T, End, tok::html_end_tag);
   T.setHTMLTagEndName(Name);
@@ -739,8 +734,8 @@
 }
 
 Lexer::Lexer(llvm::BumpPtrAllocator &Allocator, DiagnosticsEngine &Diags,
-             const CommandTraits &Traits, SourceLocation FileLoc,
-             const char *BufferStart, const char *BufferEnd, bool ParseCommands)
+             CommandTraits const &Traits, SourceLocation FileLoc,
+             char const *BufferStart, char const *BufferEnd, bool ParseCommands)
     : Allocator(Allocator), Diags(Diags), Traits(Traits),
       BufferStart(BufferStart), BufferEnd(BufferEnd), BufferPtr(BufferStart),
       FileLoc(FileLoc), ParseCommands(ParseCommands),
@@ -757,8 +752,8 @@
 
     assert(*BufferPtr == '/');
     BufferPtr++; // Skip first slash.
-    switch(*BufferPtr) {
-    case '/': { // BCPL comment.
+    switch (*BufferPtr) {
+    case '/': {    // BCPL comment.
       BufferPtr++; // Skip second slash.
 
       if (BufferPtr != BufferEnd) {
@@ -766,7 +761,7 @@
         // It might be missing because of a typo //< or /*<, or because we
         // merged this non-Doxygen comment into a bunch of Doxygen comments
         // around it: /** ... */ /* ... */ /** ... */
-        const char C = *BufferPtr;
+        char const C = *BufferPtr;
         if (C == '/' || C == '!')
           BufferPtr++;
       }
@@ -783,11 +778,11 @@
       CommentEnd = findBCPLCommentEnd(BufferPtr, BufferEnd);
       goto again;
     }
-    case '*': { // C comment.
+    case '*': {    // C comment.
       BufferPtr++; // Skip star.
 
       // Skip Doxygen magic marker.
-      const char C = *BufferPtr;
+      char const C = *BufferPtr;
       if ((C == '*' && *(BufferPtr + 1) != '/') || C == '!')
         BufferPtr++;
 
@@ -807,8 +802,8 @@
   case LCS_BetweenComments: {
     // Consecutive comments are extracted only if there is only whitespace
     // between them.  So we can search for the start of the next comment.
-    const char *EndWhitespace = BufferPtr;
-    while(EndWhitespace != BufferEnd && *EndWhitespace != '/')
+    char const *EndWhitespace = BufferPtr;
+    while (EndWhitespace != BufferEnd && *EndWhitespace != '/')
       EndWhitespace++;
 
     // Turn any whitespace between comments (and there is only whitespace
@@ -848,8 +843,8 @@
   }
 }
 
-StringRef Lexer::getSpelling(const Token &Tok,
-                             const SourceManager &SourceMgr) const {
+StringRef Lexer::getSpelling(Token const &Tok,
+                             SourceManager const &SourceMgr) const {
   SourceLocation Loc = Tok.getLocation();
   std::pair<FileID, unsigned> LocInfo = SourceMgr.getDecomposedLoc(Loc);
 
@@ -858,7 +853,7 @@
   if (InvalidTemp)
     return StringRef();
 
-  const char *Begin = File.data() + LocInfo.second;
+  char const *Begin = File.data() + LocInfo.second;
   return StringRef(Begin, Tok.getLength());
 }
 
Index: clang/lib/AST/CommentParser.cpp
===================================================================
--- clang/lib/AST/CommentParser.cpp
+++ clang/lib/AST/CommentParser.cpp
@@ -16,7 +16,7 @@
 
 namespace clang {
 
-static inline bool isWhitespace(llvm::StringRef S) {
+inline static bool isWhitespace(llvm::StringRef S) {
   for (StringRef::const_iterator I = S.begin(), E = S.end(); I != E; ++I) {
     if (!isWhitespace(*I))
       return false;
@@ -39,9 +39,9 @@
 
   /// A position in \c Toks.
   struct Position {
-    const char *BufferStart;
-    const char *BufferEnd;
-    const char *BufferPtr;
+    char const *BufferStart;
+    char const *BufferEnd;
+    char const *BufferPtr;
     SourceLocation BufferStartLoc;
     unsigned CurToken;
   };
@@ -49,14 +49,12 @@
   /// Current position in Toks.
   Position Pos;
 
-  bool isEnd() const {
-    return Pos.CurToken >= Toks.size();
-  }
+  bool isEnd() const { return Pos.CurToken >= Toks.size(); }
 
   /// Sets up the buffer pointers to point to current token.
   void setupBuffer() {
     assert(!isEnd());
-    const Token &Tok = Toks[Pos.CurToken];
+    Token const &Tok = Toks[Pos.CurToken];
 
     Pos.BufferStart = Tok.getText().begin();
     Pos.BufferEnd = Tok.getText().end();
@@ -65,7 +63,7 @@
   }
 
   SourceLocation getSourceLocation() const {
-    const unsigned CharNo = Pos.BufferPtr - Pos.BufferStart;
+    unsigned const CharNo = Pos.BufferPtr - Pos.BufferStart;
     return Pos.BufferStartLoc.getLocWithOffset(CharNo);
   }
 
@@ -127,10 +125,8 @@
     }
   }
 
-  void formTokenWithChars(Token &Result,
-                          SourceLocation Loc,
-                          const char *TokBegin,
-                          unsigned TokLength,
+  void formTokenWithChars(Token &Result, SourceLocation Loc,
+                          char const *TokBegin, unsigned TokLength,
                           StringRef Text) {
     Result.setLocation(Loc);
     Result.setKind(tok::text);
@@ -143,8 +139,8 @@
   }
 
 public:
-  TextTokenRetokenizer(llvm::BumpPtrAllocator &Allocator, Parser &P):
-      Allocator(Allocator), P(P), NoMoreInterestingTokens(false) {
+  TextTokenRetokenizer(llvm::BumpPtrAllocator &Allocator, Parser &P)
+      : Allocator(Allocator), P(P), NoMoreInterestingTokens(false) {
     Pos.CurToken = 0;
     addToken();
   }
@@ -158,17 +154,17 @@
 
     consumeWhitespace();
     SmallString<32> WordText;
-    const char *WordBegin = Pos.BufferPtr;
+    char const *WordBegin = Pos.BufferPtr;
     SourceLocation Loc = getSourceLocation();
     while (!isEnd()) {
-      const char C = peek();
+      char const C = peek();
       if (!isWhitespace(C)) {
         WordText.push_back(C);
         consumeChar();
       } else
         break;
     }
-    const unsigned Length = WordText.size();
+    unsigned const Length = WordText.size();
     if (Length == 0) {
       Pos = SavedPos;
       return false;
@@ -191,11 +187,11 @@
 
     consumeWhitespace();
     SmallString<32> WordText;
-    const char *WordBegin = Pos.BufferPtr;
+    char const *WordBegin = Pos.BufferPtr;
     SourceLocation Loc = getSourceLocation();
     bool Error = false;
     if (!isEnd()) {
-      const char C = peek();
+      char const C = peek();
       if (C == OpenDelim) {
         WordText.push_back(C);
         consumeChar();
@@ -218,14 +214,13 @@
       return false;
     }
 
-    const unsigned Length = WordText.size();
+    unsigned const Length = WordText.size();
     char *TextPtr = Allocator.Allocate<char>(Length + 1);
 
     memcpy(TextPtr, WordText.c_str(), Length + 1);
     StringRef Text = StringRef(TextPtr, Length);
 
-    formTokenWithChars(Tok, Loc, WordBegin,
-                       Pos.BufferPtr - WordBegin, Text);
+    formTokenWithChars(Tok, Loc, WordBegin, Pos.BufferPtr - WordBegin, Text);
     return true;
   }
 
@@ -237,10 +232,10 @@
     bool HavePartialTok = false;
     Token PartialTok;
     if (Pos.BufferPtr != Pos.BufferStart) {
-      formTokenWithChars(PartialTok, getSourceLocation(),
-                         Pos.BufferPtr, Pos.BufferEnd - Pos.BufferPtr,
-                         StringRef(Pos.BufferPtr,
-                                   Pos.BufferEnd - Pos.BufferPtr));
+      formTokenWithChars(
+          PartialTok, getSourceLocation(), Pos.BufferPtr,
+          Pos.BufferEnd - Pos.BufferPtr,
+          StringRef(Pos.BufferPtr, Pos.BufferEnd - Pos.BufferPtr));
       HavePartialTok = true;
       Pos.CurToken++;
     }
@@ -254,10 +249,10 @@
 };
 
 Parser::Parser(Lexer &L, Sema &S, llvm::BumpPtrAllocator &Allocator,
-               const SourceManager &SourceMgr, DiagnosticsEngine &Diags,
-               const CommandTraits &Traits):
-    L(L), S(S), Allocator(Allocator), SourceMgr(SourceMgr), Diags(Diags),
-    Traits(Traits) {
+               SourceManager const &SourceMgr, DiagnosticsEngine &Diags,
+               CommandTraits const &Traits)
+    : L(L), S(S), Allocator(Allocator), SourceMgr(SourceMgr), Diags(Diags),
+      Traits(Traits) {
   consumeToken();
 }
 
@@ -267,15 +262,11 @@
   // Check if argument looks like direction specification: [dir]
   // e.g., [in], [out], [in,out]
   if (Retokenizer.lexDelimitedSeq(Arg, '[', ']'))
-    S.actOnParamCommandDirectionArg(PC,
-                                    Arg.getLocation(),
-                                    Arg.getEndLocation(),
+    S.actOnParamCommandDirectionArg(PC, Arg.getLocation(), Arg.getEndLocation(),
                                     Arg.getText());
 
   if (Retokenizer.lexWord(Arg))
-    S.actOnParamCommandParamNameArg(PC,
-                                    Arg.getLocation(),
-                                    Arg.getEndLocation(),
+    S.actOnParamCommandParamNameArg(PC, Arg.getLocation(), Arg.getEndLocation(),
                                     Arg.getText());
 }
 
@@ -283,10 +274,8 @@
                                     TextTokenRetokenizer &Retokenizer) {
   Token Arg;
   if (Retokenizer.lexWord(Arg))
-    S.actOnTParamCommandParamNameArg(TPC,
-                                     Arg.getLocation(),
-                                     Arg.getEndLocation(),
-                                     Arg.getText());
+    S.actOnTParamCommandParamNameArg(TPC, Arg.getLocation(),
+                                     Arg.getEndLocation(), Arg.getText());
 }
 
 void Parser::parseBlockCommandArgs(BlockCommandComment *BC,
@@ -298,9 +287,8 @@
   unsigned ParsedArgs = 0;
   Token Arg;
   while (ParsedArgs < NumArgs && Retokenizer.lexWord(Arg)) {
-    Args[ParsedArgs] = Argument(SourceRange(Arg.getLocation(),
-                                            Arg.getEndLocation()),
-                                Arg.getText());
+    Args[ParsedArgs] = Argument(
+        SourceRange(Arg.getLocation(), Arg.getEndLocation()), Arg.getText());
     ParsedArgs++;
   }
 
@@ -313,24 +301,18 @@
   ParamCommandComment *PC = nullptr;
   TParamCommandComment *TPC = nullptr;
   BlockCommandComment *BC = nullptr;
-  const CommandInfo *Info = Traits.getCommandInfo(Tok.getCommandID());
+  CommandInfo const *Info = Traits.getCommandInfo(Tok.getCommandID());
   CommandMarkerKind CommandMarker =
       Tok.is(tok::backslash_command) ? CMK_Backslash : CMK_At;
   if (Info->IsParamCommand) {
-    PC = S.actOnParamCommandStart(Tok.getLocation(),
-                                  Tok.getEndLocation(),
-                                  Tok.getCommandID(),
-                                  CommandMarker);
+    PC = S.actOnParamCommandStart(Tok.getLocation(), Tok.getEndLocation(),
+                                  Tok.getCommandID(), CommandMarker);
   } else if (Info->IsTParamCommand) {
-    TPC = S.actOnTParamCommandStart(Tok.getLocation(),
-                                    Tok.getEndLocation(),
-                                    Tok.getCommandID(),
-                                    CommandMarker);
+    TPC = S.actOnTParamCommandStart(Tok.getLocation(), Tok.getEndLocation(),
+                                    Tok.getCommandID(), CommandMarker);
   } else {
-    BC = S.actOnBlockCommandStart(Tok.getLocation(),
-                                  Tok.getEndLocation(),
-                                  Tok.getCommandID(),
-                                  CommandMarker);
+    BC = S.actOnBlockCommandStart(Tok.getLocation(), Tok.getEndLocation(),
+                                  Tok.getCommandID(), CommandMarker);
   }
   consumeToken();
 
@@ -414,10 +396,8 @@
   if (ArgTokValid) {
     IC = S.actOnInlineCommand(CommandTok.getLocation(),
                               CommandTok.getEndLocation(),
-                              CommandTok.getCommandID(),
-                              ArgTok.getLocation(),
-                              ArgTok.getEndLocation(),
-                              ArgTok.getText());
+                              CommandTok.getCommandID(), ArgTok.getLocation(),
+                              ArgTok.getEndLocation(), ArgTok.getText());
   } else {
     IC = S.actOnInlineCommand(CommandTok.getLocation(),
                               CommandTok.getEndLocation(),
@@ -438,8 +418,7 @@
 HTMLStartTagComment *Parser::parseHTMLStartTag() {
   assert(Tok.is(tok::html_start_tag));
   HTMLStartTagComment *HST =
-      S.actOnHTMLStartTagStart(Tok.getLocation(),
-                               Tok.getHTMLTagStartName());
+      S.actOnHTMLStartTagStart(Tok.getLocation(), Tok.getHTMLTagStartName());
   consumeToken();
 
   SmallVector<HTMLStartTagComment::Attribute, 2> Attrs;
@@ -458,36 +437,30 @@
       if (Tok.isNot(tok::html_quoted_string)) {
         Diag(Tok.getLocation(),
              diag::warn_doc_html_start_tag_expected_quoted_string)
-          << SourceRange(Equals.getLocation());
+            << SourceRange(Equals.getLocation());
         Attrs.push_back(HTMLStartTagComment::Attribute(Ident.getLocation(),
                                                        Ident.getHTMLIdent()));
-        while (Tok.is(tok::html_equals) ||
-               Tok.is(tok::html_quoted_string))
+        while (Tok.is(tok::html_equals) || Tok.is(tok::html_quoted_string))
           consumeToken();
         continue;
       }
       Attrs.push_back(HTMLStartTagComment::Attribute(
-                              Ident.getLocation(),
-                              Ident.getHTMLIdent(),
-                              Equals.getLocation(),
-                              SourceRange(Tok.getLocation(),
-                                          Tok.getEndLocation()),
-                              Tok.getHTMLQuotedString()));
+          Ident.getLocation(), Ident.getHTMLIdent(), Equals.getLocation(),
+          SourceRange(Tok.getLocation(), Tok.getEndLocation()),
+          Tok.getHTMLQuotedString()));
       consumeToken();
       continue;
     }
 
     case tok::html_greater:
-      S.actOnHTMLStartTagFinish(HST,
-                                S.copyArray(llvm::makeArrayRef(Attrs)),
+      S.actOnHTMLStartTagFinish(HST, S.copyArray(llvm::makeArrayRef(Attrs)),
                                 Tok.getLocation(),
                                 /* IsSelfClosing = */ false);
       consumeToken();
       return HST;
 
     case tok::html_slash_greater:
-      S.actOnHTMLStartTagFinish(HST,
-                                S.copyArray(llvm::makeArrayRef(Attrs)),
+      S.actOnHTMLStartTagFinish(HST, S.copyArray(llvm::makeArrayRef(Attrs)),
                                 Tok.getLocation(),
                                 /* IsSelfClosing = */ true);
       consumeToken();
@@ -497,43 +470,37 @@
     case tok::html_quoted_string:
       Diag(Tok.getLocation(),
            diag::warn_doc_html_start_tag_expected_ident_or_greater);
-      while (Tok.is(tok::html_equals) ||
-             Tok.is(tok::html_quoted_string))
+      while (Tok.is(tok::html_equals) || Tok.is(tok::html_quoted_string))
         consumeToken();
-      if (Tok.is(tok::html_ident) ||
-          Tok.is(tok::html_greater) ||
+      if (Tok.is(tok::html_ident) || Tok.is(tok::html_greater) ||
           Tok.is(tok::html_slash_greater))
         continue;
 
-      S.actOnHTMLStartTagFinish(HST,
-                                S.copyArray(llvm::makeArrayRef(Attrs)),
+      S.actOnHTMLStartTagFinish(HST, S.copyArray(llvm::makeArrayRef(Attrs)),
                                 SourceLocation(),
                                 /* IsSelfClosing = */ false);
       return HST;
 
     default:
       // Not a token from an HTML start tag.  Thus HTML tag prematurely ended.
-      S.actOnHTMLStartTagFinish(HST,
-                                S.copyArray(llvm::makeArrayRef(Attrs)),
+      S.actOnHTMLStartTagFinish(HST, S.copyArray(llvm::makeArrayRef(Attrs)),
                                 SourceLocation(),
                                 /* IsSelfClosing = */ false);
       bool StartLineInvalid;
-      const unsigned StartLine = SourceMgr.getPresumedLineNumber(
-                                                  HST->getLocation(),
-                                                  &StartLineInvalid);
+      unsigned const StartLine = SourceMgr.getPresumedLineNumber(
+          HST->getLocation(), &StartLineInvalid);
       bool EndLineInvalid;
-      const unsigned EndLine = SourceMgr.getPresumedLineNumber(
-                                                  Tok.getLocation(),
-                                                  &EndLineInvalid);
+      unsigned const EndLine =
+          SourceMgr.getPresumedLineNumber(Tok.getLocation(), &EndLineInvalid);
       if (StartLineInvalid || EndLineInvalid || StartLine == EndLine)
         Diag(Tok.getLocation(),
              diag::warn_doc_html_start_tag_expected_ident_or_greater)
-          << HST->getSourceRange();
+            << HST->getSourceRange();
       else {
         Diag(Tok.getLocation(),
              diag::warn_doc_html_start_tag_expected_ident_or_greater);
         Diag(HST->getLocation(), diag::note_doc_html_tag_started_here)
-          << HST->getSourceRange();
+            << HST->getSourceRange();
       }
       return HST;
     }
@@ -550,8 +517,7 @@
     consumeToken();
   }
 
-  return S.actOnHTMLEndTag(TokEndTag.getLocation(),
-                           Loc,
+  return S.actOnHTMLEndTag(TokEndTag.getLocation(), Loc,
                            TokEndTag.getHTMLTagEndName());
 }
 
@@ -574,25 +540,22 @@
 
     case tok::backslash_command:
     case tok::at_command: {
-      const CommandInfo *Info = Traits.getCommandInfo(Tok.getCommandID());
+      CommandInfo const *Info = Traits.getCommandInfo(Tok.getCommandID());
       if (Info->IsBlockCommand) {
         if (Content.size() == 0)
           return parseBlockCommand();
         break; // Block command ahead, finish this parapgaph.
       }
       if (Info->IsVerbatimBlockEndCommand) {
-        Diag(Tok.getLocation(),
-             diag::warn_verbatim_block_end_without_start)
-          << Tok.is(tok::at_command)
-          << Info->Name
-          << SourceRange(Tok.getLocation(), Tok.getEndLocation());
+        Diag(Tok.getLocation(), diag::warn_verbatim_block_end_without_start)
+            << Tok.is(tok::at_command) << Info->Name
+            << SourceRange(Tok.getLocation(), Tok.getEndLocation());
         consumeToken();
         continue;
       }
       if (Info->IsUnknownCommand) {
-        Content.push_back(S.actOnUnknownCommand(Tok.getLocation(),
-                                                Tok.getEndLocation(),
-                                                Info->getID()));
+        Content.push_back(S.actOnUnknownCommand(
+            Tok.getLocation(), Tok.getEndLocation(), Info->getID()));
         consumeToken();
         continue;
       }
@@ -634,9 +597,8 @@
       continue;
 
     case tok::text:
-      Content.push_back(S.actOnText(Tok.getLocation(),
-                                    Tok.getEndLocation(),
-                                    Tok.getText()));
+      Content.push_back(
+          S.actOnText(Tok.getLocation(), Tok.getEndLocation(), Tok.getText()));
       consumeToken();
       continue;
 
@@ -660,8 +622,7 @@
   assert(Tok.is(tok::verbatim_block_begin));
 
   VerbatimBlockComment *VB =
-      S.actOnVerbatimBlockStart(Tok.getLocation(),
-                                Tok.getVerbatimBlockID());
+      S.actOnVerbatimBlockStart(Tok.getLocation(), Tok.getVerbatimBlockID());
   consumeToken();
 
   // Don't create an empty line if verbatim opening command is followed
@@ -670,8 +631,7 @@
     consumeToken();
 
   SmallVector<VerbatimBlockLineComment *, 8> Lines;
-  while (Tok.is(tok::verbatim_block_line) ||
-         Tok.is(tok::newline)) {
+  while (Tok.is(tok::verbatim_block_line) || Tok.is(tok::newline)) {
     VerbatimBlockLineComment *Line;
     if (Tok.is(tok::verbatim_block_line)) {
       Line = S.actOnVerbatimBlockLine(Tok.getLocation(),
@@ -689,9 +649,8 @@
   }
 
   if (Tok.is(tok::verbatim_block_end)) {
-    const CommandInfo *Info = Traits.getCommandInfo(Tok.getVerbatimBlockID());
-    S.actOnVerbatimBlockFinish(VB, Tok.getLocation(),
-                               Info->Name,
+    CommandInfo const *Info = Traits.getCommandInfo(Tok.getVerbatimBlockID());
+    S.actOnVerbatimBlockFinish(VB, Tok.getLocation(), Info->Name,
                                S.copyArray(llvm::makeArrayRef(Lines)));
     consumeToken();
   } else {
@@ -721,10 +680,8 @@
     Text = "";
   }
 
-  VerbatimLineComment *VL = S.actOnVerbatimLine(NameTok.getLocation(),
-                                                NameTok.getVerbatimLineID(),
-                                                TextBegin,
-                                                Text);
+  VerbatimLineComment *VL = S.actOnVerbatimLine(
+      NameTok.getLocation(), NameTok.getVerbatimLineID(), TextBegin, Text);
   consumeToken();
   return VL;
 }
Index: clang/lib/AST/CommentSema.cpp
===================================================================
--- clang/lib/AST/CommentSema.cpp
+++ clang/lib/AST/CommentSema.cpp
@@ -25,15 +25,14 @@
 #include "clang/AST/CommentHTMLTagsProperties.inc"
 } // end anonymous namespace
 
-Sema::Sema(llvm::BumpPtrAllocator &Allocator, const SourceManager &SourceMgr,
+Sema::Sema(llvm::BumpPtrAllocator &Allocator, SourceManager const &SourceMgr,
            DiagnosticsEngine &Diags, CommandTraits &Traits,
-           const Preprocessor *PP) :
-    Allocator(Allocator), SourceMgr(SourceMgr), Diags(Diags), Traits(Traits),
-    PP(PP), ThisDeclInfo(nullptr), BriefCommand(nullptr),
-    HeaderfileCommand(nullptr) {
-}
+           Preprocessor const *PP)
+    : Allocator(Allocator), SourceMgr(SourceMgr), Diags(Diags), Traits(Traits),
+      PP(PP), ThisDeclInfo(nullptr), BriefCommand(nullptr),
+      HeaderfileCommand(nullptr) {}
 
-void Sema::setDecl(const Decl *D) {
+void Sema::setDecl(Decl const *D) {
   if (!D)
     return;
 
@@ -42,19 +41,17 @@
   ThisDeclInfo->IsFilled = false;
 }
 
-ParagraphComment *Sema::actOnParagraphComment(
-                              ArrayRef<InlineContentComment *> Content) {
+ParagraphComment *
+Sema::actOnParagraphComment(ArrayRef<InlineContentComment *> Content) {
   return new (Allocator) ParagraphComment(Content);
 }
 
-BlockCommandComment *Sema::actOnBlockCommandStart(
-                                      SourceLocation LocBegin,
-                                      SourceLocation LocEnd,
-                                      unsigned CommandID,
-                                      CommandMarkerKind CommandMarker) {
-  BlockCommandComment *BC = new (Allocator) BlockCommandComment(LocBegin, LocEnd,
-                                                                CommandID,
-                                                                CommandMarker);
+BlockCommandComment *
+Sema::actOnBlockCommandStart(SourceLocation LocBegin, SourceLocation LocEnd,
+                             unsigned CommandID,
+                             CommandMarkerKind CommandMarker) {
+  BlockCommandComment *BC = new (Allocator)
+      BlockCommandComment(LocBegin, LocEnd, CommandID, CommandMarker);
   checkContainerDecl(BC);
   return BC;
 }
@@ -77,144 +74,137 @@
   }
 }
 
-ParamCommandComment *Sema::actOnParamCommandStart(
-                                      SourceLocation LocBegin,
-                                      SourceLocation LocEnd,
-                                      unsigned CommandID,
-                                      CommandMarkerKind CommandMarker) {
-  ParamCommandComment *Command =
-      new (Allocator) ParamCommandComment(LocBegin, LocEnd, CommandID,
-                                          CommandMarker);
+ParamCommandComment *
+Sema::actOnParamCommandStart(SourceLocation LocBegin, SourceLocation LocEnd,
+                             unsigned CommandID,
+                             CommandMarkerKind CommandMarker) {
+  ParamCommandComment *Command = new (Allocator)
+      ParamCommandComment(LocBegin, LocEnd, CommandID, CommandMarker);
 
   if (!isFunctionDecl() && !isFunctionOrBlockPointerVarLikeDecl())
     Diag(Command->getLocation(),
          diag::warn_doc_param_not_attached_to_a_function_decl)
-      << CommandMarker
-      << Command->getCommandNameRange(Traits);
+        << CommandMarker << Command->getCommandNameRange(Traits);
 
   return Command;
 }
 
-void Sema::checkFunctionDeclVerbatimLine(const BlockCommandComment *Comment) {
-  const CommandInfo *Info = Traits.getCommandInfo(Comment->getCommandID());
+void Sema::checkFunctionDeclVerbatimLine(BlockCommandComment const *Comment) {
+  CommandInfo const *Info = Traits.getCommandInfo(Comment->getCommandID());
   if (!Info->IsFunctionDeclarationCommand)
     return;
 
   unsigned DiagSelect;
   switch (Comment->getCommandID()) {
-    case CommandTraits::KCI_function:
-      DiagSelect = (!isAnyFunctionDecl() && !isFunctionTemplateDecl())? 1 : 0;
-      break;
-    case CommandTraits::KCI_functiongroup:
-      DiagSelect = (!isAnyFunctionDecl() && !isFunctionTemplateDecl())? 2 : 0;
-      break;
-    case CommandTraits::KCI_method:
-      DiagSelect = !isObjCMethodDecl() ? 3 : 0;
-      break;
-    case CommandTraits::KCI_methodgroup:
-      DiagSelect = !isObjCMethodDecl() ? 4 : 0;
-      break;
-    case CommandTraits::KCI_callback:
-      DiagSelect = !isFunctionPointerVarDecl() ? 5 : 0;
-      break;
-    default:
-      DiagSelect = 0;
-      break;
+  case CommandTraits::KCI_function:
+    DiagSelect = (!isAnyFunctionDecl() && !isFunctionTemplateDecl()) ? 1 : 0;
+    break;
+  case CommandTraits::KCI_functiongroup:
+    DiagSelect = (!isAnyFunctionDecl() && !isFunctionTemplateDecl()) ? 2 : 0;
+    break;
+  case CommandTraits::KCI_method:
+    DiagSelect = !isObjCMethodDecl() ? 3 : 0;
+    break;
+  case CommandTraits::KCI_methodgroup:
+    DiagSelect = !isObjCMethodDecl() ? 4 : 0;
+    break;
+  case CommandTraits::KCI_callback:
+    DiagSelect = !isFunctionPointerVarDecl() ? 5 : 0;
+    break;
+  default:
+    DiagSelect = 0;
+    break;
   }
   if (DiagSelect)
     Diag(Comment->getLocation(), diag::warn_doc_function_method_decl_mismatch)
-    << Comment->getCommandMarker()
-    << (DiagSelect-1) << (DiagSelect-1)
-    << Comment->getSourceRange();
+        << Comment->getCommandMarker() << (DiagSelect - 1) << (DiagSelect - 1)
+        << Comment->getSourceRange();
 }
 
-void Sema::checkContainerDeclVerbatimLine(const BlockCommandComment *Comment) {
-  const CommandInfo *Info = Traits.getCommandInfo(Comment->getCommandID());
+void Sema::checkContainerDeclVerbatimLine(BlockCommandComment const *Comment) {
+  CommandInfo const *Info = Traits.getCommandInfo(Comment->getCommandID());
   if (!Info->IsRecordLikeDeclarationCommand)
     return;
   unsigned DiagSelect;
   switch (Comment->getCommandID()) {
-    case CommandTraits::KCI_class:
-      DiagSelect =
-          (!isClassOrStructOrTagTypedefDecl() && !isClassTemplateDecl()) ? 1
-                                                                         : 0;
-      // Allow @class command on @interface declarations.
-      // FIXME. Currently, \class and @class are indistinguishable. So,
-      // \class is also allowed on an @interface declaration
-      if (DiagSelect && Comment->getCommandMarker() && isObjCInterfaceDecl())
-        DiagSelect = 0;
-      break;
-    case CommandTraits::KCI_interface:
-      DiagSelect = !isObjCInterfaceDecl() ? 2 : 0;
-      break;
-    case CommandTraits::KCI_protocol:
-      DiagSelect = !isObjCProtocolDecl() ? 3 : 0;
-      break;
-    case CommandTraits::KCI_struct:
-      DiagSelect = !isClassOrStructOrTagTypedefDecl() ? 4 : 0;
-      break;
-    case CommandTraits::KCI_union:
-      DiagSelect = !isUnionDecl() ? 5 : 0;
-      break;
-    default:
+  case CommandTraits::KCI_class:
+    DiagSelect =
+        (!isClassOrStructOrTagTypedefDecl() && !isClassTemplateDecl()) ? 1 : 0;
+    // Allow @class command on @interface declarations.
+    // FIXME. Currently, \class and @class are indistinguishable. So,
+    // \class is also allowed on an @interface declaration
+    if (DiagSelect && Comment->getCommandMarker() && isObjCInterfaceDecl())
       DiagSelect = 0;
-      break;
+    break;
+  case CommandTraits::KCI_interface:
+    DiagSelect = !isObjCInterfaceDecl() ? 2 : 0;
+    break;
+  case CommandTraits::KCI_protocol:
+    DiagSelect = !isObjCProtocolDecl() ? 3 : 0;
+    break;
+  case CommandTraits::KCI_struct:
+    DiagSelect = !isClassOrStructOrTagTypedefDecl() ? 4 : 0;
+    break;
+  case CommandTraits::KCI_union:
+    DiagSelect = !isUnionDecl() ? 5 : 0;
+    break;
+  default:
+    DiagSelect = 0;
+    break;
   }
   if (DiagSelect)
     Diag(Comment->getLocation(), diag::warn_doc_api_container_decl_mismatch)
-    << Comment->getCommandMarker()
-    << (DiagSelect-1) << (DiagSelect-1)
-    << Comment->getSourceRange();
+        << Comment->getCommandMarker() << (DiagSelect - 1) << (DiagSelect - 1)
+        << Comment->getSourceRange();
 }
 
-void Sema::checkContainerDecl(const BlockCommandComment *Comment) {
-  const CommandInfo *Info = Traits.getCommandInfo(Comment->getCommandID());
+void Sema::checkContainerDecl(BlockCommandComment const *Comment) {
+  CommandInfo const *Info = Traits.getCommandInfo(Comment->getCommandID());
   if (!Info->IsRecordLikeDetailCommand || isRecordLikeDecl())
     return;
   unsigned DiagSelect;
   switch (Comment->getCommandID()) {
-    case CommandTraits::KCI_classdesign:
-      DiagSelect = 1;
-      break;
-    case CommandTraits::KCI_coclass:
-      DiagSelect = 2;
-      break;
-    case CommandTraits::KCI_dependency:
-      DiagSelect = 3;
-      break;
-    case CommandTraits::KCI_helper:
-      DiagSelect = 4;
-      break;
-    case CommandTraits::KCI_helperclass:
-      DiagSelect = 5;
-      break;
-    case CommandTraits::KCI_helps:
-      DiagSelect = 6;
-      break;
-    case CommandTraits::KCI_instancesize:
-      DiagSelect = 7;
-      break;
-    case CommandTraits::KCI_ownership:
-      DiagSelect = 8;
-      break;
-    case CommandTraits::KCI_performance:
-      DiagSelect = 9;
-      break;
-    case CommandTraits::KCI_security:
-      DiagSelect = 10;
-      break;
-    case CommandTraits::KCI_superclass:
-      DiagSelect = 11;
-      break;
-    default:
-      DiagSelect = 0;
-      break;
+  case CommandTraits::KCI_classdesign:
+    DiagSelect = 1;
+    break;
+  case CommandTraits::KCI_coclass:
+    DiagSelect = 2;
+    break;
+  case CommandTraits::KCI_dependency:
+    DiagSelect = 3;
+    break;
+  case CommandTraits::KCI_helper:
+    DiagSelect = 4;
+    break;
+  case CommandTraits::KCI_helperclass:
+    DiagSelect = 5;
+    break;
+  case CommandTraits::KCI_helps:
+    DiagSelect = 6;
+    break;
+  case CommandTraits::KCI_instancesize:
+    DiagSelect = 7;
+    break;
+  case CommandTraits::KCI_ownership:
+    DiagSelect = 8;
+    break;
+  case CommandTraits::KCI_performance:
+    DiagSelect = 9;
+    break;
+  case CommandTraits::KCI_security:
+    DiagSelect = 10;
+    break;
+  case CommandTraits::KCI_superclass:
+    DiagSelect = 11;
+    break;
+  default:
+    DiagSelect = 0;
+    break;
   }
   if (DiagSelect)
     Diag(Comment->getLocation(), diag::warn_doc_container_decl_mismatch)
-    << Comment->getCommandMarker()
-    << (DiagSelect-1)
-    << Comment->getSourceRange();
+        << Comment->getCommandMarker() << (DiagSelect - 1)
+        << Comment->getSourceRange();
 }
 
 /// Turn a string into the corresponding PassDirection or -1 if it's not
@@ -243,7 +233,7 @@
 
     SourceRange ArgRange(ArgLocBegin, ArgLocEnd);
     if (Direction != -1) {
-      const char *FixedName = ParamCommandComment::getDirectionAsString(
+      char const *FixedName = ParamCommandComment::getDirectionAsString(
           (ParamCommandComment::PassDirection)Direction);
       Diag(ArgLocBegin, diag::warn_doc_param_spaces_in_direction)
           << ArgRange << FixItHint::CreateReplacement(ArgRange, FixedName);
@@ -268,9 +258,8 @@
     Command->setDirection(ParamCommandComment::In, /* Explicit = */ false);
   }
   typedef BlockCommandComment::Argument Argument;
-  Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
-                                                     ArgLocEnd),
-                                         Arg);
+  Argument *A =
+      new (Allocator) Argument(SourceRange(ArgLocBegin, ArgLocEnd), Arg);
   Command->setArgs(llvm::makeArrayRef(A, 1));
 }
 
@@ -280,20 +269,17 @@
   checkBlockCommandEmptyParagraph(Command);
 }
 
-TParamCommandComment *Sema::actOnTParamCommandStart(
-                                      SourceLocation LocBegin,
-                                      SourceLocation LocEnd,
-                                      unsigned CommandID,
-                                      CommandMarkerKind CommandMarker) {
-  TParamCommandComment *Command =
-      new (Allocator) TParamCommandComment(LocBegin, LocEnd, CommandID,
-                                           CommandMarker);
+TParamCommandComment *
+Sema::actOnTParamCommandStart(SourceLocation LocBegin, SourceLocation LocEnd,
+                              unsigned CommandID,
+                              CommandMarkerKind CommandMarker) {
+  TParamCommandComment *Command = new (Allocator)
+      TParamCommandComment(LocBegin, LocEnd, CommandID, CommandMarker);
 
   if (!isTemplateOrSpecialization())
     Diag(Command->getLocation(),
          diag::warn_doc_tparam_not_attached_to_a_template_decl)
-      << CommandMarker
-      << Command->getCommandNameRange(Traits);
+        << CommandMarker << Command->getCommandNameRange(Traits);
 
   return Command;
 }
@@ -306,9 +292,8 @@
   assert(Command->getNumArgs() == 0);
 
   typedef BlockCommandComment::Argument Argument;
-  Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
-                                                     ArgLocEnd),
-                                         Arg);
+  Argument *A =
+      new (Allocator) Argument(SourceRange(ArgLocBegin, ArgLocEnd), Arg);
   Command->setArgs(llvm::makeArrayRef(A, 1));
 
   if (!isTemplateOrSpecialization()) {
@@ -316,7 +301,7 @@
     return;
   }
 
-  const TemplateParameterList *TemplateParameters =
+  TemplateParameterList const *TemplateParameters =
       ThisDeclInfo->TemplateParameters;
   SmallVector<unsigned, 2> Position;
   if (resolveTParamReference(Arg, TemplateParameters, &Position)) {
@@ -324,26 +309,24 @@
     TParamCommandComment *&PrevCommand = TemplateParameterDocs[Arg];
     if (PrevCommand) {
       SourceRange ArgRange(ArgLocBegin, ArgLocEnd);
-      Diag(ArgLocBegin, diag::warn_doc_tparam_duplicate)
-        << Arg << ArgRange;
+      Diag(ArgLocBegin, diag::warn_doc_tparam_duplicate) << Arg << ArgRange;
       Diag(PrevCommand->getLocation(), diag::note_doc_tparam_previous)
-        << PrevCommand->getParamNameRange();
+          << PrevCommand->getParamNameRange();
     }
     PrevCommand = Command;
     return;
   }
 
   SourceRange ArgRange(ArgLocBegin, ArgLocEnd);
-  Diag(ArgLocBegin, diag::warn_doc_tparam_not_found)
-    << Arg << ArgRange;
+  Diag(ArgLocBegin, diag::warn_doc_tparam_not_found) << Arg << ArgRange;
 
   if (!TemplateParameters || TemplateParameters->size() == 0)
     return;
 
   StringRef CorrectedName;
   if (TemplateParameters->size() == 1) {
-    const NamedDecl *Param = TemplateParameters->getParam(0);
-    const IdentifierInfo *II = Param->getIdentifier();
+    NamedDecl const *Param = TemplateParameters->getParam(0);
+    IdentifierInfo const *II = Param->getIdentifier();
     if (II)
       CorrectedName = II->getName();
   } else {
@@ -352,8 +335,8 @@
 
   if (!CorrectedName.empty()) {
     Diag(ArgLocBegin, diag::note_doc_tparam_name_suggestion)
-      << CorrectedName
-      << FixItHint::CreateReplacement(ArgRange, CorrectedName);
+        << CorrectedName
+        << FixItHint::CreateReplacement(ArgRange, CorrectedName);
   }
 }
 
@@ -368,12 +351,9 @@
                                                unsigned CommandID) {
   ArrayRef<InlineCommandComment::Argument> Args;
   StringRef CommandName = Traits.getCommandInfo(CommandID)->Name;
-  return new (Allocator) InlineCommandComment(
-                                  CommandLocBegin,
-                                  CommandLocEnd,
-                                  CommandID,
-                                  getInlineCommandRenderKind(CommandName),
-                                  Args);
+  return new (Allocator)
+      InlineCommandComment(CommandLocBegin, CommandLocEnd, CommandID,
+                           getInlineCommandRenderKind(CommandName), Args);
 }
 
 InlineCommandComment *Sema::actOnInlineCommand(SourceLocation CommandLocBegin,
@@ -383,17 +363,13 @@
                                                SourceLocation ArgLocEnd,
                                                StringRef Arg) {
   typedef InlineCommandComment::Argument Argument;
-  Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
-                                                     ArgLocEnd),
-                                         Arg);
+  Argument *A =
+      new (Allocator) Argument(SourceRange(ArgLocBegin, ArgLocEnd), Arg);
   StringRef CommandName = Traits.getCommandInfo(CommandID)->Name;
 
   return new (Allocator) InlineCommandComment(
-                                  CommandLocBegin,
-                                  CommandLocEnd,
-                                  CommandID,
-                                  getInlineCommandRenderKind(CommandName),
-                                  llvm::makeArrayRef(A, 1));
+      CommandLocBegin, CommandLocEnd, CommandID,
+      getInlineCommandRenderKind(CommandName), llvm::makeArrayRef(A, 1));
 }
 
 InlineContentComment *Sema::actOnUnknownCommand(SourceLocation LocBegin,
@@ -408,13 +384,10 @@
                                                 unsigned CommandID) {
   ArrayRef<InlineCommandComment::Argument> Args;
   return new (Allocator) InlineCommandComment(
-                                  LocBegin, LocEnd, CommandID,
-                                  InlineCommandComment::RenderNormal,
-                                  Args);
+      LocBegin, LocEnd, CommandID, InlineCommandComment::RenderNormal, Args);
 }
 
-TextComment *Sema::actOnText(SourceLocation LocBegin,
-                             SourceLocation LocEnd,
+TextComment *Sema::actOnText(SourceLocation LocBegin, SourceLocation LocEnd,
                              StringRef Text) {
   return new (Allocator) TextComment(LocBegin, LocEnd, Text);
 }
@@ -423,9 +396,7 @@
                                                     unsigned CommandID) {
   StringRef CommandName = Traits.getCommandInfo(CommandID)->Name;
   return new (Allocator) VerbatimBlockComment(
-                                  Loc,
-                                  Loc.getLocWithOffset(1 + CommandName.size()),
-                                  CommandID);
+      Loc, Loc.getLocWithOffset(1 + CommandName.size()), CommandID);
 }
 
 VerbatimBlockLineComment *Sema::actOnVerbatimBlockLine(SourceLocation Loc,
@@ -434,10 +405,8 @@
 }
 
 void Sema::actOnVerbatimBlockFinish(
-                            VerbatimBlockComment *Block,
-                            SourceLocation CloseNameLocBegin,
-                            StringRef CloseName,
-                            ArrayRef<VerbatimBlockLineComment *> Lines) {
+    VerbatimBlockComment *Block, SourceLocation CloseNameLocBegin,
+    StringRef CloseName, ArrayRef<VerbatimBlockLineComment *> Lines) {
   Block->setCloseName(CloseName, CloseNameLocBegin);
   Block->setLines(Lines);
 }
@@ -446,12 +415,9 @@
                                              unsigned CommandID,
                                              SourceLocation TextBegin,
                                              StringRef Text) {
-  VerbatimLineComment *VL = new (Allocator) VerbatimLineComment(
-                              LocBegin,
-                              TextBegin.getLocWithOffset(Text.size()),
-                              CommandID,
-                              TextBegin,
-                              Text);
+  VerbatimLineComment *VL = new (Allocator)
+      VerbatimLineComment(LocBegin, TextBegin.getLocWithOffset(Text.size()),
+                          CommandID, TextBegin, Text);
   checkFunctionDeclVerbatimLine(VL);
   checkContainerDeclVerbatimLine(VL);
   return VL;
@@ -463,10 +429,8 @@
 }
 
 void Sema::actOnHTMLStartTagFinish(
-                              HTMLStartTagComment *Tag,
-                              ArrayRef<HTMLStartTagComment::Attribute> Attrs,
-                              SourceLocation GreaterLoc,
-                              bool IsSelfClosing) {
+    HTMLStartTagComment *Tag, ArrayRef<HTMLStartTagComment::Attribute> Attrs,
+    SourceLocation GreaterLoc, bool IsSelfClosing) {
   Tag->setAttrs(Attrs);
   Tag->setGreaterLoc(GreaterLoc);
   if (IsSelfClosing)
@@ -482,14 +446,15 @@
       new (Allocator) HTMLEndTagComment(LocBegin, LocEnd, TagName);
   if (isHTMLEndTagForbidden(TagName)) {
     Diag(HET->getLocation(), diag::warn_doc_html_end_forbidden)
-      << TagName << HET->getSourceRange();
+        << TagName << HET->getSourceRange();
     HET->setIsMalformed();
     return HET;
   }
 
   bool FoundOpen = false;
   for (SmallVectorImpl<HTMLStartTagComment *>::const_reverse_iterator
-       I = HTMLOpenTags.rbegin(), E = HTMLOpenTags.rend();
+           I = HTMLOpenTags.rbegin(),
+           E = HTMLOpenTags.rend();
        I != E; ++I) {
     if ((*I)->getTagName() == TagName) {
       FoundOpen = true;
@@ -498,7 +463,7 @@
   }
   if (!FoundOpen) {
     Diag(HET->getLocation(), diag::warn_doc_html_end_unbalanced)
-      << HET->getSourceRange();
+        << HET->getSourceRange();
     HET->setIsMalformed();
     return HET;
   }
@@ -517,25 +482,22 @@
       continue;
 
     bool OpenLineInvalid;
-    const unsigned OpenLine = SourceMgr.getPresumedLineNumber(
-                                                HST->getLocation(),
-                                                &OpenLineInvalid);
+    unsigned const OpenLine =
+        SourceMgr.getPresumedLineNumber(HST->getLocation(), &OpenLineInvalid);
     bool CloseLineInvalid;
-    const unsigned CloseLine = SourceMgr.getPresumedLineNumber(
-                                                HET->getLocation(),
-                                                &CloseLineInvalid);
+    unsigned const CloseLine =
+        SourceMgr.getPresumedLineNumber(HET->getLocation(), &CloseLineInvalid);
 
     if (OpenLineInvalid || CloseLineInvalid || OpenLine == CloseLine) {
       Diag(HST->getLocation(), diag::warn_doc_html_start_end_mismatch)
-        << HST->getTagName() << HET->getTagName()
-        << HST->getSourceRange() << HET->getSourceRange();
+          << HST->getTagName() << HET->getTagName() << HST->getSourceRange()
+          << HET->getSourceRange();
       HST->setIsMalformed();
     } else {
       Diag(HST->getLocation(), diag::warn_doc_html_start_end_mismatch)
-        << HST->getTagName() << HET->getTagName()
-        << HST->getSourceRange();
+          << HST->getTagName() << HET->getTagName() << HST->getSourceRange();
       Diag(HET->getLocation(), diag::note_doc_html_end_tag)
-        << HET->getSourceRange();
+          << HET->getSourceRange();
       HST->setIsMalformed();
     }
   }
@@ -543,8 +505,7 @@
   return HET;
 }
 
-FullComment *Sema::actOnFullComment(
-                              ArrayRef<BlockContentComment *> Blocks) {
+FullComment *Sema::actOnFullComment(ArrayRef<BlockContentComment *> Blocks) {
   FullComment *FC = new (Allocator) FullComment(Blocks, ThisDeclInfo);
   resolveParamCommandIndexes(FC);
 
@@ -555,7 +516,7 @@
       continue;
 
     Diag(HST->getLocation(), diag::warn_doc_html_missing_end_tag)
-      << HST->getTagName() << HST->getSourceRange();
+        << HST->getTagName() << HST->getSourceRange();
     HST->setIsMalformed();
   }
 
@@ -574,13 +535,12 @@
     if (!DiagLoc.isValid())
       DiagLoc = Command->getCommandNameRange(Traits).getEnd();
     Diag(DiagLoc, diag::warn_doc_block_command_empty_paragraph)
-      << Command->getCommandMarker()
-      << Command->getCommandName(Traits)
-      << Command->getSourceRange();
+        << Command->getCommandMarker() << Command->getCommandName(Traits)
+        << Command->getSourceRange();
   }
 }
 
-void Sema::checkReturnsCommand(const BlockCommandComment *Command) {
+void Sema::checkReturnsCommand(BlockCommandComment const *Command) {
   if (!Traits.getCommandInfo(Command->getCommandID())->IsReturnsCommand)
     return;
 
@@ -611,24 +571,21 @@
       }
       Diag(Command->getLocation(),
            diag::warn_doc_returns_attached_to_a_void_function)
-        << Command->getCommandMarker()
-        << Command->getCommandName(Traits)
-        << DiagKind
-        << Command->getSourceRange();
+          << Command->getCommandMarker() << Command->getCommandName(Traits)
+          << DiagKind << Command->getSourceRange();
     }
     return;
   }
 
   Diag(Command->getLocation(),
        diag::warn_doc_returns_not_attached_to_a_function_decl)
-    << Command->getCommandMarker()
-    << Command->getCommandName(Traits)
-    << Command->getSourceRange();
+      << Command->getCommandMarker() << Command->getCommandName(Traits)
+      << Command->getSourceRange();
 }
 
-void Sema::checkBlockCommandDuplicate(const BlockCommandComment *Command) {
-  const CommandInfo *Info = Traits.getCommandInfo(Command->getCommandID());
-  const BlockCommandComment *PrevCommand = nullptr;
+void Sema::checkBlockCommandDuplicate(BlockCommandComment const *Command) {
+  CommandInfo const *Info = Traits.getCommandInfo(Command->getCommandID());
+  BlockCommandComment const *PrevCommand = nullptr;
   if (Info->IsBriefCommand) {
     if (!BriefCommand) {
       BriefCommand = Command;
@@ -648,34 +605,29 @@
   StringRef CommandName = Command->getCommandName(Traits);
   StringRef PrevCommandName = PrevCommand->getCommandName(Traits);
   Diag(Command->getLocation(), diag::warn_doc_block_command_duplicate)
-      << Command->getCommandMarker()
-      << CommandName
+      << Command->getCommandMarker() << CommandName
       << Command->getSourceRange();
   if (CommandName == PrevCommandName)
     Diag(PrevCommand->getLocation(), diag::note_doc_block_command_previous)
-        << PrevCommand->getCommandMarker()
-        << PrevCommandName
+        << PrevCommand->getCommandMarker() << PrevCommandName
         << PrevCommand->getSourceRange();
   else
     Diag(PrevCommand->getLocation(),
          diag::note_doc_block_command_previous_alias)
-        << PrevCommand->getCommandMarker()
-        << PrevCommandName
-        << CommandName;
+        << PrevCommand->getCommandMarker() << PrevCommandName << CommandName;
 }
 
-void Sema::checkDeprecatedCommand(const BlockCommandComment *Command) {
+void Sema::checkDeprecatedCommand(BlockCommandComment const *Command) {
   if (!Traits.getCommandInfo(Command->getCommandID())->IsDeprecatedCommand)
     return;
 
   assert(ThisDeclInfo && "should not call this check on a bare comment");
 
-  const Decl *D = ThisDeclInfo->CommentDecl;
+  Decl const *D = ThisDeclInfo->CommentDecl;
   if (!D)
     return;
 
-  if (D->hasAttr<DeprecatedAttr>() ||
-      D->hasAttr<AvailabilityAttr>() ||
+  if (D->hasAttr<DeprecatedAttr>() || D->hasAttr<AvailabilityAttr>() ||
       D->hasAttr<UnavailableAttr>())
     return;
 
@@ -683,16 +635,15 @@
       << Command->getSourceRange() << Command->getCommandMarker();
 
   // Try to emit a fixit with a deprecation attribute.
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+  if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(D)) {
     // Don't emit a Fix-It for non-member function definitions.  GCC does not
     // accept attributes on them.
-    const DeclContext *Ctx = FD->getDeclContext();
-    if ((!Ctx || !Ctx->isRecord()) &&
-        FD->doesThisDeclarationHaveABody())
+    DeclContext const *Ctx = FD->getDeclContext();
+    if ((!Ctx || !Ctx->isRecord()) && FD->doesThisDeclarationHaveABody())
       return;
 
-    const LangOptions &LO = FD->getLangOpts();
-    const bool DoubleSquareBracket = LO.CPlusPlus14 || LO.C2x;
+    LangOptions const &LO = FD->getLangOpts();
+    bool const DoubleSquareBracket = LO.CPlusPlus14 || LO.C2x;
     StringRef AttributeSpelling =
         DoubleSquareBracket ? "[[deprecated]]" : "__attribute__((deprecated))";
     if (PP) {
@@ -729,7 +680,7 @@
   }
 }
 
-void Sema::resolveParamCommandIndexes(const FullComment *FC) {
+void Sema::resolveParamCommandIndexes(FullComment const *FC) {
   if (!isFunctionDecl()) {
     // We already warned that \\param commands are not attached to a function
     // decl.
@@ -742,7 +693,7 @@
   // found a \\param command or NULL if no documentation was found so far.
   SmallVector<ParamCommandComment *, 8> ParamVarDocs;
 
-  ArrayRef<const ParmVarDecl *> ParamVars = getParamVars();
+  ArrayRef<ParmVarDecl const *> ParamVars = getParamVars();
   ParamVarDocs.resize(ParamVars.size(), nullptr);
 
   // First pass over all \\param commands: resolve all parameter names.
@@ -754,8 +705,8 @@
     StringRef ParamName = PCC->getParamNameAsWritten();
 
     // Check that referenced parameter name is in the function decl.
-    const unsigned ResolvedParamIndex = resolveParmVarReference(ParamName,
-                                                                ParamVars);
+    unsigned const ResolvedParamIndex =
+        resolveParmVarReference(ParamName, ParamVars);
     if (ResolvedParamIndex == ParamCommandComment::VarArgParamIndex) {
       PCC->setIsVarArgParam();
       continue;
@@ -768,16 +719,16 @@
     if (ParamVarDocs[ResolvedParamIndex]) {
       SourceRange ArgRange = PCC->getParamNameRange();
       Diag(ArgRange.getBegin(), diag::warn_doc_param_duplicate)
-        << ParamName << ArgRange;
+          << ParamName << ArgRange;
       ParamCommandComment *PrevCommand = ParamVarDocs[ResolvedParamIndex];
       Diag(PrevCommand->getLocation(), diag::note_doc_param_previous)
-        << PrevCommand->getParamNameRange();
+          << PrevCommand->getParamNameRange();
     }
     ParamVarDocs[ResolvedParamIndex] = PCC;
   }
 
   // Find parameter declarations that have no corresponding \\param.
-  SmallVector<const ParmVarDecl *, 8> OrphanedParamDecls;
+  SmallVector<ParmVarDecl const *, 8> OrphanedParamDecls;
   for (unsigned i = 0, e = ParamVarDocs.size(); i != e; ++i) {
     if (!ParamVarDocs[i])
       OrphanedParamDecls.push_back(ParamVars[i]);
@@ -787,12 +738,12 @@
   // Suggest corrections from a set of parameter declarations that have no
   // corresponding \\param.
   for (unsigned i = 0, e = UnresolvedParamCommands.size(); i != e; ++i) {
-    const ParamCommandComment *PCC = UnresolvedParamCommands[i];
+    ParamCommandComment const *PCC = UnresolvedParamCommands[i];
 
     SourceRange ArgRange = PCC->getParamNameRange();
     StringRef ParamName = PCC->getParamNameAsWritten();
     Diag(ArgRange.getBegin(), diag::warn_doc_param_not_found)
-      << ParamName << ArgRange;
+        << ParamName << ArgRange;
 
     // All parameters documented -- can't suggest a correction.
     if (OrphanedParamDecls.size() == 0)
@@ -805,15 +756,15 @@
       CorrectedParamIndex = 0;
     } else {
       // Do typo correction.
-      CorrectedParamIndex = correctTypoInParmVarReference(ParamName,
-                                                          OrphanedParamDecls);
+      CorrectedParamIndex =
+          correctTypoInParmVarReference(ParamName, OrphanedParamDecls);
     }
     if (CorrectedParamIndex != ParamCommandComment::InvalidParamIndex) {
-      const ParmVarDecl *CorrectedPVD = OrphanedParamDecls[CorrectedParamIndex];
-      if (const IdentifierInfo *CorrectedII = CorrectedPVD->getIdentifier())
+      ParmVarDecl const *CorrectedPVD = OrphanedParamDecls[CorrectedParamIndex];
+      if (IdentifierInfo const *CorrectedII = CorrectedPVD->getIdentifier())
         Diag(ArgRange.getBegin(), diag::note_doc_param_name_suggestion)
-          << CorrectedII->getName()
-          << FixItHint::CreateReplacement(ArgRange, CorrectedII->getName());
+            << CorrectedII->getName()
+            << FixItHint::CreateReplacement(ArgRange, CorrectedII->getName());
     }
   }
 }
@@ -834,21 +785,21 @@
 bool Sema::isFunctionOrMethodVariadic() {
   if (!isFunctionDecl() || !ThisDeclInfo->CurrentDecl)
     return false;
-  if (const FunctionDecl *FD =
-        dyn_cast<FunctionDecl>(ThisDeclInfo->CurrentDecl))
+  if (FunctionDecl const *FD =
+          dyn_cast<FunctionDecl>(ThisDeclInfo->CurrentDecl))
     return FD->isVariadic();
-  if (const FunctionTemplateDecl *FTD =
-        dyn_cast<FunctionTemplateDecl>(ThisDeclInfo->CurrentDecl))
+  if (FunctionTemplateDecl const *FTD =
+          dyn_cast<FunctionTemplateDecl>(ThisDeclInfo->CurrentDecl))
     return FTD->getTemplatedDecl()->isVariadic();
-  if (const ObjCMethodDecl *MD =
-        dyn_cast<ObjCMethodDecl>(ThisDeclInfo->CurrentDecl))
+  if (ObjCMethodDecl const *MD =
+          dyn_cast<ObjCMethodDecl>(ThisDeclInfo->CurrentDecl))
     return MD->isVariadic();
-  if (const TypedefNameDecl *TD =
+  if (TypedefNameDecl const *TD =
           dyn_cast<TypedefNameDecl>(ThisDeclInfo->CurrentDecl)) {
     QualType Type = TD->getUnderlyingType();
     if (Type->isFunctionPointerType() || Type->isBlockPointerType())
       Type = Type->getPointeeType();
-    if (const auto *FT = Type->getAs<FunctionProtoType>())
+    if (auto const *FT = Type->getAs<FunctionProtoType>())
       return FT->isVariadic();
   }
   return false;
@@ -865,7 +816,8 @@
   if (!ThisDeclInfo->IsFilled)
     inspectThisDecl();
   if (ThisDeclInfo->getKind() == DeclInfo::VariableKind) {
-    if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDeclInfo->CurrentDecl)) {
+    if (VarDecl const *VD =
+            dyn_cast_or_null<VarDecl>(ThisDeclInfo->CurrentDecl)) {
       QualType QT = VD->getType();
       return QT->isFunctionPointerType();
     }
@@ -882,9 +834,9 @@
       !ThisDeclInfo->CurrentDecl)
     return false;
   QualType QT;
-  if (const auto *VD = dyn_cast<DeclaratorDecl>(ThisDeclInfo->CurrentDecl))
+  if (auto const *VD = dyn_cast<DeclaratorDecl>(ThisDeclInfo->CurrentDecl))
     QT = VD->getType();
-  else if (const auto *PD =
+  else if (auto const *PD =
                dyn_cast<ObjCPropertyDecl>(ThisDeclInfo->CurrentDecl))
     QT = PD->getType();
   else
@@ -894,10 +846,10 @@
   // can be ignored.
   if (QT->getAs<TypedefType>())
     return false;
-  if (const auto *P = QT->getAs<PointerType>())
+  if (auto const *P = QT->getAs<PointerType>())
     if (P->getPointeeType()->getAs<TypedefType>())
       return false;
-  if (const auto *P = QT->getAs<BlockPointerType>())
+  if (auto const *P = QT->getAs<BlockPointerType>())
     if (P->getPointeeType()->getAs<TypedefType>())
       return false;
   return QT->isFunctionPointerType() || QT->isBlockPointerType();
@@ -933,12 +885,12 @@
     return false;
   if (!ThisDeclInfo->IsFilled)
     inspectThisDecl();
-  if (const RecordDecl *RD =
-        dyn_cast_or_null<RecordDecl>(ThisDeclInfo->CurrentDecl))
+  if (RecordDecl const *RD =
+          dyn_cast_or_null<RecordDecl>(ThisDeclInfo->CurrentDecl))
     return RD->isUnion();
   return false;
 }
-static bool isClassOrStructDeclImpl(const Decl *D) {
+static bool isClassOrStructDeclImpl(Decl const *D) {
   if (auto *record = dyn_cast_or_null<RecordDecl>(D))
     return !record->isUnion();
 
@@ -969,7 +921,8 @@
   if (isClassOrStructDeclImpl(ThisDeclInfo->CurrentDecl))
     return true;
 
-  if (auto *ThisTypedefDecl = dyn_cast<TypedefDecl>(ThisDeclInfo->CurrentDecl)) {
+  if (auto *ThisTypedefDecl =
+          dyn_cast<TypedefDecl>(ThisDeclInfo->CurrentDecl)) {
     auto UnderlyingType = ThisTypedefDecl->getUnderlyingType();
     if (auto ThisElaboratedType = dyn_cast<ElaboratedType>(UnderlyingType)) {
       auto DesugaredType = ThisElaboratedType->desugar();
@@ -990,7 +943,7 @@
   if (!ThisDeclInfo->IsFilled)
     inspectThisDecl();
   return ThisDeclInfo->CurrentDecl &&
-          (isa<ClassTemplateDecl>(ThisDeclInfo->CurrentDecl));
+         (isa<ClassTemplateDecl>(ThisDeclInfo->CurrentDecl));
 }
 
 bool Sema::isFunctionTemplateDecl() {
@@ -1020,20 +973,19 @@
          isa<ObjCProtocolDecl>(ThisDeclInfo->CurrentDecl);
 }
 
-ArrayRef<const ParmVarDecl *> Sema::getParamVars() {
+ArrayRef<ParmVarDecl const *> Sema::getParamVars() {
   if (!ThisDeclInfo->IsFilled)
     inspectThisDecl();
   return ThisDeclInfo->ParamVars;
 }
 
-void Sema::inspectThisDecl() {
-  ThisDeclInfo->fill();
-}
+void Sema::inspectThisDecl() { ThisDeclInfo->fill(); }
 
-unsigned Sema::resolveParmVarReference(StringRef Name,
-                                       ArrayRef<const ParmVarDecl *> ParamVars) {
+unsigned
+Sema::resolveParmVarReference(StringRef Name,
+                              ArrayRef<ParmVarDecl const *> ParamVars) {
   for (unsigned i = 0, e = ParamVars.size(); i != e; ++i) {
-    const IdentifierInfo *II = ParamVars[i]->getIdentifier();
+    IdentifierInfo const *II = ParamVars[i]->getIdentifier();
     if (II && II->getName() == Name)
       return i;
   }
@@ -1044,10 +996,10 @@
 
 namespace {
 class SimpleTypoCorrector {
-  const NamedDecl *BestDecl;
+  NamedDecl const *BestDecl;
 
   StringRef Typo;
-  const unsigned MaxEditDistance;
+  unsigned const MaxEditDistance;
 
   unsigned BestEditDistance;
   unsigned BestIndex;
@@ -1058,9 +1010,9 @@
       : BestDecl(nullptr), Typo(Typo), MaxEditDistance((Typo.size() + 2) / 3),
         BestEditDistance(MaxEditDistance + 1), BestIndex(0), NextIndex(0) {}
 
-  void addDecl(const NamedDecl *ND);
+  void addDecl(NamedDecl const *ND);
 
-  const NamedDecl *getBestDecl() const {
+  NamedDecl const *getBestDecl() const {
     if (BestEditDistance > MaxEditDistance)
       return nullptr;
 
@@ -1073,17 +1025,16 @@
   }
 };
 
-void SimpleTypoCorrector::addDecl(const NamedDecl *ND) {
+void SimpleTypoCorrector::addDecl(NamedDecl const *ND) {
   unsigned CurrIndex = NextIndex++;
 
-  const IdentifierInfo *II = ND->getIdentifier();
+  IdentifierInfo const *II = ND->getIdentifier();
   if (!II)
     return;
 
   StringRef Name = II->getName();
   unsigned MinPossibleEditDistance = abs((int)Name.size() - (int)Typo.size());
-  if (MinPossibleEditDistance > 0 &&
-      Typo.size() / MinPossibleEditDistance < 3)
+  if (MinPossibleEditDistance > 0 && Typo.size() / MinPossibleEditDistance < 3)
     return;
 
   unsigned EditDistance = Typo.edit_distance(Name, true, MaxEditDistance);
@@ -1095,9 +1046,9 @@
 }
 } // end anonymous namespace
 
-unsigned Sema::correctTypoInParmVarReference(
-                                    StringRef Typo,
-                                    ArrayRef<const ParmVarDecl *> ParamVars) {
+unsigned
+Sema::correctTypoInParmVarReference(StringRef Typo,
+                                    ArrayRef<ParmVarDecl const *> ParamVars) {
   SimpleTypoCorrector Corrector(Typo);
   for (unsigned i = 0, e = ParamVars.size(); i != e; ++i)
     Corrector.addDecl(ParamVars[i]);
@@ -1109,18 +1060,17 @@
 
 namespace {
 bool ResolveTParamReferenceHelper(
-                            StringRef Name,
-                            const TemplateParameterList *TemplateParameters,
-                            SmallVectorImpl<unsigned> *Position) {
+    StringRef Name, TemplateParameterList const *TemplateParameters,
+    SmallVectorImpl<unsigned> *Position) {
   for (unsigned i = 0, e = TemplateParameters->size(); i != e; ++i) {
-    const NamedDecl *Param = TemplateParameters->getParam(i);
-    const IdentifierInfo *II = Param->getIdentifier();
+    NamedDecl const *Param = TemplateParameters->getParam(i);
+    IdentifierInfo const *II = Param->getIdentifier();
     if (II && II->getName() == Name) {
       Position->push_back(i);
       return true;
     }
 
-    if (const TemplateTemplateParmDecl *TTP =
+    if (TemplateTemplateParmDecl const *TTP =
             dyn_cast<TemplateTemplateParmDecl>(Param)) {
       Position->push_back(i);
       if (ResolveTParamReferenceHelper(Name, TTP->getTemplateParameters(),
@@ -1134,9 +1084,8 @@
 } // end anonymous namespace
 
 bool Sema::resolveTParamReference(
-                            StringRef Name,
-                            const TemplateParameterList *TemplateParameters,
-                            SmallVectorImpl<unsigned> *Position) {
+    StringRef Name, TemplateParameterList const *TemplateParameters,
+    SmallVectorImpl<unsigned> *Position) {
   Position->clear();
   if (!TemplateParameters)
     return false;
@@ -1146,13 +1095,13 @@
 
 namespace {
 void CorrectTypoInTParamReferenceHelper(
-                            const TemplateParameterList *TemplateParameters,
-                            SimpleTypoCorrector &Corrector) {
+    TemplateParameterList const *TemplateParameters,
+    SimpleTypoCorrector &Corrector) {
   for (unsigned i = 0, e = TemplateParameters->size(); i != e; ++i) {
-    const NamedDecl *Param = TemplateParameters->getParam(i);
+    NamedDecl const *Param = TemplateParameters->getParam(i);
     Corrector.addDecl(Param);
 
-    if (const TemplateTemplateParmDecl *TTP =
+    if (TemplateTemplateParmDecl const *TTP =
             dyn_cast<TemplateTemplateParmDecl>(Param))
       CorrectTypoInTParamReferenceHelper(TTP->getTemplateParameters(),
                                          Corrector);
@@ -1161,12 +1110,11 @@
 } // end anonymous namespace
 
 StringRef Sema::correctTypoInTParamReference(
-                            StringRef Typo,
-                            const TemplateParameterList *TemplateParameters) {
+    StringRef Typo, TemplateParameterList const *TemplateParameters) {
   SimpleTypoCorrector Corrector(Typo);
   CorrectTypoInTParamReferenceHelper(TemplateParameters, Corrector);
-  if (const NamedDecl *ND = Corrector.getBestDecl()) {
-    const IdentifierInfo *II = ND->getIdentifier();
+  if (NamedDecl const *ND = Corrector.getBestDecl()) {
+    IdentifierInfo const *II = ND->getIdentifier();
     assert(II && "SimpleTypoCorrector should not return this decl");
     return II->getName();
   }
Index: clang/lib/AST/ComparisonCategories.cpp
===================================================================
--- clang/lib/AST/ComparisonCategories.cpp
+++ clang/lib/AST/ComparisonCategories.cpp
@@ -86,7 +86,7 @@
   return &Objects.back();
 }
 
-static const NamespaceDecl *lookupStdNamespace(const ASTContext &Ctx,
+static NamespaceDecl const *lookupStdNamespace(ASTContext const &Ctx,
                                                NamespaceDecl *&StdNS) {
   if (!StdNS) {
     DeclContextLookupResult Lookup =
@@ -97,8 +97,8 @@
   return StdNS;
 }
 
-static CXXRecordDecl *lookupCXXRecordDecl(const ASTContext &Ctx,
-                                          const NamespaceDecl *StdNS,
+static CXXRecordDecl *lookupCXXRecordDecl(ASTContext const &Ctx,
+                                          NamespaceDecl const *StdNS,
                                           ComparisonCategoryType Kind) {
   StringRef Name = ComparisonCategories::getCategoryString(Kind);
   DeclContextLookupResult Lookup = StdNS->lookup(&Ctx.Idents.get(Name));
@@ -108,20 +108,20 @@
   return nullptr;
 }
 
-const ComparisonCategoryInfo *
+ComparisonCategoryInfo const *
 ComparisonCategories::lookupInfo(ComparisonCategoryType Kind) const {
   auto It = Data.find(static_cast<char>(Kind));
   if (It != Data.end())
     return &It->second;
 
-  if (const NamespaceDecl *NS = lookupStdNamespace(Ctx, StdNS))
+  if (NamespaceDecl const *NS = lookupStdNamespace(Ctx, StdNS))
     if (CXXRecordDecl *RD = lookupCXXRecordDecl(Ctx, NS, Kind))
       return &Data.try_emplace((char)Kind, Ctx, RD, Kind).first->second;
 
   return nullptr;
 }
 
-const ComparisonCategoryInfo *
+ComparisonCategoryInfo const *
 ComparisonCategories::lookupInfoForType(QualType Ty) const {
   assert(!Ty.isNull() && "type must be non-null");
   using CCT = ComparisonCategoryType;
@@ -130,9 +130,9 @@
     return nullptr;
 
   // Check to see if we have information for the specified type cached.
-  const auto *CanonRD = RD->getCanonicalDecl();
+  auto const *CanonRD = RD->getCanonicalDecl();
   for (auto &KV : Data) {
-    const ComparisonCategoryInfo &Info = KV.second;
+    ComparisonCategoryInfo const &Info = KV.second;
     if (CanonRD == Info.Record->getCanonicalDecl())
       return &Info;
   }
@@ -157,8 +157,9 @@
   return nullptr;
 }
 
-const ComparisonCategoryInfo &ComparisonCategories::getInfoForType(QualType Ty) const {
-  const ComparisonCategoryInfo *Info = lookupInfoForType(Ty);
+ComparisonCategoryInfo const &
+ComparisonCategories::getInfoForType(QualType Ty) const {
+  ComparisonCategoryInfo const *Info = lookupInfoForType(Ty);
   assert(Info && "info for comparison category not found");
   return *Info;
 }
Index: clang/lib/AST/ComputeDependence.cpp
===================================================================
--- clang/lib/AST/ComputeDependence.cpp
+++ clang/lib/AST/ComputeDependence.cpp
@@ -38,7 +38,7 @@
 }
 
 ExprDependence clang::computeDependence(UnaryOperator *E,
-                                        const ASTContext &Ctx) {
+                                        ASTContext const &Ctx) {
   ExprDependence Dep = toExprDependence(E->getType()->getDependence()) |
                        E->getSubExpr()->getDependence();
 
@@ -60,7 +60,7 @@
     // FIXME: This doesn't enforce the C++98 constant expression rules.
     if (E->getSubExpr()->EvaluateAsConstantExpr(Result, Ctx) && Diag.empty() &&
         Result.Val.isLValue()) {
-      auto *VD = Result.Val.getLValueBase().dyn_cast<const ValueDecl *>();
+      auto *VD = Result.Val.getLValueBase().dyn_cast<ValueDecl const *>();
       if (VD && VD->isTemplated()) {
         auto *VarD = dyn_cast<VarDecl>(VD);
         if (!VarD || !VarD->hasLocalStorage())
@@ -93,14 +93,14 @@
     return Deps;
 
   auto *NoParens = E->getArgumentExpr()->IgnoreParens();
-  const ValueDecl *D = nullptr;
-  if (const auto *DRE = dyn_cast<DeclRefExpr>(NoParens))
+  ValueDecl const *D = nullptr;
+  if (auto const *DRE = dyn_cast<DeclRefExpr>(NoParens))
     D = DRE->getDecl();
-  else if (const auto *ME = dyn_cast<MemberExpr>(NoParens))
+  else if (auto const *ME = dyn_cast<MemberExpr>(NoParens))
     D = ME->getMemberDecl();
   if (!D)
     return Deps;
-  for (const auto *I : D->specific_attrs<AlignedAttr>()) {
+  for (auto const *I : D->specific_attrs<AlignedAttr>()) {
     if (I->isAlignmentErrorDependent())
       Deps |= ExprDependence::Error;
     if (I->isAlignmentDependent())
@@ -160,9 +160,9 @@
 ExprDependence clang::computeDependence(StmtExpr *E, unsigned TemplateDepth) {
   auto D = toExprDependence(E->getType()->getDependence());
   // Propagate dependence of the result.
-  if (const auto *CompoundExprResult =
+  if (auto const *CompoundExprResult =
           dyn_cast_or_null<ValueStmt>(E->getSubStmt()->getStmtExprResult()))
-    if (const Expr *ResultExpr = CompoundExprResult->getExprStmt())
+    if (Expr const *ResultExpr = CompoundExprResult->getExprStmt())
       D |= ResultExpr->getDependence();
   // Note: we treat a statement-expression in a dependent context as always
   // being value- and instantiation-dependent. This matches the behavior of
@@ -408,7 +408,7 @@
 ExprDependence clang::computeDependence(OMPArrayShapingExpr *E) {
   auto D = E->getBase()->getDependence() |
            toExprDependence(E->getType()->getDependence());
-  for (Expr *Dim: E->getDimensions())
+  for (Expr *Dim : E->getDimensions())
     if (Dim)
       D |= Dim->getDependence();
   return D;
@@ -433,7 +433,7 @@
 /// Compute the type-, value-, and instantiation-dependence of a
 /// declaration reference
 /// based on the declaration being referenced.
-ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) {
+ExprDependence clang::computeDependence(DeclRefExpr *E, ASTContext const &Ctx) {
   auto Deps = ExprDependence::None;
 
   if (auto *NNS = E->getQualifier())
@@ -498,9 +498,9 @@
 
   //   - it names a potentially-constant variable that is initialized with an
   //     expression that is value-dependent
-  if (const auto *Var = dyn_cast<VarDecl>(Decl)) {
+  if (auto const *Var = dyn_cast<VarDecl>(Decl)) {
     if (Var->mightBeUsableInConstantExpressions(Ctx)) {
-      if (const Expr *Init = Var->getAnyInitializer()) {
+      if (Expr const *Init = Var->getAnyInitializer()) {
         if (Init->isValueDependent())
           Deps |= ExprDependence::ValueInstantiation;
         if (Init->containsErrors())
@@ -513,7 +513,7 @@
     if (Var->isStaticDataMember() &&
         Var->getDeclContext()->isDependentContext() &&
         !Var->getFirstDecl()->hasInit()) {
-      const VarDecl *First = Var->getFirstDecl();
+      VarDecl const *First = Var->getFirstDecl();
       TypeSourceInfo *TInfo = First->getTypeSourceInfo();
       if (TInfo->getType()->isIncompleteArrayType()) {
         Deps |= ExprDependence::TypeValueInstantiation;
@@ -690,7 +690,7 @@
   return D;
 }
 
-static inline ExprDependence getDependenceInExpr(DeclarationNameInfo Name) {
+inline static ExprDependence getDependenceInExpr(DeclarationNameInfo Name) {
   auto D = ExprDependence::None;
   if (Name.isInstantiationDependent())
     D |= ExprDependence::Instantiation;
@@ -787,7 +787,7 @@
 
 ExprDependence clang::computeDependence(CXXFoldExpr *E) {
   auto D = ExprDependence::TypeValueInstantiation;
-  for (const auto *C : {E->getLHS(), E->getRHS()}) {
+  for (auto const *C : {E->getLHS(), E->getRHS()}) {
     if (C)
       D |= C->getDependence() & ~ExprDependence::UnexpandedPack;
   }
@@ -796,7 +796,7 @@
 
 ExprDependence clang::computeDependence(TypeTraitExpr *E) {
   auto D = ExprDependence::None;
-  for (const auto *A : E->getArgs())
+  for (auto const *A : E->getArgs())
     D |=
         toExprDependence(A->getType()->getDependence()) & ~ExprDependence::Type;
   return D;
@@ -805,9 +805,9 @@
 ExprDependence clang::computeDependence(ConceptSpecializationExpr *E,
                                         bool ValueDependent) {
   auto TA = TemplateArgumentDependence::None;
-  const auto InterestingDeps = TemplateArgumentDependence::Instantiation |
+  auto const InterestingDeps = TemplateArgumentDependence::Instantiation |
                                TemplateArgumentDependence::UnexpandedPack;
-  for (const TemplateArgumentLoc &ArgLoc :
+  for (TemplateArgumentLoc const &ArgLoc :
        E->getTemplateArgsAsWritten()->arguments()) {
     TA |= ArgLoc.getArgument().getDependence() & InterestingDeps;
     if (TA == InterestingDeps)
Index: clang/lib/AST/Decl.cpp
===================================================================
--- clang/lib/AST/Decl.cpp
+++ clang/lib/AST/Decl.cpp
@@ -79,7 +79,8 @@
 
 void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
   SourceLocation Loc = this->Loc;
-  if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
+  if (!Loc.isValid() && TheDecl)
+    Loc = TheDecl->getLocation();
   if (Loc.isValid()) {
     Loc.print(OS, Context.getSourceManager());
     OS << ": ";
@@ -162,13 +163,12 @@
 
 /// Given an LVComputationKind, return one of the same type/value sort
 /// that records that it already has explicit visibility.
-static LVComputationKind
-withExplicitVisibilityAlready(LVComputationKind Kind) {
+static LVComputationKind withExplicitVisibilityAlready(LVComputationKind Kind) {
   Kind.IgnoreExplicitVisibility = true;
   return Kind;
 }
 
-static Optional<Visibility> getExplicitVisibility(const NamedDecl *D,
+static Optional<Visibility> getExplicitVisibility(NamedDecl const *D,
                                                   LVComputationKind kind) {
   assert(!kind.IgnoreExplicitVisibility &&
          "asking for explicit visibility when we shouldn't be");
@@ -177,19 +177,19 @@
 
 /// Is the given declaration a "type" or a "value" for the purposes of
 /// visibility computation?
-static bool usesTypeVisibility(const NamedDecl *D) {
-  return isa<TypeDecl>(D) ||
-         isa<ClassTemplateDecl>(D) ||
+static bool usesTypeVisibility(NamedDecl const *D) {
+  return isa<TypeDecl>(D) || isa<ClassTemplateDecl>(D) ||
          isa<ObjCInterfaceDecl>(D);
 }
 
 /// Does the given declaration have member specialization information,
 /// and if so, is it an explicit specialization?
-template <class T> static typename
-std::enable_if<!std::is_base_of<RedeclarableTemplateDecl, T>::value, bool>::type
+template <class T>
+static typename std::enable_if<
+    !std::is_base_of<RedeclarableTemplateDecl, T>::value, bool>::type
 isExplicitMemberSpecialization(const T *D) {
-  if (const MemberSpecializationInfo *member =
-        D->getMemberSpecializationInfo()) {
+  if (MemberSpecializationInfo const *member =
+          D->getMemberSpecializationInfo()) {
     return member->isExplicitSpecialization();
   }
   return false;
@@ -198,14 +198,13 @@
 /// For templates, this question is easier: a member template can't be
 /// explicitly instantiated, so there's a single bit indicating whether
 /// or not this is an explicit member specialization.
-static bool isExplicitMemberSpecialization(const RedeclarableTemplateDecl *D) {
+static bool isExplicitMemberSpecialization(RedeclarableTemplateDecl const *D) {
   return D->isMemberSpecialization();
 }
 
 /// Given a visibility attribute, return the explicit visibility
 /// associated with it.
-template <class T>
-static Visibility getVisibilityFromAttr(const T *attr) {
+template <class T> static Visibility getVisibilityFromAttr(const T *attr) {
   switch (attr->getVisibility()) {
   case T::Default:
     return DefaultVisibility;
@@ -218,25 +217,25 @@
 }
 
 /// Return the explicit visibility of the given declaration.
-static Optional<Visibility> getVisibilityOf(const NamedDecl *D,
-                                    NamedDecl::ExplicitVisibilityKind kind) {
+static Optional<Visibility>
+getVisibilityOf(NamedDecl const *D, NamedDecl::ExplicitVisibilityKind kind) {
   // If we're ultimately computing the visibility of a type, look for
   // a 'type_visibility' attribute before looking for 'visibility'.
   if (kind == NamedDecl::VisibilityForType) {
-    if (const auto *A = D->getAttr<TypeVisibilityAttr>()) {
+    if (auto const *A = D->getAttr<TypeVisibilityAttr>()) {
       return getVisibilityFromAttr(A);
     }
   }
 
   // If this declaration has an explicit visibility attribute, use it.
-  if (const auto *A = D->getAttr<VisibilityAttr>()) {
+  if (auto const *A = D->getAttr<VisibilityAttr>()) {
     return getVisibilityFromAttr(A);
   }
 
   return None;
 }
 
-LinkageInfo LinkageComputer::getLVForType(const Type &T,
+LinkageInfo LinkageComputer::getLVForType(Type const &T,
                                           LVComputationKind computation) {
   if (computation.IgnoreAllVisibility)
     return LinkageInfo(T.getLinkage(), DefaultVisibility, true);
@@ -247,9 +246,9 @@
 /// template parameter list.  For visibility purposes, template
 /// parameters are part of the signature of a template.
 LinkageInfo LinkageComputer::getLVForTemplateParameterList(
-    const TemplateParameterList *Params, LVComputationKind computation) {
+    TemplateParameterList const *Params, LVComputationKind computation) {
   LinkageInfo LV;
-  for (const NamedDecl *P : *Params) {
+  for (NamedDecl const *P : *Params) {
     // Template type parameters are the most common and never
     // contribute to visibility, pack or not.
     if (isa<TemplateTypeParmDecl>(P))
@@ -259,7 +258,7 @@
     //   template <enum X> class A { ... };
     // We have to be careful here, though, because we can be dealing with
     // dependent types.
-    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
+    if (auto const *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
       // Handle the non-pack case first.
       if (!NTTP->isExpandedParameterPack()) {
         if (!NTTP->getType()->isDependentType()) {
@@ -279,7 +278,7 @@
 
     // Template template parameters can be restricted by their
     // template parameters, recursively.
-    const auto *TTP = cast<TemplateTemplateParmDecl>(P);
+    auto const *TTP = cast<TemplateTemplateParmDecl>(P);
 
     // Handle the non-pack case first.
     if (!TTP->isExpandedParameterPack()) {
@@ -289,8 +288,8 @@
     }
 
     // Look at all expansions in an expanded pack.
-    for (unsigned i = 0, n = TTP->getNumExpansionTemplateParameters();
-           i != n; ++i) {
+    for (unsigned i = 0, n = TTP->getNumExpansionTemplateParameters(); i != n;
+         ++i) {
       LV.merge(getLVForTemplateParameterList(
           TTP->getExpansionTemplateParameters(i), computation));
     }
@@ -299,9 +298,9 @@
   return LV;
 }
 
-static const Decl *getOutermostFuncOrBlockContext(const Decl *D) {
-  const Decl *Ret = nullptr;
-  const DeclContext *DC = D->getDeclContext();
+static Decl const *getOutermostFuncOrBlockContext(Decl const *D) {
+  Decl const *Ret = nullptr;
+  DeclContext const *DC = D->getDeclContext();
   while (DC->getDeclKind() != Decl::TranslationUnit) {
     if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC))
       Ret = cast<Decl>(DC);
@@ -320,7 +319,7 @@
                                               LVComputationKind computation) {
   LinkageInfo LV;
 
-  for (const TemplateArgument &Arg : Args) {
+  for (TemplateArgument const &Arg : Args) {
     switch (Arg.getKind()) {
     case TemplateArgument::Null:
     case TemplateArgument::Integral:
@@ -332,7 +331,7 @@
       continue;
 
     case TemplateArgument::Declaration: {
-      const NamedDecl *ND = Arg.getAsDecl();
+      NamedDecl const *ND = Arg.getAsDecl();
       assert(!usesTypeVisibility(ND));
       LV.merge(getLVForDecl(ND, computation));
       continue;
@@ -360,13 +359,14 @@
 }
 
 LinkageInfo
-LinkageComputer::getLVForTemplateArgumentList(const TemplateArgumentList &TArgs,
+LinkageComputer::getLVForTemplateArgumentList(TemplateArgumentList const &TArgs,
                                               LVComputationKind computation) {
   return getLVForTemplateArgumentList(TArgs.asArray(), computation);
 }
 
-static bool shouldConsiderTemplateVisibility(const FunctionDecl *fn,
-                        const FunctionTemplateSpecializationInfo *specInfo) {
+static bool shouldConsiderTemplateVisibility(
+    FunctionDecl const *fn,
+    FunctionTemplateSpecializationInfo const *specInfo) {
   // Include visibility from the template parameters and arguments
   // only if this is not an explicit instantiation or specialization
   // with direct explicit visibility.  (Implicit instantiations won't
@@ -385,27 +385,26 @@
 ///
 /// \param[out] LV the computation to use for the parent
 void LinkageComputer::mergeTemplateLV(
-    LinkageInfo &LV, const FunctionDecl *fn,
-    const FunctionTemplateSpecializationInfo *specInfo,
+    LinkageInfo &LV, FunctionDecl const *fn,
+    FunctionTemplateSpecializationInfo const *specInfo,
     LVComputationKind computation) {
-  bool considerVisibility =
-    shouldConsiderTemplateVisibility(fn, specInfo);
+  bool considerVisibility = shouldConsiderTemplateVisibility(fn, specInfo);
 
   // Merge information from the template parameters.
   FunctionTemplateDecl *temp = specInfo->getTemplate();
   LinkageInfo tempLV =
-    getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
+      getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
   LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
 
   // Merge information from the template arguments.
-  const TemplateArgumentList &templateArgs = *specInfo->TemplateArguments;
+  TemplateArgumentList const &templateArgs = *specInfo->TemplateArguments;
   LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
   LV.mergeMaybeWithVisibility(argsLV, considerVisibility);
 }
 
 /// Does the given declaration have a direct visibility attribute
 /// that would match the given rules?
-static bool hasDirectVisibilityAttribute(const NamedDecl *D,
+static bool hasDirectVisibilityAttribute(NamedDecl const *D,
                                          LVComputationKind computation) {
   if (computation.IgnoreAllVisibility)
     return false;
@@ -416,8 +415,8 @@
 
 /// Should we consider visibility associated with the template
 /// arguments and parameters of the given class template specialization?
-static bool shouldConsiderTemplateVisibility(
-                                 const ClassTemplateSpecializationDecl *spec,
+static bool
+shouldConsiderTemplateVisibility(ClassTemplateSpecializationDecl const *spec,
                                  LVComputationKind computation) {
   // Include visibility from the template parameters and arguments
   // only if this is not an explicit instantiation or specialization
@@ -453,7 +452,7 @@
 /// Merge in template-related linkage and visibility for the given
 /// class template specialization.
 void LinkageComputer::mergeTemplateLV(
-    LinkageInfo &LV, const ClassTemplateSpecializationDecl *spec,
+    LinkageInfo &LV, ClassTemplateSpecializationDecl const *spec,
     LVComputationKind computation) {
   bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
 
@@ -462,14 +461,14 @@
 
   ClassTemplateDecl *temp = spec->getSpecializedTemplate();
   LinkageInfo tempLV =
-    getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
-  LV.mergeMaybeWithVisibility(tempLV,
-           considerVisibility && !hasExplicitVisibilityAlready(computation));
+      getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
+  LV.mergeMaybeWithVisibility(
+      tempLV, considerVisibility && !hasExplicitVisibilityAlready(computation));
 
   // Merge information from the template arguments.  We ignore
   // template-argument visibility if we've got an explicit
   // instantiation with a visibility attribute.
-  const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
+  TemplateArgumentList const &templateArgs = spec->getTemplateArgs();
   LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
   if (considerVisibility)
     LV.mergeVisibility(argsLV);
@@ -480,8 +479,8 @@
 /// arguments and parameters of the given variable template
 /// specialization? As usual, follow class template specialization
 /// logic up to initialization.
-static bool shouldConsiderTemplateVisibility(
-                                 const VarTemplateSpecializationDecl *spec,
+static bool
+shouldConsiderTemplateVisibility(VarTemplateSpecializationDecl const *spec,
                                  LVComputationKind computation) {
   // Include visibility from the template parameters and arguments
   // only if this is not an explicit instantiation or specialization
@@ -505,7 +504,7 @@
 /// variable template specialization. As usual, follow class template
 /// specialization logic up to initialization.
 void LinkageComputer::mergeTemplateLV(LinkageInfo &LV,
-                                      const VarTemplateSpecializationDecl *spec,
+                                      VarTemplateSpecializationDecl const *spec,
                                       LVComputationKind computation) {
   bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
 
@@ -514,46 +513,46 @@
 
   VarTemplateDecl *temp = spec->getSpecializedTemplate();
   LinkageInfo tempLV =
-    getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
-  LV.mergeMaybeWithVisibility(tempLV,
-           considerVisibility && !hasExplicitVisibilityAlready(computation));
+      getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
+  LV.mergeMaybeWithVisibility(
+      tempLV, considerVisibility && !hasExplicitVisibilityAlready(computation));
 
   // Merge information from the template arguments.  We ignore
   // template-argument visibility if we've got an explicit
   // instantiation with a visibility attribute.
-  const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
+  TemplateArgumentList const &templateArgs = spec->getTemplateArgs();
   LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
   if (considerVisibility)
     LV.mergeVisibility(argsLV);
   LV.mergeExternalVisibility(argsLV);
 }
 
-static bool useInlineVisibilityHidden(const NamedDecl *D) {
+static bool useInlineVisibilityHidden(NamedDecl const *D) {
   // FIXME: we should warn if -fvisibility-inlines-hidden is used with c.
-  const LangOptions &Opts = D->getASTContext().getLangOpts();
+  LangOptions const &Opts = D->getASTContext().getLangOpts();
   if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
     return false;
 
-  const auto *FD = dyn_cast<FunctionDecl>(D);
+  auto const *FD = dyn_cast<FunctionDecl>(D);
   if (!FD)
     return false;
 
   TemplateSpecializationKind TSK = TSK_Undeclared;
-  if (FunctionTemplateSpecializationInfo *spec
-      = FD->getTemplateSpecializationInfo()) {
+  if (FunctionTemplateSpecializationInfo *spec =
+          FD->getTemplateSpecializationInfo()) {
     TSK = spec->getTemplateSpecializationKind();
   } else if (MemberSpecializationInfo *MSI =
-             FD->getMemberSpecializationInfo()) {
+                 FD->getMemberSpecializationInfo()) {
     TSK = MSI->getTemplateSpecializationKind();
   }
 
-  const FunctionDecl *Def = nullptr;
+  FunctionDecl const *Def = nullptr;
   // InlineVisibilityHidden only applies to definitions, and
   // isInlined() only gives meaningful answers on definitions
   // anyway.
   return TSK != TSK_ExplicitInstantiationDeclaration &&
-    TSK != TSK_ExplicitInstantiationDefinition &&
-    FD->hasBody(Def) && Def->isInlined() && !Def->hasAttr<GNUInlineAttr>();
+         TSK != TSK_ExplicitInstantiationDefinition && FD->hasBody(Def) &&
+         Def->isInlined() && !Def->hasAttr<GNUInlineAttr>();
 }
 
 template <typename T> static bool isFirstInExternCContext(T *D) {
@@ -561,21 +560,21 @@
   return First->isInExternCContext();
 }
 
-static bool isSingleLineLanguageLinkage(const Decl &D) {
-  if (const auto *SD = dyn_cast<LinkageSpecDecl>(D.getDeclContext()))
+static bool isSingleLineLanguageLinkage(Decl const &D) {
+  if (auto const *SD = dyn_cast<LinkageSpecDecl>(D.getDeclContext()))
     if (!SD->hasBraces())
       return true;
   return false;
 }
 
 /// Determine whether D is declared in the purview of a named module.
-static bool isInModulePurview(const NamedDecl *D) {
+static bool isInModulePurview(NamedDecl const *D) {
   if (auto *M = D->getOwningModule())
     return M->isModulePurview();
   return false;
 }
 
-static bool isExportedFromModuleInterfaceUnit(const NamedDecl *D) {
+static bool isExportedFromModuleInterfaceUnit(NamedDecl const *D) {
   // FIXME: Handle isModulePrivate.
   switch (D->getModuleOwnershipKind()) {
   case Decl::ModuleOwnershipKind::Unowned:
@@ -588,7 +587,7 @@
   llvm_unreachable("unexpected module ownership kind");
 }
 
-static LinkageInfo getInternalLinkageFor(const NamedDecl *D) {
+static LinkageInfo getInternalLinkageFor(NamedDecl const *D) {
   // Internal linkage declarations within a module interface unit are modeled
   // as "module-internal linkage", which means that they have internal linkage
   // formally but can be indirectly accessed from outside the module via inline
@@ -599,7 +598,7 @@
   return LinkageInfo::internal();
 }
 
-static LinkageInfo getExternalLinkageFor(const NamedDecl *D) {
+static LinkageInfo getExternalLinkageFor(NamedDecl const *D) {
   // C++ Modules TS [basic.link]/6.8:
   //   - A name declared at namespace scope that does not have internal linkage
   //     by the previous rules and that is introduced by a non-exported
@@ -611,7 +610,7 @@
   return LinkageInfo::external();
 }
 
-static StorageClass getStorageClass(const Decl *D) {
+static StorageClass getStorageClass(Decl const *D) {
   if (auto *TD = dyn_cast<TemplateDecl>(D))
     D = TD->getTemplatedDecl();
   if (D) {
@@ -624,7 +623,7 @@
 }
 
 LinkageInfo
-LinkageComputer::getLVForNamespaceScopeDecl(const NamedDecl *D,
+LinkageComputer::getLVForNamespaceScopeDecl(NamedDecl const *D,
                                             LVComputationKind computation,
                                             bool IgnoreVarTypeLinkage) {
   assert(D->getDeclContext()->getRedeclContext()->isFileContext() &&
@@ -642,21 +641,19 @@
     return getInternalLinkageFor(D);
   }
 
-  if (const auto *Var = dyn_cast<VarDecl>(D)) {
+  if (auto const *Var = dyn_cast<VarDecl>(D)) {
     // - a non-template variable of non-volatile const-qualified type, unless
     //   - it is explicitly declared extern, or
     //   - it is inline or exported, or
     //   - it was previously declared and the prior declaration did not have
     //     internal linkage
     // (There is no equivalent in C99.)
-    if (Context.getLangOpts().CPlusPlus &&
-        Var->getType().isConstQualified() &&
-        !Var->getType().isVolatileQualified() &&
-        !Var->isInline() &&
+    if (Context.getLangOpts().CPlusPlus && Var->getType().isConstQualified() &&
+        !Var->getType().isVolatileQualified() && !Var->isInline() &&
         !isExportedFromModuleInterfaceUnit(Var) &&
         !isa<VarTemplateSpecializationDecl>(Var) &&
         !Var->getDescribedVarTemplate()) {
-      const VarDecl *PrevVar = Var->getPreviousDecl();
+      VarDecl const *PrevVar = Var->getPreviousDecl();
       if (PrevVar)
         return getLVForDecl(PrevVar, computation);
 
@@ -666,7 +663,7 @@
         return getInternalLinkageFor(Var);
     }
 
-    for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar;
+    for (VarDecl const *PrevVar = Var->getPreviousDecl(); PrevVar;
          PrevVar = PrevVar->getPreviousDecl()) {
       if (PrevVar->getStorageClass() == SC_PrivateExtern &&
           Var->getStorageClass() == SC_None)
@@ -675,9 +672,9 @@
       if (PrevVar->getStorageClass() == SC_Static)
         return getInternalLinkageFor(Var);
     }
-  } else if (const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
+  } else if (auto const *IFD = dyn_cast<IndirectFieldDecl>(D)) {
     //   - a data member of an anonymous union.
-    const VarDecl *VD = IFD->getVarDecl();
+    VarDecl const *VD = IFD->getVarDecl();
     assert(VD && "Expected a VarDecl in this IndirectFieldDecl!");
     return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
   }
@@ -686,8 +683,8 @@
   // FIXME: This gives internal linkage to names that should have no linkage
   // (those not covered by [basic.link]p6).
   if (D->isInAnonymousNamespace()) {
-    const auto *Var = dyn_cast<VarDecl>(D);
-    const auto *Func = dyn_cast<FunctionDecl>(D);
+    auto const *Var = dyn_cast<VarDecl>(D);
+    auto const *Func = dyn_cast<FunctionDecl>(D);
     // FIXME: The check for extern "C" here is not justified by the standard
     // wording, but we retain it from the pre-DR1113 model to avoid breaking
     // code.
@@ -714,11 +711,11 @@
     } else {
       // If we're declared in a namespace with a visibility attribute,
       // use that namespace's visibility, and it still counts as explicit.
-      for (const DeclContext *DC = D->getDeclContext();
-           !isa<TranslationUnitDecl>(DC);
-           DC = DC->getParent()) {
-        const auto *ND = dyn_cast<NamespaceDecl>(DC);
-        if (!ND) continue;
+      for (DeclContext const *DC = D->getDeclContext();
+           !isa<TranslationUnitDecl>(DC); DC = DC->getParent()) {
+        auto const *ND = dyn_cast<NamespaceDecl>(DC);
+        if (!ND)
+          continue;
         if (Optional<Visibility> Vis = getExplicitVisibility(ND, computation)) {
           LV.mergeVisibility(*Vis, true);
           break;
@@ -758,7 +755,7 @@
   //   The bullets are:
 
   //     - a variable; or
-  if (const auto *Var = dyn_cast<VarDecl>(D)) {
+  if (auto const *Var = dyn_cast<VarDecl>(D)) {
     // GCC applies the following optimization to variables and static
     // data members, but not to functions:
     //
@@ -799,12 +796,12 @@
     // As per function and class template specializations (below),
     // consider LV for the template and template arguments.  We're at file
     // scope, so we do not need to worry about nested specializations.
-    if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
+    if (auto const *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
       mergeTemplateLV(LV, spec, computation);
     }
 
-  //     - a function; or
-  } else if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
+    //     - a function; or
+  } else if (auto const *Function = dyn_cast<FunctionDecl>(D)) {
     // In theory, we can modify the function's LV by the LV of its
     // type unless it has C linkage (see comment above about variables
     // for justification).  In practice, GCC doesn't do this, so it's
@@ -834,18 +831,18 @@
     // Consider LV from the template and the template arguments.
     // We're at file scope, so we do not need to worry about nested
     // specializations.
-    if (FunctionTemplateSpecializationInfo *specInfo
-                               = Function->getTemplateSpecializationInfo()) {
+    if (FunctionTemplateSpecializationInfo *specInfo =
+            Function->getTemplateSpecializationInfo()) {
       mergeTemplateLV(LV, Function, specInfo, computation);
     }
 
-  //     - a named class (Clause 9), or an unnamed class defined in a
-  //       typedef declaration in which the class has the typedef name
-  //       for linkage purposes (7.1.3); or
-  //     - a named enumeration (7.2), or an unnamed enumeration
-  //       defined in a typedef declaration in which the enumeration
-  //       has the typedef name for linkage purposes (7.1.3); or
-  } else if (const auto *Tag = dyn_cast<TagDecl>(D)) {
+    //     - a named class (Clause 9), or an unnamed class defined in a
+    //       typedef declaration in which the class has the typedef name
+    //       for linkage purposes (7.1.3); or
+    //     - a named enumeration (7.2), or an unnamed enumeration
+    //       defined in a typedef declaration in which the enumeration
+    //       has the typedef name for linkage purposes (7.1.3); or
+  } else if (auto const *Tag = dyn_cast<TagDecl>(D)) {
     // Unnamed tags have no linkage.
     if (!Tag->hasNameForLinkage())
       return LinkageInfo::none();
@@ -853,50 +850,50 @@
     // If this is a class template specialization, consider the
     // linkage of the template and template arguments.  We're at file
     // scope, so we do not need to worry about nested specializations.
-    if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
+    if (auto const *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
       mergeTemplateLV(LV, spec, computation);
     }
 
-  // FIXME: This is not part of the C++ standard any more.
-  //     - an enumerator belonging to an enumeration with external linkage; or
+    // FIXME: This is not part of the C++ standard any more.
+    //     - an enumerator belonging to an enumeration with external linkage; or
   } else if (isa<EnumConstantDecl>(D)) {
-    LinkageInfo EnumLV = getLVForDecl(cast<NamedDecl>(D->getDeclContext()),
-                                      computation);
+    LinkageInfo EnumLV =
+        getLVForDecl(cast<NamedDecl>(D->getDeclContext()), computation);
     if (!isExternalFormalLinkage(EnumLV.getLinkage()))
       return LinkageInfo::none();
     LV.merge(EnumLV);
 
-  //     - a template
-  } else if (const auto *temp = dyn_cast<TemplateDecl>(D)) {
+    //     - a template
+  } else if (auto const *temp = dyn_cast<TemplateDecl>(D)) {
     bool considerVisibility = !hasExplicitVisibilityAlready(computation);
-    LinkageInfo tempLV =
-      getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
+    LinkageInfo tempLV = getLVForTemplateParameterList(
+        temp->getTemplateParameters(), computation);
     LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
 
-  //     An unnamed namespace or a namespace declared directly or indirectly
-  //     within an unnamed namespace has internal linkage. All other namespaces
-  //     have external linkage.
-  //
-  // We handled names in anonymous namespaces above.
+    //     An unnamed namespace or a namespace declared directly or indirectly
+    //     within an unnamed namespace has internal linkage. All other
+    //     namespaces have external linkage.
+    //
+    // We handled names in anonymous namespaces above.
   } else if (isa<NamespaceDecl>(D)) {
     return LV;
 
-  // By extension, we assign external linkage to Objective-C
-  // interfaces.
+    // By extension, we assign external linkage to Objective-C
+    // interfaces.
   } else if (isa<ObjCInterfaceDecl>(D)) {
     // fallout
 
   } else if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
     // A typedef declaration has linkage if it gives a type a name for
     // linkage purposes.
-    if (!TD->getAnonDeclWithTypedefName(/*AnyRedecl*/true))
+    if (!TD->getAnonDeclWithTypedefName(/*AnyRedecl*/ true))
       return LinkageInfo::none();
 
   } else if (isa<MSGuidDecl>(D)) {
     // A GUID behaves like an inline variable with external linkage. Fall
     // through.
 
-  // Everything not covered here has no linkage.
+    // Everything not covered here has no linkage.
   } else {
     return LinkageInfo::none();
   }
@@ -913,10 +910,9 @@
   return LV;
 }
 
-LinkageInfo
-LinkageComputer::getLVForClassMember(const NamedDecl *D,
-                                     LVComputationKind computation,
-                                     bool IgnoreVarTypeLinkage) {
+LinkageInfo LinkageComputer::getLVForClassMember(NamedDecl const *D,
+                                                 LVComputationKind computation,
+                                                 bool IgnoreVarTypeLinkage) {
   // Only certain class members have linkage.  Note that fields don't
   // really have linkage, but it's convenient to say they do for the
   // purposes of calculating linkage of pointer-to-data-member
@@ -927,12 +923,8 @@
   // linkage and visibility of a template specialization, we might hit
   // a template template argument that way. If we do, we need to
   // consider its linkage.
-  if (!(isa<CXXMethodDecl>(D) ||
-        isa<VarDecl>(D) ||
-        isa<FieldDecl>(D) ||
-        isa<IndirectFieldDecl>(D) ||
-        isa<TagDecl>(D) ||
-        isa<TemplateDecl>(D)))
+  if (!(isa<CXXMethodDecl>(D) || isa<VarDecl>(D) || isa<FieldDecl>(D) ||
+        isa<IndirectFieldDecl>(D) || isa<TagDecl>(D) || isa<TemplateDecl>(D)))
     return LinkageInfo::none();
 
   LinkageInfo LV;
@@ -958,21 +950,20 @@
     classComputation = withExplicitVisibilityAlready(computation);
 
   LinkageInfo classLV =
-    getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation);
+      getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation);
   // The member has the same linkage as the class. If that's not externally
   // visible, we don't need to compute anything about the linkage.
   // FIXME: If we're only computing linkage, can we bail out here?
   if (!isExternallyVisible(classLV.getLinkage()))
     return classLV;
 
-
   // Otherwise, don't merge in classLV yet, because in certain cases
   // we need to completely ignore the visibility from it.
 
   // Specifically, if this decl exists and has an explicit attribute.
-  const NamedDecl *explicitSpecSuppressor = nullptr;
+  NamedDecl const *explicitSpecSuppressor = nullptr;
 
-  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
+  if (auto const *MD = dyn_cast<CXXMethodDecl>(D)) {
     // Only look at the type-as-written. Otherwise, deducing the return type
     // of a function could change its linkage.
     QualType TypeAsWritten = MD->getType();
@@ -983,8 +974,8 @@
 
     // If this is a method template specialization, use the linkage for
     // the template parameters and arguments.
-    if (FunctionTemplateSpecializationInfo *spec
-           = MD->getTemplateSpecializationInfo()) {
+    if (FunctionTemplateSpecializationInfo *spec =
+            MD->getTemplateSpecializationInfo()) {
       mergeTemplateLV(LV, MD, spec, computation);
       if (spec->isExplicitSpecialization()) {
         explicitSpecSuppressor = MD;
@@ -995,13 +986,13 @@
       explicitSpecSuppressor = MD;
     }
 
-  } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
-    if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
+  } else if (auto const *RD = dyn_cast<CXXRecordDecl>(D)) {
+    if (auto const *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
       mergeTemplateLV(LV, spec, computation);
       if (spec->isExplicitSpecialization()) {
         explicitSpecSuppressor = spec;
       } else {
-        const ClassTemplateDecl *temp = spec->getSpecializedTemplate();
+        ClassTemplateDecl const *temp = spec->getSpecializedTemplate();
         if (isExplicitMemberSpecialization(temp)) {
           explicitSpecSuppressor = temp->getTemplatedDecl();
         }
@@ -1010,9 +1001,9 @@
       explicitSpecSuppressor = RD;
     }
 
-  // Static data members.
-  } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
-    if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
+    // Static data members.
+  } else if (auto const *VD = dyn_cast<VarDecl>(D)) {
+    if (auto const *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
       mergeTemplateLV(LV, spec, computation);
 
     // Modify the variable's linkage by its type, but ignore the
@@ -1030,17 +1021,16 @@
       explicitSpecSuppressor = VD;
     }
 
-  // Template members.
-  } else if (const auto *temp = dyn_cast<TemplateDecl>(D)) {
+    // Template members.
+  } else if (auto const *temp = dyn_cast<TemplateDecl>(D)) {
     bool considerVisibility =
-      (!LV.isVisibilityExplicit() &&
-       !classLV.isVisibilityExplicit() &&
-       !hasExplicitVisibilityAlready(computation));
-    LinkageInfo tempLV =
-      getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
+        (!LV.isVisibilityExplicit() && !classLV.isVisibilityExplicit() &&
+         !hasExplicitVisibilityAlready(computation));
+    LinkageInfo tempLV = getLVForTemplateParameterList(
+        temp->getTemplateParameters(), computation);
     LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
 
-    if (const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
+    if (auto const *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
       if (isExplicitMemberSpecialization(redeclTemp)) {
         explicitSpecSuppressor = temp->getTemplatedDecl();
       }
@@ -1079,8 +1069,8 @@
 }
 
 ReservedIdentifierStatus
-NamedDecl::isReserved(const LangOptions &LangOpts) const {
-  const IdentifierInfo *II = getIdentifier();
+NamedDecl::isReserved(LangOptions const &LangOpts) const {
+  IdentifierInfo const *II = getIdentifier();
 
   // This triggers at least for CXXLiteralIdentifiers, which we already checked
   // at lexing time.
@@ -1092,7 +1082,7 @@
     // Check if we're at TU level or not.
     if (isa<ParmVarDecl>(this) || isTemplateParameter())
       return ReservedIdentifierStatus::NotReserved;
-    const DeclContext *DC = getDeclContext()->getRedeclContext();
+    DeclContext const *DC = getDeclContext()->getRedeclContext();
     if (!DC->isTranslationUnit())
       return ReservedIdentifierStatus::NotReserved;
   }
@@ -1102,7 +1092,8 @@
 
 ObjCStringFormatFamily NamedDecl::getObjCFStringFormattingFamily() const {
   StringRef name = getName();
-  if (name.empty()) return SFF_None;
+  if (name.empty())
+    return SFF_None;
 
   if (name.front() == 'C')
     if (name == "CFStringCreateWithFormat" ||
@@ -1126,7 +1117,7 @@
 }
 
 static Optional<Visibility>
-getExplicitVisibilityAux(const NamedDecl *ND,
+getExplicitVisibilityAux(NamedDecl const *ND,
                          NamedDecl::ExplicitVisibilityKind kind,
                          bool IsMostRecent) {
   assert(!IsMostRecent || ND == ND->getMostRecentDecl());
@@ -1137,7 +1128,7 @@
 
   // If this is a member class of a specialization of a class template
   // and the corresponding decl has explicit visibility, use that.
-  if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
+  if (auto const *RD = dyn_cast<CXXRecordDecl>(ND)) {
     CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass();
     if (InstantiatedFrom)
       return getVisibilityOf(InstantiatedFrom, kind);
@@ -1146,10 +1137,10 @@
   // If there wasn't explicit visibility there, and this is a
   // specialization of a class template, check for visibility
   // on the pattern.
-  if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
+  if (auto const *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
     // Walk all the template decl till this point to see if there are
     // explicit visibility attributes.
-    const auto *TD = spec->getSpecializedTemplate()->getTemplatedDecl();
+    auto const *TD = spec->getSpecializedTemplate()->getTemplatedDecl();
     while (TD != nullptr) {
       auto Vis = getVisibilityOf(TD, kind);
       if (Vis != None)
@@ -1161,30 +1152,30 @@
 
   // Use the most recent declaration.
   if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
-    const NamedDecl *MostRecent = ND->getMostRecentDecl();
+    NamedDecl const *MostRecent = ND->getMostRecentDecl();
     if (MostRecent != ND)
       return getExplicitVisibilityAux(MostRecent, kind, true);
   }
 
-  if (const auto *Var = dyn_cast<VarDecl>(ND)) {
+  if (auto const *Var = dyn_cast<VarDecl>(ND)) {
     if (Var->isStaticDataMember()) {
       VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember();
       if (InstantiatedFrom)
         return getVisibilityOf(InstantiatedFrom, kind);
     }
 
-    if (const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
+    if (auto const *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
       return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
                              kind);
 
     return None;
   }
   // Also handle function template specializations.
-  if (const auto *fn = dyn_cast<FunctionDecl>(ND)) {
+  if (auto const *fn = dyn_cast<FunctionDecl>(ND)) {
     // If the function is a specialization of a template with an
     // explicit visibility attribute, use that.
-    if (FunctionTemplateSpecializationInfo *templateInfo
-          = fn->getTemplateSpecializationInfo())
+    if (FunctionTemplateSpecializationInfo *templateInfo =
+            fn->getTemplateSpecializationInfo())
       return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
                              kind);
 
@@ -1198,7 +1189,7 @@
   }
 
   // The visibility of a template is stored in the templated decl.
-  if (const auto *TD = dyn_cast<TemplateDecl>(ND))
+  if (auto const *TD = dyn_cast<TemplateDecl>(ND))
     return getVisibilityOf(TD->getTemplatedDecl(), kind);
 
   return None;
@@ -1209,11 +1200,11 @@
   return getExplicitVisibilityAux(this, kind, false);
 }
 
-LinkageInfo LinkageComputer::getLVForClosure(const DeclContext *DC,
+LinkageInfo LinkageComputer::getLVForClosure(DeclContext const *DC,
                                              Decl *ContextDecl,
                                              LVComputationKind computation) {
   // This lambda has its linkage/visibility determined by its owner.
-  const NamedDecl *Owner;
+  NamedDecl const *Owner;
   if (!ContextDecl)
     Owner = dyn_cast<NamedDecl>(DC);
   else if (isa<ParmVarDecl>(ContextDecl))
@@ -1232,7 +1223,7 @@
   auto *VD = dyn_cast<VarDecl>(Owner);
   LinkageInfo OwnerLV =
       VD && VD->getType()->getContainedDeducedType()
-          ? computeLVForDecl(Owner, computation, /*IgnoreVarTypeLinkage*/true)
+          ? computeLVForDecl(Owner, computation, /*IgnoreVarTypeLinkage*/ true)
           : getLVForDecl(Owner, computation);
 
   // A lambda never formally has linkage. But if the owner is externally
@@ -1243,9 +1234,9 @@
                      OwnerLV.isVisibilityExplicit());
 }
 
-LinkageInfo LinkageComputer::getLVForLocalDecl(const NamedDecl *D,
+LinkageInfo LinkageComputer::getLVForLocalDecl(NamedDecl const *D,
                                                LVComputationKind computation) {
-  if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
+  if (auto const *Function = dyn_cast<FunctionDecl>(D)) {
     if (Function->isInAnonymousNamespace() &&
         !isFirstInExternCContext(Function))
       return getInternalLinkageFor(Function);
@@ -1268,7 +1259,7 @@
     return LV;
   }
 
-  if (const auto *Var = dyn_cast<VarDecl>(D)) {
+  if (auto const *Var = dyn_cast<VarDecl>(D)) {
     if (Var->hasExternalStorage()) {
       if (Var->isInAnonymousNamespace() && !isFirstInExternCContext(Var))
         return getInternalLinkageFor(Var);
@@ -1281,7 +1272,7 @@
           LV.mergeVisibility(*Vis, true);
       }
 
-      if (const VarDecl *Prev = Var->getPreviousDecl()) {
+      if (VarDecl const *Prev = Var->getPreviousDecl()) {
         LinkageInfo PrevLV = getLVForDecl(Prev, computation);
         if (PrevLV.getLinkage())
           LV.setLinkage(PrevLV.getLinkage());
@@ -1299,19 +1290,19 @@
   if (!Context.getLangOpts().CPlusPlus)
     return LinkageInfo::none();
 
-  const Decl *OuterD = getOutermostFuncOrBlockContext(D);
+  Decl const *OuterD = getOutermostFuncOrBlockContext(D);
   if (!OuterD || OuterD->isInvalidDecl())
     return LinkageInfo::none();
 
   LinkageInfo LV;
-  if (const auto *BD = dyn_cast<BlockDecl>(OuterD)) {
+  if (auto const *BD = dyn_cast<BlockDecl>(OuterD)) {
     if (!BD->getBlockManglingNumber())
       return LinkageInfo::none();
 
     LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
                          BD->getBlockManglingContextDecl(), computation);
   } else {
-    const auto *FD = cast<FunctionDecl>(OuterD);
+    auto const *FD = cast<FunctionDecl>(OuterD);
     if (!FD->isInlined() &&
         !isTemplateInstantiation(FD->getTemplateSpecializationKind()))
       return LinkageInfo::none();
@@ -1327,7 +1318,7 @@
       // If this was an implicitly hidden inline method, check again for
       // explicit visibility on the parent class, and use that for static locals
       // if present.
-      if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
+      if (auto const *MD = dyn_cast<CXXMethodDecl>(FD))
         LV = getLVForDecl(MD->getParent(), computation);
       if (!LV.isVisibilityExplicit()) {
         Visibility globalVisibility =
@@ -1345,7 +1336,7 @@
                      LV.isVisibilityExplicit());
 }
 
-LinkageInfo LinkageComputer::computeLVForDecl(const NamedDecl *D,
+LinkageInfo LinkageComputer::computeLVForDecl(NamedDecl const *D,
                                               LVComputationKind computation,
                                               bool IgnoreVarTypeLinkage) {
   // Internal_linkage attribute overrides other considerations.
@@ -1355,78 +1346,77 @@
   // Objective-C: treat all Objective-C declarations as having external
   // linkage.
   switch (D->getKind()) {
-    default:
-      break;
+  default:
+    break;
 
-    // Per C++ [basic.link]p2, only the names of objects, references,
-    // functions, types, templates, namespaces, and values ever have linkage.
-    //
-    // Note that the name of a typedef, namespace alias, using declaration,
-    // and so on are not the name of the corresponding type, namespace, or
-    // declaration, so they do *not* have linkage.
-    case Decl::ImplicitParam:
-    case Decl::Label:
-    case Decl::NamespaceAlias:
-    case Decl::ParmVar:
-    case Decl::Using:
-    case Decl::UsingEnum:
-    case Decl::UsingShadow:
-    case Decl::UsingDirective:
-      return LinkageInfo::none();
+  // Per C++ [basic.link]p2, only the names of objects, references,
+  // functions, types, templates, namespaces, and values ever have linkage.
+  //
+  // Note that the name of a typedef, namespace alias, using declaration,
+  // and so on are not the name of the corresponding type, namespace, or
+  // declaration, so they do *not* have linkage.
+  case Decl::ImplicitParam:
+  case Decl::Label:
+  case Decl::NamespaceAlias:
+  case Decl::ParmVar:
+  case Decl::Using:
+  case Decl::UsingEnum:
+  case Decl::UsingShadow:
+  case Decl::UsingDirective:
+    return LinkageInfo::none();
 
-    case Decl::EnumConstant:
-      // C++ [basic.link]p4: an enumerator has the linkage of its enumeration.
-      if (D->getASTContext().getLangOpts().CPlusPlus)
-        return getLVForDecl(cast<EnumDecl>(D->getDeclContext()), computation);
-      return LinkageInfo::visible_none();
-
-    case Decl::Typedef:
-    case Decl::TypeAlias:
-      // A typedef declaration has linkage if it gives a type a name for
-      // linkage purposes.
-      if (!cast<TypedefNameDecl>(D)
-               ->getAnonDeclWithTypedefName(/*AnyRedecl*/true))
-        return LinkageInfo::none();
-      break;
+  case Decl::EnumConstant:
+    // C++ [basic.link]p4: an enumerator has the linkage of its enumeration.
+    if (D->getASTContext().getLangOpts().CPlusPlus)
+      return getLVForDecl(cast<EnumDecl>(D->getDeclContext()), computation);
+    return LinkageInfo::visible_none();
 
-    case Decl::TemplateTemplateParm: // count these as external
-    case Decl::NonTypeTemplateParm:
-    case Decl::ObjCAtDefsField:
-    case Decl::ObjCCategory:
-    case Decl::ObjCCategoryImpl:
-    case Decl::ObjCCompatibleAlias:
-    case Decl::ObjCImplementation:
-    case Decl::ObjCMethod:
-    case Decl::ObjCProperty:
-    case Decl::ObjCPropertyImpl:
-    case Decl::ObjCProtocol:
-      return getExternalLinkageFor(D);
-
-    case Decl::CXXRecord: {
-      const auto *Record = cast<CXXRecordDecl>(D);
-      if (Record->isLambda()) {
-        if (Record->hasKnownLambdaInternalLinkage() ||
-            !Record->getLambdaManglingNumber()) {
-          // This lambda has no mangling number, so it's internal.
-          return getInternalLinkageFor(D);
-        }
+  case Decl::Typedef:
+  case Decl::TypeAlias:
+    // A typedef declaration has linkage if it gives a type a name for
+    // linkage purposes.
+    if (!cast<TypedefNameDecl>(D)->getAnonDeclWithTypedefName(
+            /*AnyRedecl*/ true))
+      return LinkageInfo::none();
+    break;
 
-        return getLVForClosure(
-                  Record->getDeclContext()->getRedeclContext(),
-                  Record->getLambdaContextDecl(), computation);
+  case Decl::TemplateTemplateParm: // count these as external
+  case Decl::NonTypeTemplateParm:
+  case Decl::ObjCAtDefsField:
+  case Decl::ObjCCategory:
+  case Decl::ObjCCategoryImpl:
+  case Decl::ObjCCompatibleAlias:
+  case Decl::ObjCImplementation:
+  case Decl::ObjCMethod:
+  case Decl::ObjCProperty:
+  case Decl::ObjCPropertyImpl:
+  case Decl::ObjCProtocol:
+    return getExternalLinkageFor(D);
+
+  case Decl::CXXRecord: {
+    auto const *Record = cast<CXXRecordDecl>(D);
+    if (Record->isLambda()) {
+      if (Record->hasKnownLambdaInternalLinkage() ||
+          !Record->getLambdaManglingNumber()) {
+        // This lambda has no mangling number, so it's internal.
+        return getInternalLinkageFor(D);
       }
 
-      break;
+      return getLVForClosure(Record->getDeclContext()->getRedeclContext(),
+                             Record->getLambdaContextDecl(), computation);
     }
 
-    case Decl::TemplateParamObject: {
-      // The template parameter object can be referenced from anywhere its type
-      // and value can be referenced.
-      auto *TPO = cast<TemplateParamObjectDecl>(D);
-      LinkageInfo LV = getLVForType(*TPO->getType(), computation);
-      LV.merge(getLVForValue(TPO->getValue(), computation));
-      return LV;
-    }
+    break;
+  }
+
+  case Decl::TemplateParamObject: {
+    // The template parameter object can be referenced from anywhere its type
+    // and value can be referenced.
+    auto *TPO = cast<TemplateParamObjectDecl>(D);
+    LinkageInfo LV = getLVForType(*TPO->getType(), computation);
+    LV.merge(getLVForValue(TPO->getValue(), computation));
+    return LV;
+  }
   }
 
   // Handle linkage for namespace-scope names.
@@ -1463,7 +1453,7 @@
 }
 
 /// getLVForDecl - Get the linkage and visibility for the given declaration.
-LinkageInfo LinkageComputer::getLVForDecl(const NamedDecl *D,
+LinkageInfo LinkageComputer::getLVForDecl(NamedDecl const *D,
                                           LVComputationKind computation) {
   // Internal_linkage attribute overrides other considerations.
   if (D->hasAttr<InternalLinkageAttr>())
@@ -1486,7 +1476,7 @@
   // In C (because of gnu inline) and in c++ with microsoft extensions an
   // static can follow an extern, so we can have two decls with different
   // linkages.
-  const LangOptions &Opts = D->getASTContext().getLangOpts();
+  LangOptions const &Opts = D->getASTContext().getLangOpts();
   if (!Opts.CPlusPlus || Opts.MicrosoftExt)
     return LV;
 
@@ -1509,7 +1499,7 @@
   return LV;
 }
 
-LinkageInfo LinkageComputer::getDeclLinkageAndVisibility(const NamedDecl *D) {
+LinkageInfo LinkageComputer::getDeclLinkageAndVisibility(NamedDecl const *D) {
   NamedDecl::ExplicitVisibilityKind EK = usesTypeVisibility(D)
                                              ? NamedDecl::VisibilityForType
                                              : NamedDecl::VisibilityForValue;
@@ -1544,8 +1534,8 @@
       InternalLinkage = !ND->hasExternalFormalLinkage();
     else {
       auto *NSD = dyn_cast<NamespaceDecl>(this);
-      InternalLinkage = (NSD && NSD->isAnonymousNamespace()) ||
-                        isInAnonymousNamespace();
+      InternalLinkage =
+          (NSD && NSD->isAnonymousNamespace()) || isInAnonymousNamespace();
     }
     return InternalLinkage ? M->Parent : nullptr;
   }
@@ -1559,9 +1549,7 @@
   llvm_unreachable("unknown module kind");
 }
 
-void NamedDecl::printName(raw_ostream &os) const {
-  os << Name;
-}
+void NamedDecl::printName(raw_ostream &os) const { os << Name; }
 
 std::string NamedDecl::getQualifiedNameAsString() const {
   std::string QualName;
@@ -1575,7 +1563,7 @@
 }
 
 void NamedDecl::printQualifiedName(raw_ostream &OS,
-                                   const PrintingPolicy &P) const {
+                                   PrintingPolicy const &P) const {
   if (getDeclContext()->isFunctionOrMethod()) {
     // We do not print '(anonymous)' for function parameters without name.
     printName(OS);
@@ -1602,8 +1590,8 @@
 }
 
 void NamedDecl::printNestedNameSpecifier(raw_ostream &OS,
-                                         const PrintingPolicy &P) const {
-  const DeclContext *Ctx = getDeclContext();
+                                         PrintingPolicy const &P) const {
+  DeclContext const *Ctx = getDeclContext();
 
   // For ObjC methods and properties, look through categories and use the
   // interface as context.
@@ -1622,7 +1610,7 @@
   if (Ctx->isFunctionOrMethod())
     return;
 
-  using ContextsTy = SmallVector<const DeclContext *, 8>;
+  using ContextsTy = SmallVector<DeclContext const *, 8>;
   ContextsTy Contexts;
 
   // Collect named contexts.
@@ -1639,7 +1627,7 @@
       continue;
 
     // Skip non-named contexts such as linkage specifications and ExportDecls.
-    const NamedDecl *ND = dyn_cast<NamedDecl>(Ctx);
+    NamedDecl const *ND = dyn_cast<NamedDecl>(Ctx);
     if (!ND)
       continue;
 
@@ -1648,27 +1636,26 @@
   }
 
   for (unsigned I = Contexts.size(); I != 0; --I) {
-    const DeclContext *DC = Contexts[I - 1];
-    if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
+    DeclContext const *DC = Contexts[I - 1];
+    if (auto const *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
       OS << Spec->getName();
-      const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
+      TemplateArgumentList const &TemplateArgs = Spec->getTemplateArgs();
       printTemplateArgumentList(
           OS, TemplateArgs.asArray(), P,
           Spec->getSpecializedTemplate()->getTemplateParameters());
-    } else if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
+    } else if (auto const *ND = dyn_cast<NamespaceDecl>(DC)) {
       if (ND->isAnonymousNamespace()) {
         OS << (P.MSVCFormatting ? "`anonymous namespace\'"
                                 : "(anonymous namespace)");
-      }
-      else
+      } else
         OS << *ND;
-    } else if (const auto *RD = dyn_cast<RecordDecl>(DC)) {
+    } else if (auto const *RD = dyn_cast<RecordDecl>(DC)) {
       if (!RD->getIdentifier())
         OS << "(anonymous " << RD->getKindName() << ')';
       else
         OS << *RD;
-    } else if (const auto *FD = dyn_cast<FunctionDecl>(DC)) {
-      const FunctionProtoType *FT = nullptr;
+    } else if (auto const *FD = dyn_cast<FunctionDecl>(DC)) {
+      FunctionProtoType const *FT = nullptr;
       if (FD->hasWrittenPrototype())
         FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>());
 
@@ -1688,7 +1675,7 @@
         }
       }
       OS << ')';
-    } else if (const auto *ED = dyn_cast<EnumDecl>(DC)) {
+    } else if (auto const *ED = dyn_cast<EnumDecl>(DC)) {
       // C++ [dcl.enum]p10: Each enum-name and each unscoped
       // enumerator is declared in the scope that immediately contains
       // the enum-specifier. Each scoped enumerator is declared in the
@@ -1708,7 +1695,7 @@
 }
 
 void NamedDecl::getNameForDiagnostic(raw_ostream &OS,
-                                     const PrintingPolicy &Policy,
+                                     PrintingPolicy const &Policy,
                                      bool Qualified) const {
   if (Qualified)
     printQualifiedName(OS, Policy);
@@ -1716,14 +1703,14 @@
     printName(OS);
 }
 
-template<typename T> static bool isRedeclarableImpl(Redeclarable<T> *) {
+template <typename T> static bool isRedeclarableImpl(Redeclarable<T> *) {
   return true;
 }
 static bool isRedeclarableImpl(...) { return false; }
 static bool isRedeclarable(Decl::Kind K) {
   switch (K) {
-#define DECL(Type, Base) \
-  case Decl::Type: \
+#define DECL(Type, Base)                                                       \
+  case Decl::Type:                                                             \
     return isRedeclarableImpl((Type##Decl *)nullptr);
 #define ABSTRACT_DECL(DECL)
 #include "clang/AST/DeclNodes.inc"
@@ -1771,7 +1758,7 @@
     ASTContext &Context = getASTContext();
     return Context.getCanonicalNestedNameSpecifier(UUVD->getQualifier()) ==
            Context.getCanonicalNestedNameSpecifier(
-                        cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
+               cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
   }
 
   if (isRedeclarable(getKind())) {
@@ -1807,9 +1794,7 @@
   return false;
 }
 
-bool NamedDecl::hasLinkage() const {
-  return getFormalLinkage() != NoLinkage;
-}
+bool NamedDecl::hasLinkage() const { return getFormalLinkage() != NoLinkage; }
 
 NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
   NamedDecl *ND = this;
@@ -1829,13 +1814,13 @@
   if (!isCXXClassMember())
     return false;
 
-  const NamedDecl *D = this;
+  NamedDecl const *D = this;
   if (isa<UsingShadowDecl>(D))
     D = cast<UsingShadowDecl>(D)->getTargetDecl();
 
   if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
     return true;
-  if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()))
+  if (auto const *MD = dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()))
     return MD->isInstance();
   return false;
 }
@@ -1845,7 +1830,7 @@
 //===----------------------------------------------------------------------===//
 
 template <typename DeclT>
-static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl) {
+static SourceLocation getTemplateOrInnerLocStart(DeclT const *decl) {
   if (decl->getNumTemplateParameterLists() > 0)
     return decl->getTemplateParameterList(0)->getTemplateLoc();
   return decl->getInnerLocStart();
@@ -1853,13 +1838,15 @@
 
 SourceLocation DeclaratorDecl::getTypeSpecStartLoc() const {
   TypeSourceInfo *TSI = getTypeSourceInfo();
-  if (TSI) return TSI->getTypeLoc().getBeginLoc();
+  if (TSI)
+    return TSI->getTypeLoc().getBeginLoc();
   return SourceLocation();
 }
 
 SourceLocation DeclaratorDecl::getTypeSpecEndLoc() const {
   TypeSourceInfo *TSI = getTypeSourceInfo();
-  if (TSI) return TSI->getTypeLoc().getEndLoc();
+  if (TSI)
+    return TSI->getTypeLoc().getEndLoc();
   return SourceLocation();
 }
 
@@ -1868,7 +1855,7 @@
     // Make sure the extended decl info is allocated.
     if (!hasExtInfo()) {
       // Save (non-extended) type source info pointer.
-      auto *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
+      auto *savedTInfo = DeclInfo.get<TypeSourceInfo *>();
       // Allocate external info struct.
       DeclInfo = new (getASTContext()) ExtInfo;
       // Restore savedTInfo into (extended) decl info.
@@ -1887,7 +1874,7 @@
   // Make sure the extended decl info is allocated.
   if (!hasExtInfo()) {
     // Save (non-extended) type source info pointer.
-    auto *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
+    auto *savedTInfo = DeclInfo.get<TypeSourceInfo *>();
     // Allocate external info struct.
     DeclInfo = new (getASTContext()) ExtInfo;
     // Restore savedTInfo into (extended) decl info.
@@ -1903,7 +1890,7 @@
   // Make sure the extended decl info is allocated.
   if (!hasExtInfo()) {
     // Save (non-extended) type source info pointer.
-    auto *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
+    auto *savedTInfo = DeclInfo.get<TypeSourceInfo *>();
     // Allocate external info struct.
     DeclInfo = new (getASTContext()) ExtInfo;
     // Restore savedTInfo into (extended) decl info.
@@ -1921,7 +1908,7 @@
 // having a postfix component.
 static bool typeIsPostfix(QualType QT) {
   while (true) {
-    const Type* T = QT.getTypePtr();
+    Type const *T = QT.getTypePtr();
     switch (T->getTypeClass()) {
     default:
       return false;
@@ -1984,14 +1971,20 @@
 // VarDecl Implementation
 //===----------------------------------------------------------------------===//
 
-const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) {
+char const *VarDecl::getStorageClassSpecifierString(StorageClass SC) {
   switch (SC) {
-  case SC_None:                 break;
-  case SC_Auto:                 return "auto";
-  case SC_Extern:               return "extern";
-  case SC_PrivateExtern:        return "__private_extern__";
-  case SC_Register:             return "register";
-  case SC_Static:               return "static";
+  case SC_None:
+    break;
+  case SC_Auto:
+    return "auto";
+  case SC_Extern:
+    return "extern";
+  case SC_PrivateExtern:
+    return "__private_extern__";
+  case SC_Register:
+    return "register";
+  case SC_Static:
+    return "static";
   }
 
   llvm_unreachable("Invalid storage class");
@@ -2014,10 +2007,9 @@
   // Everything else is implicitly initialized to false.
 }
 
-VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC,
-                         SourceLocation StartL, SourceLocation IdL,
-                         IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
-                         StorageClass S) {
+VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation StartL,
+                         SourceLocation IdL, IdentifierInfo *Id, QualType T,
+                         TypeSourceInfo *TInfo, StorageClass S) {
   return new (C, DC) VarDecl(Var, C, DC, StartL, IdL, Id, T, TInfo, S);
 }
 
@@ -2055,7 +2047,7 @@
 }
 
 SourceRange VarDecl::getSourceRange() const {
-  if (const Expr *Init = getInit()) {
+  if (Expr const *Init = getInit()) {
     SourceLocation InitEnd = Init->getEndLoc();
     // If Init is implicit, ignore its source range and fallback on
     // DeclaratorDecl::getSourceRange() to handle postfix elements.
@@ -2065,7 +2057,7 @@
   return DeclaratorDecl::getSourceRange();
 }
 
-template<typename T>
+template <typename T>
 static LanguageLinkage getDeclLanguageLinkage(const T &D) {
   // C++ [dcl.link]p1: All function types, function names with external linkage,
   // and variable names with external linkage have a language linkage.
@@ -2081,7 +2073,7 @@
   // C++ [dcl.link]p4: A C language linkage is ignored in determining the
   // language linkage of the names of class members and the function type of
   // class member functions.
-  const DeclContext *DC = D.getDeclContext();
+  DeclContext const *DC = D.getDeclContext();
   if (DC->isRecord())
     return CXXLanguageLinkage;
 
@@ -2093,11 +2085,10 @@
   return CXXLanguageLinkage;
 }
 
-template<typename T>
-static bool isDeclExternC(const T &D) {
+template <typename T> static bool isDeclExternC(const T &D) {
   // Since the context is ignored for class members, they can only have C++
   // language linkage or no language linkage.
-  const DeclContext *DC = D.getDeclContext();
+  DeclContext const *DC = D.getDeclContext();
   if (DC->isRecord()) {
     assert(D.getASTContext().getLangOpts().CPlusPlus);
     return false;
@@ -2110,9 +2101,7 @@
   return getDeclLanguageLinkage(*this);
 }
 
-bool VarDecl::isExternC() const {
-  return isDeclExternC(*this);
-}
+bool VarDecl::isExternC() const { return isDeclExternC(*this); }
 
 bool VarDecl::isInExternCContext() const {
   return getLexicalDeclContext()->isExternCContext();
@@ -2133,8 +2122,8 @@
   //   A declaration is a definition unless [...] it contains the 'extern'
   //   specifier or a linkage-specification and neither an initializer [...],
   //   it declares a non-inline static data member in a class declaration [...],
-  //   it declares a static data member outside a class definition and the variable
-  //   was defined within the class with the constexpr specifier [...],
+  //   it declares a static data member outside a class definition and the
+  //   variable was defined within the class with the constexpr specifier [...],
   // C++1y [temp.expl.spec]p15:
   //   An explicit specialization of a static data member or an explicit
   //   specialization of a static data member template is a definition if the
@@ -2173,7 +2162,7 @@
   if (hasDefiningAttr())
     return Definition;
 
-  if (const auto *SAA = getAttr<SelectAnyAttr>())
+  if (auto const *SAA = getAttr<SelectAnyAttr>())
     if (!SAA->isInherited())
       return Definition;
 
@@ -2243,7 +2232,7 @@
 VarDecl::DefinitionKind VarDecl::hasDefinition(ASTContext &C) const {
   DefinitionKind Kind = DeclarationOnly;
 
-  const VarDecl *First = getFirstDecl();
+  VarDecl const *First = getFirstDecl();
   for (auto I : First->redecls()) {
     Kind = std::max(Kind, I->isThisDeclarationADefinition(C));
     if (Kind == Definition)
@@ -2253,7 +2242,7 @@
   return Kind;
 }
 
-const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const {
+Expr const *VarDecl::getAnyInitializer(VarDecl const *&D) const {
   for (auto I : redecls()) {
     if (auto Expr = I->getInit()) {
       D = I;
@@ -2328,8 +2317,8 @@
   Init = I;
 }
 
-bool VarDecl::mightBeUsableInConstantExpressions(const ASTContext &C) const {
-  const LangOptions &Lang = C.getLangOpts();
+bool VarDecl::mightBeUsableInConstantExpressions(ASTContext const &C) const {
+  LangOptions const &Lang = C.getLangOpts();
 
   // OpenCL permits const integral variables to be used in constant
   // expressions, like in C++98.
@@ -2365,12 +2354,12 @@
   return Lang.CPlusPlus11 && isConstexpr();
 }
 
-bool VarDecl::isUsableInConstantExpressions(const ASTContext &Context) const {
+bool VarDecl::isUsableInConstantExpressions(ASTContext const &Context) const {
   // C++2a [expr.const]p3:
   //   A variable is usable in constant expressions after its initializing
   //   declaration is encountered...
-  const VarDecl *DefVD = nullptr;
-  const Expr *Init = getAnyInitializer(DefVD);
+  VarDecl const *DefVD = nullptr;
+  Expr const *Init = getAnyInitializer(DefVD);
   if (!Init || Init->isValueDependent() || getType()->isDependentType())
     return false;
   //   ... if it is a constexpr variable, or it is of reference type or of
@@ -2420,7 +2409,7 @@
                                     bool IsConstantInitialization) const {
   EvaluatedStmt *Eval = ensureEvaluatedStmt();
 
-  const auto *Init = cast<Expr>(Eval->Value);
+  auto const *Init = cast<Expr>(Eval->Value);
   assert(!Init->isValueDependent());
 
   // We only produce notes indicating why an initializer is non-constant the
@@ -2469,8 +2458,8 @@
   return nullptr;
 }
 
-bool VarDecl::hasICEInitializer(const ASTContext &Context) const {
-  const Expr *Init = getInit();
+bool VarDecl::hasICEInitializer(ASTContext const &Context) const {
+  Expr const *Init = getInit();
   assert(Init && "no initializer");
 
   EvaluatedStmt *Eval = ensureEvaluatedStmt();
@@ -2522,8 +2511,7 @@
   return isa<PackExpansionType>(getType());
 }
 
-template<typename DeclT>
-static DeclT *getDefinitionOrSelf(DeclT *D) {
+template <typename DeclT> static DeclT *getDefinitionOrSelf(DeclT *D) {
   assert(D);
   if (auto *Def = D->getDefinition())
     return Def;
@@ -2541,13 +2529,13 @@
 bool VarDecl::hasDependentAlignment() const {
   QualType T = getType();
   return T->isDependentType() || T->isUndeducedAutoType() ||
-         llvm::any_of(specific_attrs<AlignedAttr>(), [](const AlignedAttr *AA) {
+         llvm::any_of(specific_attrs<AlignedAttr>(), [](AlignedAttr const *AA) {
            return AA->isAlignmentDependent();
          });
 }
 
 VarDecl *VarDecl::getTemplateInstantiationPattern() const {
-  const VarDecl *VD = this;
+  VarDecl const *VD = this;
 
   // If this is an instantiated member, walk back to the template from which
   // it was instantiated.
@@ -2601,7 +2589,7 @@
 
   if (VD == this)
     return nullptr;
-  return getDefinitionOrSelf(const_cast<VarDecl*>(VD));
+  return getDefinitionOrSelf(const_cast<VarDecl *>(VD));
 }
 
 VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const {
@@ -2612,7 +2600,7 @@
 }
 
 TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const {
-  if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
+  if (auto const *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
     return Spec->getSpecializationKind();
 
   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
@@ -2626,14 +2614,14 @@
   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
     return MSI->getTemplateSpecializationKind();
 
-  if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
+  if (auto const *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
     return Spec->getSpecializationKind();
 
   return TSK_Undeclared;
 }
 
 SourceLocation VarDecl::getPointOfInstantiation() const {
-  if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
+  if (auto const *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
     return Spec->getPointOfInstantiation();
 
   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
@@ -2643,7 +2631,8 @@
 }
 
 VarTemplateDecl *VarDecl::getDescribedVarTemplate() const {
-  return getASTContext().getTemplateOrSpecializationInfo(this)
+  return getASTContext()
+      .getTemplateOrSpecializationInfo(this)
       .dyn_cast<VarTemplateDecl *>();
 }
 
@@ -2652,7 +2641,7 @@
 }
 
 bool VarDecl::isKnownToBeDefined() const {
-  const auto &LangOpts = getASTContext().getLangOpts();
+  auto const &LangOpts = getASTContext().getLangOpts();
   // In CUDA mode without relocatable device code, variables of form 'extern
   // __shared__ Foo foo[]' are pointers to the base of the GPU core's shared
   // memory pool.  These are never undefined variables, even if they appear
@@ -2668,14 +2657,14 @@
   return hasDefinition();
 }
 
-bool VarDecl::isNoDestroy(const ASTContext &Ctx) const {
+bool VarDecl::isNoDestroy(ASTContext const &Ctx) const {
   return hasGlobalStorage() && (hasAttr<NoDestroyAttr>() ||
                                 (!Ctx.getLangOpts().RegisterStaticDestructors &&
                                  !hasAttr<AlwaysDestroyAttr>()));
 }
 
 QualType::DestructionKind
-VarDecl::needsDestruction(const ASTContext &Ctx) const {
+VarDecl::needsDestruction(ASTContext const &Ctx) const {
   if (EvaluatedStmt *Eval = getEvaluatedStmt())
     if (Eval->HasConstantDestruction)
       return QualType::DK_none;
@@ -2690,13 +2679,14 @@
   if (isStaticDataMember())
     // FIXME: Remove ?
     // return getASTContext().getInstantiatedFromStaticDataMember(this);
-    return getASTContext().getTemplateOrSpecializationInfo(this)
+    return getASTContext()
+        .getTemplateOrSpecializationInfo(this)
         .dyn_cast<MemberSpecializationInfo *>();
   return nullptr;
 }
 
-void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
-                                         SourceLocation PointOfInstantiation) {
+void VarDecl::setTemplateSpecializationKind(
+    TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation) {
   assert((isa<VarTemplateSpecializationDecl>(this) ||
           getMemberSpecializationInfo()) &&
          "not a variable or static data member template specialization");
@@ -2704,8 +2694,7 @@
   if (VarTemplateSpecializationDecl *Spec =
           dyn_cast<VarTemplateSpecializationDecl>(this)) {
     Spec->setSpecializationKind(TSK);
-    if (TSK != TSK_ExplicitSpecialization &&
-        PointOfInstantiation.isValid() &&
+    if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
         Spec->getPointOfInstantiation().isInvalid()) {
       Spec->setPointOfInstantiation(PointOfInstantiation);
       if (ASTMutationListener *L = getASTContext().getASTMutationListener())
@@ -2722,9 +2711,8 @@
   }
 }
 
-void
-VarDecl::setInstantiationOfStaticDataMember(VarDecl *VD,
-                                            TemplateSpecializationKind TSK) {
+void VarDecl::setInstantiationOfStaticDataMember(
+    VarDecl *VD, TemplateSpecializationKind TSK) {
   assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() &&
          "Previous template or instantiation?");
   getASTContext().setInstantiatedFromStaticDataMember(this, VD, TSK);
@@ -2735,18 +2723,18 @@
 //===----------------------------------------------------------------------===//
 
 ParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC,
-                                 SourceLocation StartLoc,
-                                 SourceLocation IdLoc, IdentifierInfo *Id,
-                                 QualType T, TypeSourceInfo *TInfo,
-                                 StorageClass S, Expr *DefArg) {
-  return new (C, DC) ParmVarDecl(ParmVar, C, DC, StartLoc, IdLoc, Id, T, TInfo,
-                                 S, DefArg);
+                                 SourceLocation StartLoc, SourceLocation IdLoc,
+                                 IdentifierInfo *Id, QualType T,
+                                 TypeSourceInfo *TInfo, StorageClass S,
+                                 Expr *DefArg) {
+  return new (C, DC)
+      ParmVarDecl(ParmVar, C, DC, StartLoc, IdLoc, Id, T, TInfo, S, DefArg);
 }
 
 QualType ParmVarDecl::getOriginalType() const {
   TypeSourceInfo *TSI = getTypeSourceInfo();
   QualType T = TSI ? TSI->getType() : getType();
-  if (const auto *DT = dyn_cast<DecayedType>(T))
+  if (auto const *DT = dyn_cast<DecayedType>(T))
     return DT->getOriginalType();
   return T;
 }
@@ -2811,7 +2799,7 @@
     return getUninstantiatedDefaultArg()->getSourceRange();
 
   case DAK_Normal:
-    if (const Expr *E = getInit())
+    if (Expr const *E = getInit())
       return E->getSourceRange();
 
     // Missing an actual expression, may be invalid.
@@ -2854,7 +2842,7 @@
 
 FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
                            SourceLocation StartLoc,
-                           const DeclarationNameInfo &NameInfo, QualType T,
+                           DeclarationNameInfo const &NameInfo, QualType T,
                            TypeSourceInfo *TInfo, StorageClass S,
                            bool UsesFPIntrin, bool isInlineSpecified,
                            ConstexprSpecKind ConstexprKind,
@@ -2892,16 +2880,17 @@
     setTrailingRequiresClause(TrailingRequiresClause);
 }
 
-void FunctionDecl::getNameForDiagnostic(
-    raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
+void FunctionDecl::getNameForDiagnostic(raw_ostream &OS,
+                                        PrintingPolicy const &Policy,
+                                        bool Qualified) const {
   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
-  const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs();
+  TemplateArgumentList const *TemplateArgs = getTemplateSpecializationArgs();
   if (TemplateArgs)
     printTemplateArgumentList(OS, TemplateArgs->asArray(), Policy);
 }
 
 bool FunctionDecl::isVariadic() const {
-  if (const auto *FT = getType()->getAs<FunctionProtoType>())
+  if (auto const *FT = getType()->getAs<FunctionProtoType>())
     return FT->isVariadic();
   return false;
 }
@@ -2932,7 +2921,7 @@
   return FunctionDeclBits.HasDefaultedFunctionInfo ? DefaultedInfo : nullptr;
 }
 
-bool FunctionDecl::hasBody(const FunctionDecl *&Definition) const {
+bool FunctionDecl::hasBody(FunctionDecl const *&Definition) const {
   for (auto I : redecls()) {
     if (I->doesThisDeclarationHaveABody()) {
       Definition = I;
@@ -2962,15 +2951,15 @@
 
   // Check for a friend function instantiated from a friend function
   // definition in a templated class.
-  if (const FunctionDecl *InstantiatedFrom =
+  if (FunctionDecl const *InstantiatedFrom =
           getInstantiatedFromMemberFunction())
     return InstantiatedFrom->getFriendObjectKind() &&
            InstantiatedFrom->isThisDeclarationADefinition();
 
   // Check for a friend function template instantiated from a friend
   // function template definition in a templated class.
-  if (const FunctionTemplateDecl *Template = getDescribedFunctionTemplate()) {
-    if (const FunctionTemplateDecl *InstantiatedFrom =
+  if (FunctionTemplateDecl const *Template = getDescribedFunctionTemplate()) {
+    if (FunctionTemplateDecl const *InstantiatedFrom =
             Template->getInstantiatedFromMemberTemplate())
       return InstantiatedFrom->getFriendObjectKind() &&
              InstantiatedFrom->isThisDeclarationADefinition();
@@ -2979,9 +2968,9 @@
   return false;
 }
 
-bool FunctionDecl::isDefined(const FunctionDecl *&Definition,
+bool FunctionDecl::isDefined(FunctionDecl const *&Definition,
                              bool CheckForPendingFriendDefinition) const {
-  for (const FunctionDecl *FD : redecls()) {
+  for (FunctionDecl const *FD : redecls()) {
     if (FD->isThisDeclarationADefinition()) {
       Definition = FD;
       return true;
@@ -3012,7 +3001,7 @@
   return false;
 }
 
-Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const {
+Stmt *FunctionDecl::getBody(FunctionDecl const *&Definition) const {
   if (!hasBody(Definition))
     return nullptr;
 
@@ -3038,22 +3027,21 @@
       Parent->markedVirtualFunctionPure();
 }
 
-template<std::size_t Len>
-static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) {
+template <std::size_t Len>
+static bool isNamed(NamedDecl const *ND, char const (&Str)[Len]) {
   IdentifierInfo *II = ND->getIdentifier();
   return II && II->isStr(Str);
 }
 
 bool FunctionDecl::isMain() const {
-  const TranslationUnitDecl *tunit =
-    dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
-  return tunit &&
-         !tunit->getASTContext().getLangOpts().Freestanding &&
+  TranslationUnitDecl const *tunit =
+      dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
+  return tunit && !tunit->getASTContext().getLangOpts().Freestanding &&
          isNamed(this, "main");
 }
 
 bool FunctionDecl::isMSVCRTEntryPoint() const {
-  const TranslationUnitDecl *TUnit =
+  TranslationUnitDecl const *TUnit =
       dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
   if (!TUnit)
     return false;
@@ -3089,13 +3077,13 @@
   if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
     return false;
 
-  const auto *proto = getType()->castAs<FunctionProtoType>();
+  auto const *proto = getType()->castAs<FunctionProtoType>();
   if (proto->getNumParams() != 2 || proto->isVariadic())
     return false;
 
   ASTContext &Context =
-    cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
-      ->getASTContext();
+      cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
+          ->getASTContext();
 
   // The result type and first argument type are constant across all
   // these operators.  The second argument must be exactly void*.
@@ -3119,7 +3107,7 @@
   if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
     return false;
 
-  const auto *FPT = getType()->castAs<FunctionProtoType>();
+  auto const *FPT = getType()->castAs<FunctionProtoType>();
   if (FPT->getNumParams() == 0 || FPT->getNumParams() > 3 || FPT->isVariadic())
     return false;
 
@@ -3149,7 +3137,8 @@
 
   // In C++17, the next parameter can be a 'std::align_val_t' for aligned
   // new/delete.
-  if (Ctx.getLangOpts().AlignedAllocation && !Ty.isNull() && Ty->isAlignValT()) {
+  if (Ctx.getLangOpts().AlignedAllocation && !Ty.isNull() &&
+      Ty->isAlignValT()) {
     Consume();
     if (AlignmentParam)
       *AlignmentParam = Params;
@@ -3175,7 +3164,7 @@
   if (!getBuiltinID())
     return false;
 
-  const FunctionDecl *Definition;
+  FunctionDecl const *Definition;
   return hasBody(Definition) && Definition->isInlineSpecified();
 }
 
@@ -3197,9 +3186,7 @@
   return getDeclLanguageLinkage(*this);
 }
 
-bool FunctionDecl::isExternC() const {
-  return isDeclExternC(*this);
-}
+bool FunctionDecl::isExternC() const { return isDeclExternC(*this); }
 
 bool FunctionDecl::isInExternCContext() const {
   if (hasAttr<OpenCLKernelAttr>())
@@ -3212,16 +3199,15 @@
 }
 
 bool FunctionDecl::isGlobal() const {
-  if (const auto *Method = dyn_cast<CXXMethodDecl>(this))
+  if (auto const *Method = dyn_cast<CXXMethodDecl>(this))
     return Method->isStatic();
 
   if (getCanonicalDecl()->getStorageClass() == SC_Static)
     return false;
 
-  for (const DeclContext *DC = getDeclContext();
-       DC->isNamespace();
+  for (DeclContext const *DC = getDeclContext(); DC->isNamespace();
        DC = DC->getParent()) {
-    if (const auto *Namespace = cast<NamespaceDecl>(DC)) {
+    if (auto const *Namespace = cast<NamespaceDecl>(DC)) {
       if (!Namespace->getDeclName())
         return false;
       break;
@@ -3242,7 +3228,6 @@
   return false;
 }
 
-
 MultiVersionKind FunctionDecl::getMultiVersionKind() const {
   if (hasAttr<TargetAttr>())
     return MultiVersionKind::Target;
@@ -3265,13 +3250,12 @@
   return isMultiVersion() && hasAttr<TargetAttr>();
 }
 
-void
-FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) {
+void FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) {
   redeclarable_base::setPreviousDecl(PrevDecl);
 
   if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) {
-    FunctionTemplateDecl *PrevFunTmpl
-      = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : nullptr;
+    FunctionTemplateDecl *PrevFunTmpl =
+        PrevDecl ? PrevDecl->getDescribedFunctionTemplate() : nullptr;
     assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");
     FunTmpl->setPreviousDecl(PrevFunTmpl);
   }
@@ -3298,11 +3282,11 @@
 unsigned FunctionDecl::getBuiltinID(bool ConsiderWrapperFunctions) const {
   unsigned BuiltinID = 0;
 
-  if (const auto *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
+  if (auto const *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
     BuiltinID = ABAA->getBuiltinName()->getBuiltinID();
-  } else if (const auto *BAA = getAttr<BuiltinAliasAttr>()) {
+  } else if (auto const *BAA = getAttr<BuiltinAliasAttr>()) {
     BuiltinID = BAA->getBuiltinName()->getBuiltinID();
-  } else if (const auto *A = getAttr<BuiltinAttr>()) {
+  } else if (auto const *A = getAttr<BuiltinAttr>()) {
     BuiltinID = A->getID();
   }
 
@@ -3356,7 +3340,7 @@
 /// based on its FunctionType.  This is the length of the ParamInfo array
 /// after it has been created.
 unsigned FunctionDecl::getNumParams() const {
-  const auto *FPT = getType()->getAs<FunctionProtoType>();
+  auto const *FPT = getType()->getAs<FunctionProtoType>();
   return FPT ? FPT->getNumParams() : 0;
 }
 
@@ -3367,7 +3351,7 @@
 
   // Zero params -> null pointer.
   if (!NewParamInfo.empty()) {
-    ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()];
+    ParamInfo = new (C) ParmVarDecl *[NewParamInfo.size()];
     std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
   }
 }
@@ -3409,12 +3393,12 @@
 bool FunctionDecl::isMSExternInline() const {
   assert(isInlined() && "expected to get called on an inlined function!");
 
-  const ASTContext &Context = getASTContext();
+  ASTContext const &Context = getASTContext();
   if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
       !hasAttr<DLLExportAttr>())
     return false;
 
-  for (const FunctionDecl *FD = getMostRecentDecl(); FD;
+  for (FunctionDecl const *FD = getMostRecentDecl(); FD;
        FD = FD->getPreviousDecl())
     if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
       return true;
@@ -3422,11 +3406,11 @@
   return false;
 }
 
-static bool redeclForcesDefMSVC(const FunctionDecl *Redecl) {
+static bool redeclForcesDefMSVC(FunctionDecl const *Redecl) {
   if (Redecl->getStorageClass() != SC_Extern)
     return false;
 
-  for (const FunctionDecl *FD = Redecl->getPreviousDecl(); FD;
+  for (FunctionDecl const *FD = Redecl->getPreviousDecl(); FD;
        FD = FD->getPreviousDecl())
     if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
       return false;
@@ -3434,7 +3418,7 @@
   return true;
 }
 
-static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
+static bool RedeclForcesDefC99(FunctionDecl const *Redecl) {
   // Only consider file-scope declarations in this test.
   if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
     return false;
@@ -3463,7 +3447,7 @@
   ASTContext &Context = getASTContext();
 
   if (Context.getLangOpts().MSVCCompat) {
-    const FunctionDecl *Definition;
+    FunctionDecl const *Definition;
     if (hasBody(Definition) && Definition->isInlined() &&
         redeclForcesDefMSVC(this))
       return true;
@@ -3481,7 +3465,7 @@
     if (!isInlineSpecified() || getStorageClass() == SC_Extern)
       return false;
 
-    const FunctionDecl *Prev = this;
+    FunctionDecl const *Prev = this;
     bool FoundBody = false;
     while ((Prev = Prev->getPreviousDecl())) {
       FoundBody |= Prev->doesThisDeclarationHaveABody();
@@ -3489,8 +3473,7 @@
       if (Prev->doesThisDeclarationHaveABody()) {
         // If it's not the case that both 'inline' and 'extern' are
         // specified on the definition, then it is always externally visible.
-        if (!Prev->isInlineSpecified() ||
-            Prev->getStorageClass() != SC_Extern)
+        if (!Prev->isInlineSpecified() || Prev->getStorageClass() != SC_Extern)
           return false;
       } else if (Prev->isInlineSpecified() &&
                  Prev->getStorageClass() != SC_Extern) {
@@ -3506,7 +3489,7 @@
   //   then the definition in that translation unit is an inline definition.
   if (isInlineSpecified() && getStorageClass() != SC_Extern)
     return false;
-  const FunctionDecl *Prev = this;
+  FunctionDecl const *Prev = this;
   bool FoundBody = false;
   while ((Prev = Prev->getPreviousDecl())) {
     FoundBody |= Prev->doesThisDeclarationHaveABody();
@@ -3517,7 +3500,7 @@
 }
 
 FunctionTypeLoc FunctionDecl::getFunctionTypeLoc() const {
-  const TypeSourceInfo *TSI = getTypeSourceInfo();
+  TypeSourceInfo const *TSI = getTypeSourceInfo();
   return TSI ? TSI->getTypeLoc().IgnoreParens().getAs<FunctionTypeLoc>()
              : FunctionTypeLoc();
 }
@@ -3528,7 +3511,7 @@
     return SourceRange();
 
   // Skip self-referential return types.
-  const SourceManager &SM = getASTContext().getSourceManager();
+  SourceManager const &SM = getASTContext().getSourceManager();
   SourceRange RTRange = FTL.getReturnLoc().getSourceRange();
   SourceLocation Boundary = getNameInfo().getBeginLoc();
   if (RTRange.isInvalid() || Boundary.isInvalid() ||
@@ -3598,8 +3581,7 @@
     // If any declaration is 'inline' but not 'extern', then this definition
     // is externally visible.
     for (auto Redecl : redecls()) {
-      if (Redecl->isInlineSpecified() &&
-          Redecl->getStorageClass() != SC_Extern)
+      if (Redecl->isInlineSpecified() && Redecl->getStorageClass() != SC_Extern)
         return true;
     }
 
@@ -3636,7 +3618,7 @@
 
 /// getLiteralIdentifier - The literal suffix identifier this function
 /// represents, if any.
-const IdentifierInfo *FunctionDecl::getLiteralIdentifier() const {
+IdentifierInfo const *FunctionDecl::getLiteralIdentifier() const {
   if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName)
     return getDeclName().getCXXLiteralIdentifier();
   return nullptr;
@@ -3651,8 +3633,8 @@
     return TK_MemberSpecialization;
   if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>())
     return TK_FunctionTemplateSpecialization;
-  if (TemplateOrSpecialization.is
-                               <DependentFunctionTemplateSpecializationInfo*>())
+  if (TemplateOrSpecialization
+          .is<DependentFunctionTemplateSpecializationInfo *>())
     return TK_DependentFunctionTemplateSpecialization;
 
   llvm_unreachable("Did we miss a TemplateOrSpecialization type?");
@@ -3675,14 +3657,11 @@
   return nullptr;
 }
 
-void
-FunctionDecl::setInstantiationOfMemberFunction(ASTContext &C,
-                                               FunctionDecl *FD,
-                                               TemplateSpecializationKind TSK) {
+void FunctionDecl::setInstantiationOfMemberFunction(
+    ASTContext &C, FunctionDecl *FD, TemplateSpecializationKind TSK) {
   assert(TemplateOrSpecialization.isNull() &&
          "Member function is already a specialization");
-  MemberSpecializationInfo *Info
-    = new (C) MemberSpecializationInfo(FD, TSK);
+  MemberSpecializationInfo *Info = new (C) MemberSpecializationInfo(FD, TSK);
   TemplateOrSpecialization = Info;
 }
 
@@ -3690,7 +3669,8 @@
   return TemplateOrSpecialization.dyn_cast<FunctionTemplateDecl *>();
 }
 
-void FunctionDecl::setDescribedFunctionTemplate(FunctionTemplateDecl *Template) {
+void FunctionDecl::setDescribedFunctionTemplate(
+    FunctionTemplateDecl *Template) {
   assert(TemplateOrSpecialization.isNull() &&
          "Member function is already a specialization");
   TemplateOrSpecialization = Template;
@@ -3716,7 +3696,7 @@
   }
 
   // Find the actual template from which we will instantiate.
-  const FunctionDecl *PatternDecl = getTemplateInstantiationPattern();
+  FunctionDecl const *PatternDecl = getTemplateInstantiationPattern();
   bool HasPattern = false;
   if (PatternDecl)
     HasPattern = PatternDecl->hasBody(PatternDecl);
@@ -3756,7 +3736,7 @@
 
   // Check for a declaration of this function that was instantiated from a
   // friend definition.
-  const FunctionDecl *FD = nullptr;
+  FunctionDecl const *FD = nullptr;
   if (!isDefined(FD, /*CheckForPendingFriendDefinition=*/true))
     FD = this;
 
@@ -3788,9 +3768,9 @@
 }
 
 FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const {
-  if (FunctionTemplateSpecializationInfo *Info
-        = TemplateOrSpecialization
-            .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
+  if (FunctionTemplateSpecializationInfo *Info =
+          TemplateOrSpecialization
+              .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
     return Info->getTemplate();
   }
   return nullptr;
@@ -3802,34 +3782,32 @@
       .dyn_cast<FunctionTemplateSpecializationInfo *>();
 }
 
-const TemplateArgumentList *
+TemplateArgumentList const *
 FunctionDecl::getTemplateSpecializationArgs() const {
-  if (FunctionTemplateSpecializationInfo *Info
-        = TemplateOrSpecialization
-            .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
+  if (FunctionTemplateSpecializationInfo *Info =
+          TemplateOrSpecialization
+              .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
     return Info->TemplateArguments;
   }
   return nullptr;
 }
 
-const ASTTemplateArgumentListInfo *
+ASTTemplateArgumentListInfo const *
 FunctionDecl::getTemplateSpecializationArgsAsWritten() const {
-  if (FunctionTemplateSpecializationInfo *Info
-        = TemplateOrSpecialization
-            .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
+  if (FunctionTemplateSpecializationInfo *Info =
+          TemplateOrSpecialization
+              .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
     return Info->TemplateArgumentsAsWritten;
   }
   return nullptr;
 }
 
-void
-FunctionDecl::setFunctionTemplateSpecialization(ASTContext &C,
-                                                FunctionTemplateDecl *Template,
-                                     const TemplateArgumentList *TemplateArgs,
-                                                void *InsertPos,
-                                                TemplateSpecializationKind TSK,
-                        const TemplateArgumentListInfo *TemplateArgsAsWritten,
-                                          SourceLocation PointOfInstantiation) {
+void FunctionDecl::setFunctionTemplateSpecialization(
+    ASTContext &C, FunctionTemplateDecl *Template,
+    TemplateArgumentList const *TemplateArgs, void *InsertPos,
+    TemplateSpecializationKind TSK,
+    TemplateArgumentListInfo const *TemplateArgsAsWritten,
+    SourceLocation PointOfInstantiation) {
   assert((TemplateOrSpecialization.isNull() ||
           TemplateOrSpecialization.is<MemberSpecializationInfo *>()) &&
          "Member function is already a specialization");
@@ -3847,10 +3825,9 @@
   Template->addSpecialization(Info, InsertPos);
 }
 
-void
-FunctionDecl::setDependentTemplateSpecialization(ASTContext &Context,
-                                    const UnresolvedSetImpl &Templates,
-                             const TemplateArgumentListInfo &TemplateArgs) {
+void FunctionDecl::setDependentTemplateSpecialization(
+    ASTContext &Context, UnresolvedSetImpl const &Templates,
+    TemplateArgumentListInfo const &TemplateArgs) {
   assert(TemplateOrSpecialization.isNull());
   DependentFunctionTemplateSpecializationInfo *Info =
       DependentFunctionTemplateSpecializationInfo::Create(Context, Templates,
@@ -3866,8 +3843,8 @@
 
 DependentFunctionTemplateSpecializationInfo *
 DependentFunctionTemplateSpecializationInfo::Create(
-    ASTContext &Context, const UnresolvedSetImpl &Ts,
-    const TemplateArgumentListInfo &TArgs) {
+    ASTContext &Context, UnresolvedSetImpl const &Ts,
+    TemplateArgumentListInfo const &TArgs) {
   void *Buffer = Context.Allocate(
       totalSizeToAlloc<TemplateArgumentLoc, FunctionTemplateDecl *>(
           TArgs.size(), Ts.size()));
@@ -3875,9 +3852,9 @@
 }
 
 DependentFunctionTemplateSpecializationInfo::
-DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts,
-                                      const TemplateArgumentListInfo &TArgs)
-  : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) {
+    DependentFunctionTemplateSpecializationInfo(
+        UnresolvedSetImpl const &Ts, TemplateArgumentListInfo const &TArgs)
+    : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) {
   NumTemplates = Ts.size();
   NumArgs = TArgs.size();
 
@@ -3939,25 +3916,23 @@
   return TSK_Undeclared;
 }
 
-void
-FunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
-                                          SourceLocation PointOfInstantiation) {
-  if (FunctionTemplateSpecializationInfo *FTSInfo
-        = TemplateOrSpecialization.dyn_cast<
-                                    FunctionTemplateSpecializationInfo*>()) {
+void FunctionDecl::setTemplateSpecializationKind(
+    TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation) {
+  if (FunctionTemplateSpecializationInfo *FTSInfo =
+          TemplateOrSpecialization
+              .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
     FTSInfo->setTemplateSpecializationKind(TSK);
-    if (TSK != TSK_ExplicitSpecialization &&
-        PointOfInstantiation.isValid() &&
+    if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
         FTSInfo->getPointOfInstantiation().isInvalid()) {
       FTSInfo->setPointOfInstantiation(PointOfInstantiation);
       if (ASTMutationListener *L = getASTContext().getASTMutationListener())
         L->InstantiationRequested(this);
     }
-  } else if (MemberSpecializationInfo *MSInfo
-             = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) {
+  } else if (MemberSpecializationInfo *MSInfo =
+                 TemplateOrSpecialization
+                     .dyn_cast<MemberSpecializationInfo *>()) {
     MSInfo->setTemplateSpecializationKind(TSK);
-    if (TSK != TSK_ExplicitSpecialization &&
-        PointOfInstantiation.isValid() &&
+    if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
         MSInfo->getPointOfInstantiation().isInvalid()) {
       MSInfo->setPointOfInstantiation(PointOfInstantiation);
       if (ASTMutationListener *L = getASTContext().getASTMutationListener())
@@ -3968,9 +3943,9 @@
 }
 
 SourceLocation FunctionDecl::getPointOfInstantiation() const {
-  if (FunctionTemplateSpecializationInfo *FTSInfo
-        = TemplateOrSpecialization.dyn_cast<
-                                        FunctionTemplateSpecializationInfo*>())
+  if (FunctionTemplateSpecializationInfo *FTSInfo =
+          TemplateOrSpecialization
+              .dyn_cast<FunctionTemplateSpecializationInfo *>())
     return FTSInfo->getPointOfInstantiation();
   if (MemberSpecializationInfo *MSInfo =
           TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo *>())
@@ -3986,7 +3961,7 @@
   // If this function was instantiated from a member function of a
   // class template, check whether that member function was defined out-of-line.
   if (FunctionDecl *FD = getInstantiatedFromMemberFunction()) {
-    const FunctionDecl *Definition;
+    FunctionDecl const *Definition;
     if (FD->hasBody(Definition))
       return Definition->isOutOfLine();
   }
@@ -3994,7 +3969,7 @@
   // If this function was instantiated from a function template,
   // check whether that function template was defined out-of-line.
   if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) {
-    const FunctionDecl *Definition;
+    FunctionDecl const *Definition;
     if (FunTmpl->getTemplatedDecl()->hasBody(Definition))
       return Definition->isOutOfLine();
   }
@@ -4146,7 +4121,7 @@
 // FieldDecl Implementation
 //===----------------------------------------------------------------------===//
 
-FieldDecl *FieldDecl::Create(const ASTContext &C, DeclContext *DC,
+FieldDecl *FieldDecl::Create(ASTContext const &C, DeclContext *DC,
                              SourceLocation StartLoc, SourceLocation IdLoc,
                              IdentifierInfo *Id, QualType T,
                              TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
@@ -4156,32 +4131,32 @@
 }
 
 FieldDecl *FieldDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) FieldDecl(Field, nullptr, SourceLocation(),
-                               SourceLocation(), nullptr, QualType(), nullptr,
-                               nullptr, false, ICIS_NoInit);
+  return new (C, ID)
+      FieldDecl(Field, nullptr, SourceLocation(), SourceLocation(), nullptr,
+                QualType(), nullptr, nullptr, false, ICIS_NoInit);
 }
 
 bool FieldDecl::isAnonymousStructOrUnion() const {
   if (!isImplicit() || getDeclName())
     return false;
 
-  if (const auto *Record = getType()->getAs<RecordType>())
+  if (auto const *Record = getType()->getAs<RecordType>())
     return Record->getDecl()->isAnonymousStructOrUnion();
 
   return false;
 }
 
-unsigned FieldDecl::getBitWidthValue(const ASTContext &Ctx) const {
+unsigned FieldDecl::getBitWidthValue(ASTContext const &Ctx) const {
   assert(isBitField() && "not a bitfield");
   return getBitWidth()->EvaluateKnownConstInt(Ctx).getZExtValue();
 }
 
-bool FieldDecl::isZeroLengthBitField(const ASTContext &Ctx) const {
+bool FieldDecl::isZeroLengthBitField(ASTContext const &Ctx) const {
   return isUnnamedBitfield() && !getBitWidth()->isValueDependent() &&
          getBitWidthValue(Ctx) == 0;
 }
 
-bool FieldDecl::isZeroSize(const ASTContext &Ctx) const {
+bool FieldDecl::isZeroSize(ASTContext const &Ctx) const {
   if (isZeroLengthBitField(Ctx))
     return true;
 
@@ -4192,10 +4167,10 @@
     return false;
 
   //     -- is not of class type, or
-  const auto *RT = getType()->getAs<RecordType>();
+  auto const *RT = getType()->getAs<RecordType>();
   if (!RT)
     return false;
-  const RecordDecl *RD = RT->getDecl()->getDefinition();
+  RecordDecl const *RD = RT->getDecl()->getDefinition();
   if (!RD) {
     assert(isInvalidDecl() && "valid field has incomplete type");
     return false;
@@ -4203,7 +4178,7 @@
 
   //     -- [has] virtual member functions or virtual base classes, or
   //     -- has subobjects of nonzero size or bit-fields of nonzero length
-  const auto *CXXRD = cast<CXXRecordDecl>(RD);
+  auto const *CXXRD = cast<CXXRecordDecl>(RD);
   if (!CXXRD->isEmpty())
     return false;
 
@@ -4215,14 +4190,15 @@
 }
 
 unsigned FieldDecl::getFieldIndex() const {
-  const FieldDecl *Canonical = getCanonicalDecl();
+  FieldDecl const *Canonical = getCanonicalDecl();
   if (Canonical != this)
     return Canonical->getFieldIndex();
 
-  if (CachedFieldIndex) return CachedFieldIndex - 1;
+  if (CachedFieldIndex)
+    return CachedFieldIndex - 1;
 
   unsigned Index = 0;
-  const RecordDecl *RD = getParent()->getDefinition();
+  RecordDecl const *RD = getParent()->getDefinition();
   assert(RD && "requested index for field of struct with no definition");
 
   for (auto *Field : RD->fields()) {
@@ -4235,7 +4211,7 @@
 }
 
 SourceRange FieldDecl::getSourceRange() const {
-  const Expr *FinalExpr = getInClassInitializer();
+  Expr const *FinalExpr = getInClassInitializer();
   if (!FinalExpr)
     FinalExpr = getBitWidth();
   if (FinalExpr)
@@ -4243,7 +4219,7 @@
   return DeclaratorDecl::getSourceRange();
 }
 
-void FieldDecl::setCapturedVLAType(const VariableArrayType *VLAType) {
+void FieldDecl::setCapturedVLAType(VariableArrayType const *VLAType) {
   assert((getParent()->isLambda() || getParent()->isCapturedRecord()) &&
          "capturing type in non-lambda or captured record.");
   assert(InitStorage.getInt() == ISK_NoInit &&
@@ -4257,7 +4233,7 @@
 // TagDecl Implementation
 //===----------------------------------------------------------------------===//
 
-TagDecl::TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
+TagDecl::TagDecl(Kind DK, TagKind TK, ASTContext const &C, DeclContext *DC,
                  SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
                  SourceLocation StartL)
     : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), redeclarable_base(C),
@@ -4287,7 +4263,7 @@
 
 void TagDecl::setTypedefNameForAnonDecl(TypedefNameDecl *TDD) {
   TypedefNameDeclOrQualifier = TDD;
-  if (const Type *T = getTypeForDecl()) {
+  if (Type const *T = getTypeForDecl()) {
     (void)T;
     assert(T->isLinkageValid());
   }
@@ -4299,7 +4275,7 @@
 
   if (auto *D = dyn_cast<CXXRecordDecl>(this)) {
     struct CXXRecordDecl::DefinitionData *Data =
-      new (getASTContext()) struct CXXRecordDecl::DefinitionData(D);
+        new (getASTContext()) struct CXXRecordDecl::DefinitionData(D);
     for (auto I : redecls())
       cast<CXXRecordDecl>(I)->DefinitionData = Data;
   }
@@ -4330,7 +4306,7 @@
     }
   }
 
-  if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(this))
+  if (auto const *CXXRD = dyn_cast<CXXRecordDecl>(this))
     return CXXRD->getDefinition();
 
   for (auto R : redecls())
@@ -4353,8 +4329,7 @@
       if (getExtInfo()->NumTemplParamLists == 0) {
         getASTContext().Deallocate(getExtInfo());
         TypedefNameDeclOrQualifier = (TypedefNameDecl *)nullptr;
-      }
-      else
+      } else
         getExtInfo()->QualifierLoc = QualifierLoc;
     }
   }
@@ -4394,9 +4369,9 @@
 
 EnumDecl *EnumDecl::Create(ASTContext &C, DeclContext *DC,
                            SourceLocation StartLoc, SourceLocation IdLoc,
-                           IdentifierInfo *Id,
-                           EnumDecl *PrevDecl, bool IsScoped,
-                           bool IsScopedUsingClassTag, bool IsFixed) {
+                           IdentifierInfo *Id, EnumDecl *PrevDecl,
+                           bool IsScoped, bool IsScopedUsingClassTag,
+                           bool IsFixed) {
   auto *Enum = new (C, DC) EnumDecl(C, DC, StartLoc, IdLoc, Id, PrevDecl,
                                     IsScoped, IsScopedUsingClassTag, IsFixed);
   Enum->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
@@ -4413,13 +4388,12 @@
 }
 
 SourceRange EnumDecl::getIntegerTypeRange() const {
-  if (const TypeSourceInfo *TI = getIntegerTypeSourceInfo())
+  if (TypeSourceInfo const *TI = getIntegerTypeSourceInfo())
     return TI->getTypeLoc().getSourceRange();
   return SourceRange();
 }
 
-void EnumDecl::completeDefinition(QualType NewType,
-                                  QualType NewPromotionType,
+void EnumDecl::completeDefinition(QualType NewType, QualType NewPromotionType,
                                   unsigned NumPositiveBits,
                                   unsigned NumNegativeBits) {
   assert(!isCompleteDefinition() && "Cannot redefine enums!");
@@ -4432,7 +4406,7 @@
 }
 
 bool EnumDecl::isClosed() const {
-  if (const auto *A = getAttr<EnumExtensibilityAttr>())
+  if (auto const *A = getAttr<EnumExtensibilityAttr>())
     return A->getExtensibility() == EnumExtensibilityAttr::Closed;
   return true;
 }
@@ -4452,13 +4426,12 @@
   return TSK_Undeclared;
 }
 
-void EnumDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
-                                         SourceLocation PointOfInstantiation) {
+void EnumDecl::setTemplateSpecializationKind(
+    TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation) {
   MemberSpecializationInfo *MSI = getMemberSpecializationInfo();
   assert(MSI && "Not an instantiated member enumeration?");
   MSI->setTemplateSpecializationKind(TSK);
-  if (TSK != TSK_ExplicitSpecialization &&
-      PointOfInstantiation.isValid() &&
+  if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
       MSI->getPointOfInstantiation().isInvalid())
     MSI->setPointOfInstantiation(PointOfInstantiation);
 }
@@ -4506,7 +4479,7 @@
 // RecordDecl Implementation
 //===----------------------------------------------------------------------===//
 
-RecordDecl::RecordDecl(Kind DK, TagKind TK, const ASTContext &C,
+RecordDecl::RecordDecl(Kind DK, TagKind TK, ASTContext const &C,
                        DeclContext *DC, SourceLocation StartLoc,
                        SourceLocation IdLoc, IdentifierInfo *Id,
                        RecordDecl *PrevDecl)
@@ -4527,18 +4500,18 @@
   setArgPassingRestrictions(APK_CanPassInRegs);
 }
 
-RecordDecl *RecordDecl::Create(const ASTContext &C, TagKind TK, DeclContext *DC,
+RecordDecl *RecordDecl::Create(ASTContext const &C, TagKind TK, DeclContext *DC,
                                SourceLocation StartLoc, SourceLocation IdLoc,
-                               IdentifierInfo *Id, RecordDecl* PrevDecl) {
-  RecordDecl *R = new (C, DC) RecordDecl(Record, TK, C, DC,
-                                         StartLoc, IdLoc, Id, PrevDecl);
+                               IdentifierInfo *Id, RecordDecl *PrevDecl) {
+  RecordDecl *R =
+      new (C, DC) RecordDecl(Record, TK, C, DC, StartLoc, IdLoc, Id, PrevDecl);
   R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
 
   C.getTypeDeclType(R, PrevDecl);
   return R;
 }
 
-RecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
+RecordDecl *RecordDecl::CreateDeserialized(ASTContext const &C, unsigned ID) {
   RecordDecl *R =
       new (C, ID) RecordDecl(Record, TTK_Struct, C, nullptr, SourceLocation(),
                              SourceLocation(), nullptr, nullptr);
@@ -4548,7 +4521,7 @@
 
 bool RecordDecl::isInjectedClassName() const {
   return isImplicit() && getDeclName() && getDeclContext()->isRecord() &&
-    cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName();
+         cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName();
 }
 
 bool RecordDecl::isLambda() const {
@@ -4569,9 +4542,9 @@
   if (isUnion())
     return true;
 
-  if (const RecordDecl *Def = getDefinition()) {
-    for (const FieldDecl *FD : Def->fields()) {
-      const RecordType *RT = FD->getType()->getAs<RecordType>();
+  if (RecordDecl const *Def = getDefinition()) {
+    for (FieldDecl const *FD : Def->fields()) {
+      RecordType const *RT = FD->getType()->getAs<RecordType>();
       if (RT && RT->getDecl()->isOrContainsUnion())
         return true;
     }
@@ -4604,7 +4577,7 @@
 /// isMsStruct - Get whether or not this record uses ms_struct layout.
 /// This which can be turned on with an attribute, pragma, or the
 /// -mms-bitfields command-line option.
-bool RecordDecl::isMsStruct(const ASTContext &C) const {
+bool RecordDecl::isMsStruct(ASTContext const &C) const {
   return hasAttr<MSStructAttr>() || C.getLangOpts().MSBitfields == 1;
 }
 
@@ -4615,15 +4588,18 @@
   // Notify that we have a RecordDecl doing some initialization.
   ExternalASTSource::Deserializing TheFields(Source);
 
-  SmallVector<Decl*, 64> Decls;
+  SmallVector<Decl *, 64> Decls;
   setHasLoadedFieldsFromExternalStorage(true);
-  Source->FindExternalLexicalDecls(this, [](Decl::Kind K) {
-    return FieldDecl::classofKind(K) || IndirectFieldDecl::classofKind(K);
-  }, Decls);
+  Source->FindExternalLexicalDecls(
+      this,
+      [](Decl::Kind K) {
+        return FieldDecl::classofKind(K) || IndirectFieldDecl::classofKind(K);
+      },
+      Decls);
 
 #ifndef NDEBUG
   // Check that all decls we got were FieldDecls.
-  for (unsigned i=0, e=Decls.size(); i != e; ++i)
+  for (unsigned i = 0, e = Decls.size(); i != e; ++i)
     assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
 #endif
 
@@ -4636,32 +4612,33 @@
 
 bool RecordDecl::mayInsertExtraPadding(bool EmitRemark) const {
   ASTContext &Context = getASTContext();
-  const SanitizerMask EnabledAsanMask = Context.getLangOpts().Sanitize.Mask &
+  const SanitizerMask EnabledAsanMask =
+      Context.getLangOpts().Sanitize.Mask &
       (SanitizerKind::Address | SanitizerKind::KernelAddress);
   if (!EnabledAsanMask || !Context.getLangOpts().SanitizeAddressFieldPadding)
     return false;
-  const auto &NoSanitizeList = Context.getNoSanitizeList();
-  const auto *CXXRD = dyn_cast<CXXRecordDecl>(this);
+  auto const &NoSanitizeList = Context.getNoSanitizeList();
+  auto const *CXXRD = dyn_cast<CXXRecordDecl>(this);
   // We may be able to relax some of these requirements.
   int ReasonToReject = -1;
   if (!CXXRD || CXXRD->isExternCContext())
-    ReasonToReject = 0;  // is not C++.
+    ReasonToReject = 0; // is not C++.
   else if (CXXRD->hasAttr<PackedAttr>())
-    ReasonToReject = 1;  // is packed.
+    ReasonToReject = 1; // is packed.
   else if (CXXRD->isUnion())
-    ReasonToReject = 2;  // is a union.
+    ReasonToReject = 2; // is a union.
   else if (CXXRD->isTriviallyCopyable())
-    ReasonToReject = 3;  // is trivially copyable.
+    ReasonToReject = 3; // is trivially copyable.
   else if (CXXRD->hasTrivialDestructor())
-    ReasonToReject = 4;  // has trivial destructor.
+    ReasonToReject = 4; // has trivial destructor.
   else if (CXXRD->isStandardLayout())
-    ReasonToReject = 5;  // is standard layout.
+    ReasonToReject = 5; // is standard layout.
   else if (NoSanitizeList.containsLocation(EnabledAsanMask, getLocation(),
                                            "field-padding"))
-    ReasonToReject = 6;  // is in an excluded file.
+    ReasonToReject = 6; // is in an excluded file.
   else if (NoSanitizeList.containsType(
                EnabledAsanMask, getQualifiedNameAsString(), "field-padding"))
-    ReasonToReject = 7;  // The type is excluded.
+    ReasonToReject = 7; // The type is excluded.
 
   if (EmitRemark) {
     if (ReasonToReject >= 0)
@@ -4678,13 +4655,13 @@
   return ReasonToReject < 0;
 }
 
-const FieldDecl *RecordDecl::findFirstNamedDataMember() const {
-  for (const auto *I : fields()) {
+FieldDecl const *RecordDecl::findFirstNamedDataMember() const {
+  for (auto const *I : fields()) {
     if (I->getIdentifier())
       return I;
 
-    if (const auto *RT = I->getType()->getAs<RecordType>())
-      if (const FieldDecl *NamedDataMember =
+    if (auto const *RT = I->getType()->getAs<RecordType>())
+      if (FieldDecl const *NamedDataMember =
               RT->getDecl()->findFirstNamedDataMember())
         return NamedDataMember;
   }
@@ -4713,7 +4690,7 @@
   // Zero params -> null pointer.
   if (!NewParamInfo.empty()) {
     NumParams = NewParamInfo.size();
-    ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()];
+    ParamInfo = new (getASTContext()) ParmVarDecl *[NewParamInfo.size()];
     std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
   }
 }
@@ -4731,8 +4708,8 @@
   this->Captures = Captures.copy(Context).data();
 }
 
-bool BlockDecl::capturesVariable(const VarDecl *variable) const {
-  for (const auto &I : captures())
+bool BlockDecl::capturesVariable(VarDecl const *variable) const {
+  for (auto const &I : captures())
     // Only auto vars can be captured, so no redeclaration worries.
     if (I.getVariable() == variable)
       return true;
@@ -4756,7 +4733,7 @@
 
 void PragmaCommentDecl::anchor() {}
 
-PragmaCommentDecl *PragmaCommentDecl::Create(const ASTContext &C,
+PragmaCommentDecl *PragmaCommentDecl::Create(ASTContext const &C,
                                              TranslationUnitDecl *DC,
                                              SourceLocation CommentLoc,
                                              PragmaMSCommentKind CommentKind,
@@ -4779,7 +4756,7 @@
 void PragmaDetectMismatchDecl::anchor() {}
 
 PragmaDetectMismatchDecl *
-PragmaDetectMismatchDecl::Create(const ASTContext &C, TranslationUnitDecl *DC,
+PragmaDetectMismatchDecl::Create(ASTContext const &C, TranslationUnitDecl *DC,
                                  SourceLocation Loc, StringRef Name,
                                  StringRef Value) {
   size_t ValueStart = Name.size() + 1;
@@ -4803,7 +4780,7 @@
 
 void ExternCContextDecl::anchor() {}
 
-ExternCContextDecl *ExternCContextDecl::Create(const ASTContext &C,
+ExternCContextDecl *ExternCContextDecl::Create(ASTContext const &C,
                                                TranslationUnitDecl *DC) {
   return new (C, DC) ExternCContextDecl(DC);
 }
@@ -4823,12 +4800,12 @@
 }
 
 LabelDecl *LabelDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) LabelDecl(nullptr, SourceLocation(), nullptr, nullptr,
-                               SourceLocation());
+  return new (C, ID)
+      LabelDecl(nullptr, SourceLocation(), nullptr, nullptr, SourceLocation());
 }
 
 void LabelDecl::setMSAsmLabel(StringRef Name) {
-char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
+  char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
   memcpy(Buffer, Name.data(), Name.size());
   Buffer[Name.size()] = '\0';
   MSAsmName = Buffer;
@@ -4863,7 +4840,7 @@
 
 FunctionDecl *
 FunctionDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
-                     const DeclarationNameInfo &NameInfo, QualType T,
+                     DeclarationNameInfo const &NameInfo, QualType T,
                      TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin,
                      bool isInlineSpecified, bool hasWrittenPrototype,
                      ConstexprSpecKind ConstexprKind,
@@ -4912,14 +4889,14 @@
 void CapturedDecl::setNothrow(bool Nothrow) { BodyAndNothrow.setInt(Nothrow); }
 
 EnumConstantDecl *EnumConstantDecl::Create(ASTContext &C, EnumDecl *CD,
-                                           SourceLocation L,
-                                           IdentifierInfo *Id, QualType T,
-                                           Expr *E, const llvm::APSInt &V) {
+                                           SourceLocation L, IdentifierInfo *Id,
+                                           QualType T, Expr *E,
+                                           llvm::APSInt const &V) {
   return new (C, CD) EnumConstantDecl(CD, L, Id, T, E, V);
 }
 
-EnumConstantDecl *
-EnumConstantDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
+EnumConstantDecl *EnumConstantDecl::CreateDeserialized(ASTContext &C,
+                                                       unsigned ID) {
   return new (C, ID) EnumConstantDecl(nullptr, SourceLocation(), nullptr,
                                       QualType(), nullptr, llvm::APSInt());
 }
@@ -5049,8 +5026,8 @@
 
 FileScopeAsmDecl *FileScopeAsmDecl::CreateDeserialized(ASTContext &C,
                                                        unsigned ID) {
-  return new (C, ID) FileScopeAsmDecl(nullptr, nullptr, SourceLocation(),
-                                      SourceLocation());
+  return new (C, ID)
+      FileScopeAsmDecl(nullptr, nullptr, SourceLocation(), SourceLocation());
 }
 
 void EmptyDecl::anchor() {}
@@ -5124,7 +5101,7 @@
   if (!isImportComplete())
     return None;
 
-  const auto *StoredLocs = getTrailingObjects<SourceLocation>();
+  auto const *StoredLocs = getTrailingObjects<SourceLocation>();
   return llvm::makeArrayRef(StoredLocs,
                             getNumModuleIdentifiers(getImportedModule()));
 }
Index: clang/lib/AST/DeclBase.cpp
===================================================================
--- clang/lib/AST/DeclBase.cpp
+++ clang/lib/AST/DeclBase.cpp
@@ -70,14 +70,14 @@
 #define ABSTRACT_DECL(DECL)
 #include "clang/AST/DeclNodes.inc"
 
-void *Decl::operator new(std::size_t Size, const ASTContext &Context,
+void *Decl::operator new(std::size_t Size, ASTContext const &Context,
                          unsigned ID, std::size_t Extra) {
   // Allocate an extra 8 bytes worth of storage, which ensures that the
   // resulting pointer will still be 8-byte aligned.
   static_assert(sizeof(unsigned) * 2 >= alignof(Decl),
                 "Decl won't be misaligned");
   void *Start = Context.Allocate(Size + Extra + 8);
-  void *Result = (char*)Start + 8;
+  void *Result = (char *)Start + 8;
 
   unsigned *PrefixPtr = (unsigned *)Result - 2;
 
@@ -90,7 +90,7 @@
   return Result;
 }
 
-void *Decl::operator new(std::size_t Size, const ASTContext &Ctx,
+void *Decl::operator new(std::size_t Size, ASTContext const &Ctx,
                          DeclContext *Parent, std::size_t Extra) {
   assert(!Parent || &Parent->getParentASTContext() == &Ctx);
   // With local visibility enabled, we track the owning module even for local
@@ -106,7 +106,7 @@
     Buffer += ExtraAlign;
     auto *ParentModule =
         Parent ? cast<Decl>(Parent)->getOwningModule() : nullptr;
-    return new (Buffer) Module*(ParentModule) + 1;
+    return new (Buffer) Module *(ParentModule) + 1;
   }
   return ::operator new(Size + Extra, Ctx);
 }
@@ -120,10 +120,13 @@
   return getASTContext().getLangOpts().trackLocalOwningModule();
 }
 
-const char *Decl::getDeclKindName() const {
+char const *Decl::getDeclKindName() const {
   switch (DeclKind) {
-  default: llvm_unreachable("Declaration not in DeclNodes.inc!");
-#define DECL(DERIVED, BASE) case DERIVED: return #DERIVED;
+  default:
+    llvm_unreachable("Declaration not in DeclNodes.inc!");
+#define DECL(DERIVED, BASE)                                                    \
+  case DERIVED:                                                                \
+    return #DERIVED;
 #define ABSTRACT_DECL(DECL)
 #include "clang/AST/DeclNodes.inc"
   }
@@ -152,9 +155,11 @@
   }
 }
 
-const char *DeclContext::getDeclKindName() const {
+char const *DeclContext::getDeclKindName() const {
   switch (getDeclKind()) {
-#define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED;
+#define DECL(DERIVED, BASE)                                                    \
+  case Decl::DERIVED:                                                          \
+    return #DERIVED;
 #define ABSTRACT_DECL(DECL)
 #include "clang/AST/DeclNodes.inc"
   }
@@ -162,9 +167,7 @@
 }
 
 bool Decl::StatisticsEnabled = false;
-void Decl::EnableStatistics() {
-  StatisticsEnabled = true;
-}
+void Decl::EnableStatistics() { StatisticsEnabled = true; }
 
 void Decl::PrintStats() {
   llvm::errs() << "\n*** Decl Stats:\n";
@@ -176,13 +179,12 @@
   llvm::errs() << "  " << totalDecls << " decls total.\n";
 
   int totalBytes = 0;
-#define DECL(DERIVED, BASE)                                             \
-  if (n##DERIVED##s > 0) {                                              \
-    totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl));         \
-    llvm::errs() << "    " << n##DERIVED##s << " " #DERIVED " decls, "  \
-                 << sizeof(DERIVED##Decl) << " each ("                  \
-                 << n##DERIVED##s * sizeof(DERIVED##Decl)               \
-                 << " bytes)\n";                                        \
+#define DECL(DERIVED, BASE)                                                    \
+  if (n##DERIVED##s > 0) {                                                     \
+    totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl));                \
+    llvm::errs() << "    " << n##DERIVED##s << " " #DERIVED " decls, "         \
+                 << sizeof(DERIVED##Decl) << " each ("                         \
+                 << n##DERIVED##s * sizeof(DERIVED##Decl) << " bytes)\n";      \
   }
 #define ABSTRACT_DECL(DECL)
 #include "clang/AST/DeclNodes.inc"
@@ -192,24 +194,27 @@
 
 void Decl::add(Kind k) {
   switch (k) {
-#define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break;
+#define DECL(DERIVED, BASE)                                                    \
+  case DERIVED:                                                                \
+    ++n##DERIVED##s;                                                           \
+    break;
 #define ABSTRACT_DECL(DECL)
 #include "clang/AST/DeclNodes.inc"
   }
 }
 
 bool Decl::isTemplateParameterPack() const {
-  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(this))
+  if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(this))
     return TTP->isParameterPack();
-  if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(this))
+  if (auto const *NTTP = dyn_cast<NonTypeTemplateParmDecl>(this))
     return NTTP->isParameterPack();
-  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(this))
+  if (auto const *TTP = dyn_cast<TemplateTemplateParmDecl>(this))
     return TTP->isParameterPack();
   return false;
 }
 
 bool Decl::isParameterPack() const {
-  if (const auto *Var = dyn_cast<VarDecl>(this))
+  if (auto const *Var = dyn_cast<VarDecl>(this))
     return Var->isParameterPack();
 
   return isTemplateParameterPack();
@@ -218,14 +223,12 @@
 FunctionDecl *Decl::getAsFunction() {
   if (auto *FD = dyn_cast<FunctionDecl>(this))
     return FD;
-  if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(this))
+  if (auto const *FTD = dyn_cast<FunctionTemplateDecl>(this))
     return FTD->getTemplatedDecl();
   return nullptr;
 }
 
-bool Decl::isTemplateDecl() const {
-  return isa<TemplateDecl>(this);
-}
+bool Decl::isTemplateDecl() const { return isa<TemplateDecl>(this); }
 
 TemplateDecl *Decl::getDescribedTemplate() const {
   if (auto *FD = dyn_cast<FunctionDecl>(this))
@@ -240,7 +243,7 @@
   return nullptr;
 }
 
-const TemplateParameterList *Decl::getDescribedTemplateParams() const {
+TemplateParameterList const *Decl::getDescribedTemplateParams() const {
   if (auto *TD = getDescribedTemplate())
     return TD->getTemplateParameters();
   if (auto *CTPSD = dyn_cast<ClassTemplatePartialSpecializationDecl>(this))
@@ -278,13 +281,13 @@
     if (Decl *Context = RD->getLambdaContextDecl())
       return Context->getTemplateDepth();
 
-  const DeclContext *DC =
+  DeclContext const *DC =
       getFriendObjectKind() ? getLexicalDeclContext() : getDeclContext();
   return cast<Decl>(DC)->getTemplateDepth();
 }
 
-const DeclContext *Decl::getParentFunctionOrMethod() const {
-  for (const DeclContext *DC = getDeclContext();
+DeclContext const *Decl::getParentFunctionOrMethod() const {
+  for (DeclContext const *DC = getDeclContext();
        DC && !DC->isTranslationUnit() && !DC->isNamespace();
        DC = DC->getParent())
     if (DC->isFunctionOrMethod())
@@ -309,7 +312,7 @@
 
   OS << Message;
 
-  if (const auto *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) {
+  if (auto const *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) {
     OS << " '";
     DN->printQualifiedName(OS);
     OS << '\'';
@@ -324,9 +327,7 @@
 // Out-of-line virtual method providing a home for Decl.
 Decl::~Decl() = default;
 
-void Decl::setDeclContext(DeclContext *DC) {
-  DeclCtx = DC;
-}
+void Decl::setDeclContext(DeclContext *DC) { DeclCtx = DC; }
 
 void Decl::setLexicalDeclContext(DeclContext *DC) {
   if (DC == getLexicalDeclContext())
@@ -365,7 +366,7 @@
 }
 
 bool Decl::isInLocalScopeForInstantiation() const {
-  const DeclContext *LDC = getLexicalDeclContext();
+  DeclContext const *LDC = getLexicalDeclContext();
   if (!LDC->isDependentContext())
     return false;
   while (true) {
@@ -373,7 +374,7 @@
       return true;
     if (!isa<TagDecl>(LDC))
       return false;
-    if (const auto *CRD = dyn_cast<CXXRecordDecl>(LDC))
+    if (auto const *CRD = dyn_cast<CXXRecordDecl>(LDC))
       if (CRD->isLambda())
         return true;
     LDC = LDC->getLexicalParent();
@@ -382,8 +383,8 @@
 }
 
 bool Decl::isInAnonymousNamespace() const {
-  for (const DeclContext *DC = getDeclContext(); DC; DC = DC->getParent()) {
-    if (const auto *ND = dyn_cast<NamespaceDecl>(DC))
+  for (DeclContext const *DC = getDeclContext(); DC; DC = DC->getParent()) {
+    if (auto const *ND = dyn_cast<NamespaceDecl>(DC))
       if (ND->isAnonymousNamespace())
         return true;
   }
@@ -392,7 +393,7 @@
 }
 
 bool Decl::isInStdNamespace() const {
-  const DeclContext *DC = getDeclContext();
+  DeclContext const *DC = getDeclContext();
   return DC && DC->isStdNamespace();
 }
 
@@ -417,7 +418,7 @@
 
 /// Helper to get the language options from the ASTContext.
 /// Defined out of line to avoid depending on ASTContext.h.
-const LangOptions &Decl::getLangOpts() const {
+LangOptions const &Decl::getLangOpts() const {
   return getASTContext().getLangOpts();
 }
 
@@ -430,7 +431,7 @@
     return 0;
 
   unsigned Align = 0;
-  const AttrVec &V = getAttrs();
+  AttrVec const &V = getAttrs();
   ASTContext &Ctx = getASTContext();
   specific_attr_iterator<AlignedAttr> I(V.begin()), E(V.end());
   for (; I != E; ++I) {
@@ -441,7 +442,7 @@
 }
 
 bool Decl::isUsed(bool CheckUsedAttr) const {
-  const Decl *CanonD = getCanonicalDecl();
+  Decl const *CanonD = getCanonicalDecl();
   if (CanonD->Used)
     return true;
 
@@ -470,7 +471,7 @@
     return true;
 
   // Check redeclarations.
-  for (const auto *I : redecls())
+  for (auto const *I : redecls())
     if (I->Referenced)
       return true;
 
@@ -478,7 +479,7 @@
 }
 
 ExternalSourceSymbolAttr *Decl::getExternalSourceSymbolAttr() const {
-  const Decl *Definition = nullptr;
+  Decl const *Definition = nullptr;
   if (auto *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
     Definition = ID->getDefinition();
   } else if (auto *PD = dyn_cast<ObjCProtocolDecl>(this)) {
@@ -503,7 +504,7 @@
          hasAttr<LoaderUninitializedAttr>();
 }
 
-const Attr *Decl::getDefiningAttr() const {
+Attr const *Decl::getDefiningAttr() const {
   if (auto *AA = getAttr<AliasAttr>())
     return AA;
   if (auto *IFA = getAttr<IFuncAttr>())
@@ -513,8 +514,8 @@
   return nullptr;
 }
 
-static StringRef getRealizedPlatform(const AvailabilityAttr *A,
-                                     const ASTContext &Context) {
+static StringRef getRealizedPlatform(AvailabilityAttr const *A,
+                                     ASTContext const &Context) {
   // Check if this is an App Extension "platform", and if so chop off
   // the suffix for matching with the actual platform.
   StringRef RealizedPlatform = A->getPlatform()->getName();
@@ -536,7 +537,7 @@
 /// FIXME: Make these strings localizable, since they end up in
 /// diagnostics.
 static AvailabilityResult CheckAvailability(ASTContext &Context,
-                                            const AvailabilityAttr *A,
+                                            AvailabilityAttr const *A,
                                             std::string *Message,
                                             VersionTuple EnclosingVersion) {
   if (EnclosingVersion.empty())
@@ -552,8 +553,8 @@
   if (getRealizedPlatform(A, Context) != TargetPlatform)
     return AR_Available;
 
-  StringRef PrettyPlatformName
-    = AvailabilityAttr::getPrettyPlatformName(ActualPlatform);
+  StringRef PrettyPlatformName =
+      AvailabilityAttr::getPrettyPlatformName(ActualPlatform);
 
   if (PrettyPlatformName.empty())
     PrettyPlatformName = ActualPlatform;
@@ -569,22 +570,20 @@
     if (Message) {
       Message->clear();
       llvm::raw_string_ostream Out(*Message);
-      Out << "not available on " << PrettyPlatformName
-          << HintMessage;
+      Out << "not available on " << PrettyPlatformName << HintMessage;
     }
 
     return AR_Unavailable;
   }
 
   // Make sure that this declaration has already been introduced.
-  if (!A->getIntroduced().empty() &&
-      EnclosingVersion < A->getIntroduced()) {
+  if (!A->getIntroduced().empty() && EnclosingVersion < A->getIntroduced()) {
     if (Message) {
       Message->clear();
       llvm::raw_string_ostream Out(*Message);
       VersionTuple VTI(A->getIntroduced());
-      Out << "introduced in " << PrettyPlatformName << ' '
-          << VTI << HintMessage;
+      Out << "introduced in " << PrettyPlatformName << ' ' << VTI
+          << HintMessage;
     }
 
     return A->getStrict() ? AR_Unavailable : AR_NotYetIntroduced;
@@ -596,8 +595,7 @@
       Message->clear();
       llvm::raw_string_ostream Out(*Message);
       VersionTuple VTO(A->getObsoleted());
-      Out << "obsoleted in " << PrettyPlatformName << ' '
-          << VTO << HintMessage;
+      Out << "obsoleted in " << PrettyPlatformName << ' ' << VTO << HintMessage;
     }
 
     return AR_Unavailable;
@@ -609,8 +607,8 @@
       Message->clear();
       llvm::raw_string_ostream Out(*Message);
       VersionTuple VTD(A->getDeprecated());
-      Out << "first deprecated in " << PrettyPlatformName << ' '
-          << VTD << HintMessage;
+      Out << "first deprecated in " << PrettyPlatformName << ' ' << VTD
+          << HintMessage;
     }
 
     return AR_Deprecated;
@@ -629,8 +627,8 @@
   AvailabilityResult Result = AR_Available;
   std::string ResultMessage;
 
-  for (const auto *A : attrs()) {
-    if (const auto *Deprecated = dyn_cast<DeprecatedAttr>(A)) {
+  for (auto const *A : attrs()) {
+    if (auto const *Deprecated = dyn_cast<DeprecatedAttr>(A)) {
       if (Result >= AR_Deprecated)
         continue;
 
@@ -641,13 +639,13 @@
       continue;
     }
 
-    if (const auto *Unavailable = dyn_cast<UnavailableAttr>(A)) {
+    if (auto const *Unavailable = dyn_cast<UnavailableAttr>(A)) {
       if (Message)
         *Message = std::string(Unavailable->getMessage());
       return AR_Unavailable;
     }
 
-    if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
+    if (auto const *Availability = dyn_cast<AvailabilityAttr>(A)) {
       AvailabilityResult AR = CheckAvailability(getASTContext(), Availability,
                                                 Message, EnclosingVersion);
 
@@ -672,10 +670,10 @@
 }
 
 VersionTuple Decl::getVersionIntroduced() const {
-  const ASTContext &Context = getASTContext();
+  ASTContext const &Context = getASTContext();
   StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
-  for (const auto *A : attrs()) {
-    if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
+  for (auto const *A : attrs()) {
+    if (auto const *Availability = dyn_cast<AvailabilityAttr>(A)) {
       if (getRealizedPlatform(Availability, Context) != TargetPlatform)
         continue;
       if (!Availability->getIntroduced().empty())
@@ -689,7 +687,7 @@
   IsDefinition = false;
 
   // Variables, if they aren't definitions.
-  if (const auto *Var = dyn_cast<VarDecl>(this)) {
+  if (auto const *Var = dyn_cast<VarDecl>(this)) {
     if (Var->isThisDeclarationADefinition()) {
       IsDefinition = true;
       return false;
@@ -697,17 +695,16 @@
     return true;
   }
   // Functions, if they aren't definitions.
-  if (const auto *FD = dyn_cast<FunctionDecl>(this)) {
+  if (auto const *FD = dyn_cast<FunctionDecl>(this)) {
     if (FD->hasBody()) {
       IsDefinition = true;
       return false;
     }
     return true;
-
   }
   // Objective-C classes, if this is the non-fragile runtime.
   if (isa<ObjCInterfaceDecl>(this) &&
-             getASTContext().getLangOpts().ObjCRuntime.hasWeakClassImport()) {
+      getASTContext().getLangOpts().ObjCRuntime.hasWeakClassImport()) {
     return true;
   }
   // Nothing else.
@@ -719,11 +716,11 @@
   if (!canBeWeakImported(IsDefinition))
     return false;
 
-  for (const auto *A : getMostRecentDecl()->attrs()) {
+  for (auto const *A : getMostRecentDecl()->attrs()) {
     if (isa<WeakImportAttr>(A))
       return true;
 
-    if (const auto *Availability = dyn_cast<AvailabilityAttr>(A)) {
+    if (auto const *Availability = dyn_cast<AvailabilityAttr>(A)) {
       if (CheckAvailability(getASTContext(), Availability, nullptr,
                             VersionTuple()) == AR_NotYetIntroduced)
         return true;
@@ -735,137 +732,137 @@
 
 unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {
   switch (DeclKind) {
-    case Function:
-    case CXXDeductionGuide:
-    case CXXMethod:
-    case CXXConstructor:
-    case ConstructorUsingShadow:
-    case CXXDestructor:
-    case CXXConversion:
-    case EnumConstant:
-    case Var:
-    case ImplicitParam:
-    case ParmVar:
-    case ObjCMethod:
-    case ObjCProperty:
-    case MSProperty:
-      return IDNS_Ordinary;
-    case Label:
-      return IDNS_Label;
-    case IndirectField:
-      return IDNS_Ordinary | IDNS_Member;
-
-    case Binding:
-    case NonTypeTemplateParm:
-    case VarTemplate:
-    case Concept:
-      // These (C++-only) declarations are found by redeclaration lookup for
-      // tag types, so we include them in the tag namespace.
-      return IDNS_Ordinary | IDNS_Tag;
-
-    case ObjCCompatibleAlias:
-    case ObjCInterface:
-      return IDNS_Ordinary | IDNS_Type;
-
-    case Typedef:
-    case TypeAlias:
-    case TemplateTypeParm:
-    case ObjCTypeParam:
-      return IDNS_Ordinary | IDNS_Type;
-
-    case UnresolvedUsingTypename:
-      return IDNS_Ordinary | IDNS_Type | IDNS_Using;
-
-    case UsingShadow:
-      return 0; // we'll actually overwrite this later
-
-    case UnresolvedUsingValue:
-      return IDNS_Ordinary | IDNS_Using;
-
-    case Using:
-    case UsingPack:
-    case UsingEnum:
-      return IDNS_Using;
-
-    case ObjCProtocol:
-      return IDNS_ObjCProtocol;
-
-    case Field:
-    case ObjCAtDefsField:
-    case ObjCIvar:
-      return IDNS_Member;
-
-    case Record:
-    case CXXRecord:
-    case Enum:
-      return IDNS_Tag | IDNS_Type;
-
-    case Namespace:
-    case NamespaceAlias:
-      return IDNS_Namespace;
-
-    case FunctionTemplate:
-      return IDNS_Ordinary;
-
-    case ClassTemplate:
-    case TemplateTemplateParm:
-    case TypeAliasTemplate:
-      return IDNS_Ordinary | IDNS_Tag | IDNS_Type;
-
-    case UnresolvedUsingIfExists:
-      return IDNS_Type | IDNS_Ordinary;
-
-    case OMPDeclareReduction:
-      return IDNS_OMPReduction;
-
-    case OMPDeclareMapper:
-      return IDNS_OMPMapper;
-
-    // Never have names.
-    case Friend:
-    case FriendTemplate:
-    case AccessSpec:
-    case LinkageSpec:
-    case Export:
-    case FileScopeAsm:
-    case StaticAssert:
-    case ObjCPropertyImpl:
-    case PragmaComment:
-    case PragmaDetectMismatch:
-    case Block:
-    case Captured:
-    case TranslationUnit:
-    case ExternCContext:
-    case Decomposition:
-    case MSGuid:
-    case TemplateParamObject:
-
-    case UsingDirective:
-    case BuiltinTemplate:
-    case ClassTemplateSpecialization:
-    case ClassTemplatePartialSpecialization:
-    case ClassScopeFunctionSpecialization:
-    case VarTemplateSpecialization:
-    case VarTemplatePartialSpecialization:
-    case ObjCImplementation:
-    case ObjCCategory:
-    case ObjCCategoryImpl:
-    case Import:
-    case OMPThreadPrivate:
-    case OMPAllocate:
-    case OMPRequires:
-    case OMPCapturedExpr:
-    case Empty:
-    case LifetimeExtendedTemporary:
-    case RequiresExprBody:
-      // Never looked up by name.
-      return 0;
+  case Function:
+  case CXXDeductionGuide:
+  case CXXMethod:
+  case CXXConstructor:
+  case ConstructorUsingShadow:
+  case CXXDestructor:
+  case CXXConversion:
+  case EnumConstant:
+  case Var:
+  case ImplicitParam:
+  case ParmVar:
+  case ObjCMethod:
+  case ObjCProperty:
+  case MSProperty:
+    return IDNS_Ordinary;
+  case Label:
+    return IDNS_Label;
+  case IndirectField:
+    return IDNS_Ordinary | IDNS_Member;
+
+  case Binding:
+  case NonTypeTemplateParm:
+  case VarTemplate:
+  case Concept:
+    // These (C++-only) declarations are found by redeclaration lookup for
+    // tag types, so we include them in the tag namespace.
+    return IDNS_Ordinary | IDNS_Tag;
+
+  case ObjCCompatibleAlias:
+  case ObjCInterface:
+    return IDNS_Ordinary | IDNS_Type;
+
+  case Typedef:
+  case TypeAlias:
+  case TemplateTypeParm:
+  case ObjCTypeParam:
+    return IDNS_Ordinary | IDNS_Type;
+
+  case UnresolvedUsingTypename:
+    return IDNS_Ordinary | IDNS_Type | IDNS_Using;
+
+  case UsingShadow:
+    return 0; // we'll actually overwrite this later
+
+  case UnresolvedUsingValue:
+    return IDNS_Ordinary | IDNS_Using;
+
+  case Using:
+  case UsingPack:
+  case UsingEnum:
+    return IDNS_Using;
+
+  case ObjCProtocol:
+    return IDNS_ObjCProtocol;
+
+  case Field:
+  case ObjCAtDefsField:
+  case ObjCIvar:
+    return IDNS_Member;
+
+  case Record:
+  case CXXRecord:
+  case Enum:
+    return IDNS_Tag | IDNS_Type;
+
+  case Namespace:
+  case NamespaceAlias:
+    return IDNS_Namespace;
+
+  case FunctionTemplate:
+    return IDNS_Ordinary;
+
+  case ClassTemplate:
+  case TemplateTemplateParm:
+  case TypeAliasTemplate:
+    return IDNS_Ordinary | IDNS_Tag | IDNS_Type;
+
+  case UnresolvedUsingIfExists:
+    return IDNS_Type | IDNS_Ordinary;
+
+  case OMPDeclareReduction:
+    return IDNS_OMPReduction;
+
+  case OMPDeclareMapper:
+    return IDNS_OMPMapper;
+
+  // Never have names.
+  case Friend:
+  case FriendTemplate:
+  case AccessSpec:
+  case LinkageSpec:
+  case Export:
+  case FileScopeAsm:
+  case StaticAssert:
+  case ObjCPropertyImpl:
+  case PragmaComment:
+  case PragmaDetectMismatch:
+  case Block:
+  case Captured:
+  case TranslationUnit:
+  case ExternCContext:
+  case Decomposition:
+  case MSGuid:
+  case TemplateParamObject:
+
+  case UsingDirective:
+  case BuiltinTemplate:
+  case ClassTemplateSpecialization:
+  case ClassTemplatePartialSpecialization:
+  case ClassScopeFunctionSpecialization:
+  case VarTemplateSpecialization:
+  case VarTemplatePartialSpecialization:
+  case ObjCImplementation:
+  case ObjCCategory:
+  case ObjCCategoryImpl:
+  case Import:
+  case OMPThreadPrivate:
+  case OMPAllocate:
+  case OMPRequires:
+  case OMPCapturedExpr:
+  case Empty:
+  case LifetimeExtendedTemporary:
+  case RequiresExprBody:
+    // Never looked up by name.
+    return 0;
   }
 
   llvm_unreachable("Invalid DeclKind!");
 }
 
-void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) {
+void Decl::setAttrsImpl(AttrVec const &attrs, ASTContext &Ctx) {
   assert(!HasAttrs && "Decl already contains attrs.");
 
   AttrVec &AttrBlank = Ctx.getDeclAttrs(this);
@@ -876,7 +873,8 @@
 }
 
 void Decl::dropAttrs() {
-  if (!HasAttrs) return;
+  if (!HasAttrs)
+    return;
 
   HasAttrs = false;
   getASTContext().eraseDeclAttrs(this);
@@ -905,54 +903,54 @@
   Attrs.insert(I, A);
 }
 
-const AttrVec &Decl::getAttrs() const {
+AttrVec const &Decl::getAttrs() const {
   assert(HasAttrs && "No attrs to get!");
   return getASTContext().getDeclAttrs(this);
 }
 
-Decl *Decl::castFromDeclContext (const DeclContext *D) {
+Decl *Decl::castFromDeclContext(DeclContext const *D) {
   Decl::Kind DK = D->getDeclKind();
-  switch(DK) {
+  switch (DK) {
 #define DECL(NAME, BASE)
-#define DECL_CONTEXT(NAME) \
-    case Decl::NAME:       \
-      return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));
+#define DECL_CONTEXT(NAME)                                                     \
+  case Decl::NAME:                                                             \
+    return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));
 #define DECL_CONTEXT_BASE(NAME)
 #include "clang/AST/DeclNodes.inc"
-    default:
+  default:
 #define DECL(NAME, BASE)
-#define DECL_CONTEXT_BASE(NAME)                  \
-      if (DK >= first##NAME && DK <= last##NAME) \
-        return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));
+#define DECL_CONTEXT_BASE(NAME)                                                \
+  if (DK >= first##NAME && DK <= last##NAME)                                   \
+    return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));
 #include "clang/AST/DeclNodes.inc"
-      llvm_unreachable("a decl that inherits DeclContext isn't handled");
+    llvm_unreachable("a decl that inherits DeclContext isn't handled");
   }
 }
 
-DeclContext *Decl::castToDeclContext(const Decl *D) {
+DeclContext *Decl::castToDeclContext(Decl const *D) {
   Decl::Kind DK = D->getKind();
-  switch(DK) {
+  switch (DK) {
 #define DECL(NAME, BASE)
-#define DECL_CONTEXT(NAME) \
-    case Decl::NAME:       \
-      return static_cast<NAME##Decl *>(const_cast<Decl *>(D));
+#define DECL_CONTEXT(NAME)                                                     \
+  case Decl::NAME:                                                             \
+    return static_cast<NAME##Decl *>(const_cast<Decl *>(D));
 #define DECL_CONTEXT_BASE(NAME)
 #include "clang/AST/DeclNodes.inc"
-    default:
+  default:
 #define DECL(NAME, BASE)
-#define DECL_CONTEXT_BASE(NAME)                                   \
-      if (DK >= first##NAME && DK <= last##NAME)                  \
-        return static_cast<NAME##Decl *>(const_cast<Decl *>(D));
+#define DECL_CONTEXT_BASE(NAME)                                                \
+  if (DK >= first##NAME && DK <= last##NAME)                                   \
+    return static_cast<NAME##Decl *>(const_cast<Decl *>(D));
 #include "clang/AST/DeclNodes.inc"
-      llvm_unreachable("a decl that inherits DeclContext isn't handled");
+    llvm_unreachable("a decl that inherits DeclContext isn't handled");
   }
 }
 
 SourceLocation Decl::getBodyRBrace() const {
   // Special handling of FunctionDecl to avoid de-serializing the body from PCH.
   // FunctionDecl stores EndRangeLoc for this purpose.
-  if (const auto *FD = dyn_cast<FunctionDecl>(this)) {
-    const FunctionDecl *Definition;
+  if (auto const *FD = dyn_cast<FunctionDecl>(this)) {
+    FunctionDecl const *Definition;
     if (FD->hasBody(Definition))
       return Definition->getSourceRange().getEnd();
     return {};
@@ -995,18 +993,18 @@
   return true;
 }
 
-static Decl::Kind getKind(const Decl *D) { return D->getKind(); }
-static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); }
+static Decl::Kind getKind(Decl const *D) { return D->getKind(); }
+static Decl::Kind getKind(DeclContext const *DC) { return DC->getDeclKind(); }
 
 int64_t Decl::getID() const {
   return getASTContext().getAllocator().identifyKnownAlignedObject<Decl>(this);
 }
 
-const FunctionType *Decl::getFunctionType(bool BlocksToo) const {
+FunctionType const *Decl::getFunctionType(bool BlocksToo) const {
   QualType Ty;
-  if (const auto *D = dyn_cast<ValueDecl>(this))
+  if (auto const *D = dyn_cast<ValueDecl>(this))
     Ty = D->getType();
-  else if (const auto *D = dyn_cast<TypedefNameDecl>(this))
+  else if (auto const *D = dyn_cast<TypedefNameDecl>(this))
     Ty = D->getUnderlyingType();
   else
     return nullptr;
@@ -1026,8 +1024,7 @@
 template <class T> static Decl *getNonClosureContext(T *D) {
   if (getKind(D) == Decl::CXXMethod) {
     auto *MD = cast<CXXMethodDecl>(D);
-    if (MD->getOverloadedOperator() == OO_Call &&
-        MD->getParent()->isLambda())
+    if (MD->getOverloadedOperator() == OO_Call && MD->getParent()->isLambda())
       return getNonClosureContext(MD->getParent()->getParent());
     return MD;
   }
@@ -1042,9 +1039,7 @@
   return nullptr;
 }
 
-Decl *Decl::getNonClosureContext() {
-  return ::getNonClosureContext(this);
-}
+Decl *Decl::getNonClosureContext() { return ::getNonClosureContext(this); }
 
 Decl *DeclContext::getNonClosureAncestor() {
   return ::getNonClosureContext(this);
@@ -1064,21 +1059,20 @@
   setUseQualifiedLookup(false);
 }
 
-bool DeclContext::classof(const Decl *D) {
+bool DeclContext::classof(Decl const *D) {
   switch (D->getKind()) {
 #define DECL(NAME, BASE)
 #define DECL_CONTEXT(NAME) case Decl::NAME:
 #define DECL_CONTEXT_BASE(NAME)
 #include "clang/AST/DeclNodes.inc"
-      return true;
-    default:
+    return true;
+  default:
 #define DECL(NAME, BASE)
-#define DECL_CONTEXT_BASE(NAME)                 \
-      if (D->getKind() >= Decl::first##NAME &&  \
-          D->getKind() <= Decl::last##NAME)     \
-        return true;
+#define DECL_CONTEXT_BASE(NAME)                                                \
+  if (D->getKind() >= Decl::first##NAME && D->getKind() <= Decl::last##NAME)   \
+    return true;
 #include "clang/AST/DeclNodes.inc"
-      return false;
+    return false;
   }
 }
 
@@ -1106,8 +1100,8 @@
   return getParent();
 }
 
-const BlockDecl *DeclContext::getInnermostBlockDecl() const {
-  const DeclContext *Ctx = this;
+BlockDecl const *DeclContext::getInnermostBlockDecl() const {
+  DeclContext const *Ctx = this;
 
   do {
     if (Ctx->isClosure())
@@ -1119,15 +1113,14 @@
 }
 
 bool DeclContext::isInlineNamespace() const {
-  return isNamespace() &&
-         cast<NamespaceDecl>(this)->isInline();
+  return isNamespace() && cast<NamespaceDecl>(this)->isInline();
 }
 
 bool DeclContext::isStdNamespace() const {
   if (!isNamespace())
     return false;
 
-  const auto *ND = cast<NamespaceDecl>(this);
+  auto const *ND = cast<NamespaceDecl>(this);
   if (ND->isInline()) {
     return ND->getParent()->isStdNamespace();
   }
@@ -1135,7 +1128,7 @@
   if (!getParent()->getRedeclContext()->isTranslationUnit())
     return false;
 
-  const IdentifierInfo *II = ND->getIdentifier();
+  IdentifierInfo const *II = ND->getIdentifier();
   return II && II->isStr("std");
 }
 
@@ -1146,7 +1139,7 @@
   if (isa<ClassTemplatePartialSpecializationDecl>(this))
     return true;
 
-  if (const auto *Record = dyn_cast<CXXRecordDecl>(this)) {
+  if (auto const *Record = dyn_cast<CXXRecordDecl>(this)) {
     if (Record->getDescribedClassTemplate())
       return true;
 
@@ -1154,7 +1147,7 @@
       return true;
   }
 
-  if (const auto *Function = dyn_cast<FunctionDecl>(this)) {
+  if (auto const *Function = dyn_cast<FunctionDecl>(this)) {
     if (Function->getDescribedFunctionTemplate())
       return true;
 
@@ -1178,7 +1171,7 @@
   return getDeclKind() == Decl::LinkageSpec || getDeclKind() == Decl::Export;
 }
 
-static bool isLinkageSpecContext(const DeclContext *DC,
+static bool isLinkageSpecContext(DeclContext const *DC,
                                  LinkageSpecDecl::LanguageIDs ID) {
   while (DC->getDeclKind() != Decl::TranslationUnit) {
     if (DC->getDeclKind() == Decl::LinkageSpec)
@@ -1192,8 +1185,8 @@
   return isLinkageSpecContext(this, LinkageSpecDecl::lang_c);
 }
 
-const LinkageSpecDecl *DeclContext::getExternCContext() const {
-  const DeclContext *DC = this;
+LinkageSpecDecl const *DeclContext::getExternCContext() const {
+  DeclContext const *DC = this;
   while (DC->getDeclKind() != Decl::TranslationUnit) {
     if (DC->getDeclKind() == Decl::LinkageSpec &&
         cast<LinkageSpecDecl>(DC)->getLanguage() == LinkageSpecDecl::lang_c)
@@ -1207,7 +1200,7 @@
   return isLinkageSpecContext(this, LinkageSpecDecl::lang_cxx);
 }
 
-bool DeclContext::Encloses(const DeclContext *DC) const {
+bool DeclContext::Encloses(DeclContext const *DC) const {
   if (getPrimaryContext() != this)
     return getPrimaryContext()->Encloses(DC);
 
@@ -1276,7 +1269,7 @@
       if (TagDecl *Def = Tag->getDefinition())
         return Def;
 
-      if (const auto *TagTy = dyn_cast<TagType>(Tag->getTypeForDecl())) {
+      if (auto const *TagTy = dyn_cast<TagType>(Tag->getTypeForDecl())) {
         // Note, TagType::getDecl returns the (partial) definition one exists.
         TagDecl *PossiblePartialDef = TagTy->getDecl();
         if (PossiblePartialDef->isBeingDefined())
@@ -1289,8 +1282,7 @@
     }
 
     assert(getDeclKind() >= Decl::firstFunction &&
-           getDeclKind() <= Decl::lastFunction &&
-          "Unknown DeclContext kind");
+           getDeclKind() <= Decl::lastFunction && "Unknown DeclContext kind");
     return this;
   }
 }
@@ -1317,8 +1309,7 @@
 }
 
 std::pair<Decl *, Decl *>
-DeclContext::BuildDeclChain(ArrayRef<Decl *> Decls,
-                            bool FieldsAlreadyLoaded) {
+DeclContext::BuildDeclChain(ArrayRef<Decl *> Decls, bool FieldsAlreadyLoaded) {
   // Build up a chain of declarations via the Decl::NextInContextAndBits field.
   Decl *FirstNewDecl = nullptr;
   Decl *PrevDecl = nullptr;
@@ -1351,8 +1342,7 @@
 /// Load the declarations within this lexical storage from an
 /// external source.
 /// \return \c true if any declarations were added.
-bool
-DeclContext::LoadLexicalDeclsFromExternalStorage() const {
+bool DeclContext::LoadLexicalDeclsFromExternalStorage() const {
   ExternalASTSource *Source = getParentASTContext().getExternalSource();
   assert(hasExternalLexicalStorage() && Source && "No external storage?");
 
@@ -1360,7 +1350,7 @@
   ExternalASTSource::Deserializing ADeclContext(Source);
 
   // Load the external declarations, if any.
-  SmallVector<Decl*, 64> Decls;
+  SmallVector<Decl *, 64> Decls;
   setHasExternalLexicalStorage(false);
   Source->FindExternalLexicalDecls(this, Decls);
 
@@ -1370,7 +1360,7 @@
   // We may have already loaded just the fields of this record, in which case
   // we need to ignore them.
   bool FieldsAlreadyLoaded = false;
-  if (const auto *RD = dyn_cast<RecordDecl>(this))
+  if (auto const *RD = dyn_cast<RecordDecl>(this))
     FieldsAlreadyLoaded = RD->hasLoadedFieldsFromExternalStorage();
 
   // Splice the newly-read declarations into the beginning of the list
@@ -1386,7 +1376,7 @@
 }
 
 DeclContext::lookup_result
-ExternalASTSource::SetNoExternalVisibleDeclsForName(const DeclContext *DC,
+ExternalASTSource::SetNoExternalVisibleDeclsForName(DeclContext const *DC,
                                                     DeclarationName Name) {
   ASTContext &Context = DC->getParentASTContext();
   StoredDeclsMap *Map;
@@ -1400,10 +1390,8 @@
   return DeclContext::lookup_result();
 }
 
-DeclContext::lookup_result
-ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC,
-                                                  DeclarationName Name,
-                                                  ArrayRef<NamedDecl*> Decls) {
+DeclContext::lookup_result ExternalASTSource::SetExternalVisibleDeclsForName(
+    DeclContext const *DC, DeclarationName Name, ArrayRef<NamedDecl *> Decls) {
   ASTContext &Context = DC->getParentASTContext();
   StoredDeclsMap *Map;
   if (!(Map = DC->LookupPtr))
@@ -1495,8 +1483,10 @@
     for (Decl *I = FirstDecl; true; I = I->NextInContextAndBits.getPointer()) {
       assert(I && "decl not found in linked list");
       if (I->NextInContextAndBits.getPointer() == D) {
-        I->NextInContextAndBits.setPointer(D->NextInContextAndBits.getPointer());
-        if (D == LastDecl) LastDecl = I;
+        I->NextInContextAndBits.setPointer(
+            D->NextInContextAndBits.getPointer());
+        if (D == LastDecl)
+          LastDecl = I;
         break;
       }
     }
@@ -1560,16 +1550,18 @@
   addHiddenDecl(D);
 
   if (auto *ND = dyn_cast<NamedDecl>(D))
-    ND->getDeclContext()->getPrimaryContext()->
-        makeDeclVisibleInContextWithFlags(ND, false, true);
+    ND->getDeclContext()
+        ->getPrimaryContext()
+        ->makeDeclVisibleInContextWithFlags(ND, false, true);
 }
 
 void DeclContext::addDeclInternal(Decl *D) {
   addHiddenDecl(D);
 
   if (auto *ND = dyn_cast<NamedDecl>(D))
-    ND->getDeclContext()->getPrimaryContext()->
-        makeDeclVisibleInContextWithFlags(ND, true, true);
+    ND->getDeclContext()
+        ->getPrimaryContext()
+        ->makeDeclVisibleInContextWithFlags(ND, true, true);
 }
 
 /// buildLookup - Build the lookup data structure with all of the
@@ -1582,8 +1574,7 @@
 StoredDeclsMap *DeclContext::buildLookup() {
   assert(this == getPrimaryContext() && "buildLookup called on non-primary DC");
 
-  if (!hasLazyLocalLexicalLookups() &&
-      !hasLazyExternalLexicalLookups())
+  if (!hasLazyLocalLexicalLookups() && !hasLazyExternalLexicalLookups())
     return LookupPtr;
 
   SmallVector<DeclContext *, 2> Contexts;
@@ -1594,8 +1585,8 @@
     for (auto *DC : Contexts) {
       if (DC->hasExternalLexicalStorage()) {
         bool LoadedDecls = DC->LoadLexicalDeclsFromExternalStorage();
-        setHasLazyLocalLexicalLookups(
-            hasLazyLocalLexicalLookups() | LoadedDecls );
+        setHasLazyLocalLexicalLookups(hasLazyLocalLexicalLookups() |
+                                      LoadedDecls);
       }
     }
 
@@ -1641,13 +1632,11 @@
   }
 }
 
-DeclContext::lookup_result
-DeclContext::lookup(DeclarationName Name) const {
-  assert(getDeclKind() != Decl::LinkageSpec &&
-         getDeclKind() != Decl::Export &&
+DeclContext::lookup_result DeclContext::lookup(DeclarationName Name) const {
+  assert(getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export &&
          "should not perform lookups into transparent contexts");
 
-  const DeclContext *PrimaryContext = getPrimaryContext();
+  DeclContext const *PrimaryContext = getPrimaryContext();
   if (PrimaryContext != this)
     return PrimaryContext->lookup(Name);
 
@@ -1666,10 +1655,9 @@
 
     StoredDeclsMap *Map = LookupPtr;
 
-    if (hasLazyLocalLexicalLookups() ||
-        hasLazyExternalLexicalLookups())
+    if (hasLazyLocalLexicalLookups() || hasLazyExternalLexicalLookups())
       // FIXME: Make buildLookup const?
-      Map = const_cast<DeclContext*>(this)->buildLookup();
+      Map = const_cast<DeclContext *>(this)->buildLookup();
 
     if (!Map)
       Map = CreateStoredDeclsMap(getParentASTContext());
@@ -1692,9 +1680,8 @@
   }
 
   StoredDeclsMap *Map = LookupPtr;
-  if (hasLazyLocalLexicalLookups() ||
-      hasLazyExternalLexicalLookups())
-    Map = const_cast<DeclContext*>(this)->buildLookup();
+  if (hasLazyLocalLexicalLookups() || hasLazyExternalLexicalLookups())
+    Map = const_cast<DeclContext *>(this)->buildLookup();
 
   if (!Map)
     return {};
@@ -1706,10 +1693,8 @@
   return I->second.getLookupResult();
 }
 
-DeclContext::lookup_result
-DeclContext::noload_lookup(DeclarationName Name) {
-  assert(getDeclKind() != Decl::LinkageSpec &&
-         getDeclKind() != Decl::Export &&
+DeclContext::lookup_result DeclContext::noload_lookup(DeclarationName Name) {
+  assert(getDeclKind() != Decl::LinkageSpec && getDeclKind() != Decl::Export &&
          "should not perform lookups into transparent contexts");
 
   DeclContext *PrimaryContext = getPrimaryContext();
@@ -1722,8 +1707,7 @@
     return {};
 
   StoredDeclsMap::iterator I = Map->find(Name);
-  return I != Map->end() ? I->second.getLookupResult()
-                         : lookup_result();
+  return I != Map->end() ? I->second.getLookupResult() : lookup_result();
 }
 
 // If we have any lazy lexical declarations not in our lookup map, add them
@@ -1758,8 +1742,7 @@
     if (StoredDeclsMap *Map = LookupPtr) {
       StoredDeclsMap::iterator Pos = Map->find(Name);
       if (Pos != Map->end()) {
-        Results.insert(Results.end(),
-                       Pos->second.getLookupResult().begin(),
+        Results.insert(Results.end(), Pos->second.getLookupResult().begin(),
                        Pos->second.getLookupResult().end());
         return;
       }
@@ -1814,7 +1797,7 @@
   return OutermostRD;
 }
 
-bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const {
+bool DeclContext::InEnclosingNamespaceSetOf(DeclContext const *O) const {
   // For non-file contexts, this is equivalent to Equals.
   if (!isFileContext())
     return O->Equals(this);
@@ -1823,7 +1806,7 @@
     if (O->Equals(this))
       return true;
 
-    const auto *NS = dyn_cast<NamespaceDecl>(O);
+    auto const *NS = dyn_cast<NamespaceDecl>(O);
     if (!NS || !NS->isInline())
       break;
     O = NS->getParent();
@@ -1846,8 +1829,8 @@
 
   if (!isLookupContext()) {
     if (isTransparentContext())
-      getParent()->getPrimaryContext()
-        ->makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);
+      getParent()->getPrimaryContext()->makeDeclVisibleInContextWithFlags(
+          D, Internal, Recoverable);
     return;
   }
 
@@ -1879,8 +1862,8 @@
   // If we are a transparent context or inline namespace, insert into our
   // parent context, too. This operation is recursive.
   if (isTransparentContext() || isInlineNamespace())
-    getParent()->getPrimaryContext()->
-        makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);
+    getParent()->getPrimaryContext()->makeDeclVisibleInContextWithFlags(
+        D, Internal, Recoverable);
 
   auto *DCAsDecl = cast<Decl>(this);
   // Notify that a decl was made visible unless we are a Tag being defined.
@@ -1952,7 +1935,7 @@
   else
     M = new StoredDeclsMap();
   M->Previous = C.LastSDM;
-  C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent);
+  C.LastSDM = llvm::PointerIntPair<StoredDeclsMap *, 1>(M, Dependent);
   LookupPtr = M;
   return M;
 }
@@ -1967,10 +1950,10 @@
 void StoredDeclsMap::DestroyAll(StoredDeclsMap *Map, bool Dependent) {
   while (Map) {
     // Advance the iteration before we invalidate memory.
-    llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous;
+    llvm::PointerIntPair<StoredDeclsMap *, 1> Next = Map->Previous;
 
     if (Dependent)
-      delete static_cast<DependentStoredDeclsMap*>(Map);
+      delete static_cast<DependentStoredDeclsMap *>(Map);
     else
       delete Map;
 
@@ -1979,11 +1962,11 @@
   }
 }
 
-DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C,
-                                                 DeclContext *Parent,
-                                           const PartialDiagnostic &PDiag) {
-  assert(Parent->isDependentContext()
-         && "cannot iterate dependent diagnostics of non-dependent context");
+DependentDiagnostic *
+DependentDiagnostic::Create(ASTContext &C, DeclContext *Parent,
+                            PartialDiagnostic const &PDiag) {
+  assert(Parent->isDependentContext() &&
+         "cannot iterate dependent diagnostics of non-dependent context");
   Parent = Parent->getPrimaryContext();
   if (!Parent->LookupPtr)
     Parent->CreateStoredDeclsMap(C);
Index: clang/lib/AST/DeclCXX.cpp
===================================================================
--- clang/lib/AST/DeclCXX.cpp
+++ clang/lib/AST/DeclCXX.cpp
@@ -81,8 +81,7 @@
       HasPublicFields(false), HasMutableFields(false), HasVariantMembers(false),
       HasOnlyCMembers(true), HasInClassInitializer(false),
       HasUninitializedReferenceMember(false), HasUninitializedFields(false),
-      HasInheritedConstructor(false),
-      HasInheritedDefaultConstructor(false),
+      HasInheritedConstructor(false), HasInheritedDefaultConstructor(false),
       HasInheritedAssignment(false),
       NeedOverloadResolutionForCopyConstructor(false),
       NeedOverloadResolutionForMoveConstructor(false),
@@ -121,21 +120,20 @@
   return VBases.get(Definition->getASTContext().getExternalSource());
 }
 
-CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C,
+CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, ASTContext const &C,
                              DeclContext *DC, SourceLocation StartLoc,
                              SourceLocation IdLoc, IdentifierInfo *Id,
                              CXXRecordDecl *PrevDecl)
     : RecordDecl(K, TK, C, DC, StartLoc, IdLoc, Id, PrevDecl),
-      DefinitionData(PrevDecl ? PrevDecl->DefinitionData
-                              : nullptr) {}
+      DefinitionData(PrevDecl ? PrevDecl->DefinitionData : nullptr) {}
 
-CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK,
+CXXRecordDecl *CXXRecordDecl::Create(ASTContext const &C, TagKind TK,
                                      DeclContext *DC, SourceLocation StartLoc,
                                      SourceLocation IdLoc, IdentifierInfo *Id,
                                      CXXRecordDecl *PrevDecl,
                                      bool DelayTypeCreation) {
-  auto *R = new (C, DC) CXXRecordDecl(CXXRecord, TK, C, DC, StartLoc, IdLoc, Id,
-                                      PrevDecl);
+  auto *R = new (C, DC)
+      CXXRecordDecl(CXXRecord, TK, C, DC, StartLoc, IdLoc, Id, PrevDecl);
   R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
 
   // FIXME: DelayTypeCreation seems like such a hack
@@ -145,27 +143,26 @@
 }
 
 CXXRecordDecl *
-CXXRecordDecl::CreateLambda(const ASTContext &C, DeclContext *DC,
+CXXRecordDecl::CreateLambda(ASTContext const &C, DeclContext *DC,
                             TypeSourceInfo *Info, SourceLocation Loc,
                             bool Dependent, bool IsGeneric,
                             LambdaCaptureDefault CaptureDefault) {
-  auto *R = new (C, DC) CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc,
-                                      nullptr, nullptr);
+  auto *R = new (C, DC)
+      CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc, nullptr, nullptr);
   R->setBeingDefined(true);
-  R->DefinitionData =
-      new (C) struct LambdaDefinitionData(R, Info, Dependent, IsGeneric,
-                                          CaptureDefault);
+  R->DefinitionData = new (C) struct LambdaDefinitionData(
+      R, Info, Dependent, IsGeneric, CaptureDefault);
   R->setMayHaveOutOfDateDef(false);
   R->setImplicit(true);
   C.getTypeDeclType(R, /*PrevDecl=*/nullptr);
   return R;
 }
 
-CXXRecordDecl *
-CXXRecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
-  auto *R = new (C, ID) CXXRecordDecl(
-      CXXRecord, TTK_Struct, C, nullptr, SourceLocation(), SourceLocation(),
-      nullptr, nullptr);
+CXXRecordDecl *CXXRecordDecl::CreateDeserialized(ASTContext const &C,
+                                                 unsigned ID) {
+  auto *R = new (C, ID)
+      CXXRecordDecl(CXXRecord, TTK_Struct, C, nullptr, SourceLocation(),
+                    SourceLocation(), nullptr, nullptr);
   R->setMayHaveOutOfDateDef(false);
   return R;
 }
@@ -173,13 +170,13 @@
 /// Determine whether a class has a repeated base class. This is intended for
 /// use when determining if a class is standard-layout, so makes no attempt to
 /// handle virtual bases.
-static bool hasRepeatedBaseClass(const CXXRecordDecl *StartRD) {
-  llvm::SmallPtrSet<const CXXRecordDecl*, 8> SeenBaseTypes;
-  SmallVector<const CXXRecordDecl*, 8> WorkList = {StartRD};
+static bool hasRepeatedBaseClass(CXXRecordDecl const *StartRD) {
+  llvm::SmallPtrSet<CXXRecordDecl const *, 8> SeenBaseTypes;
+  SmallVector<CXXRecordDecl const *, 8> WorkList = {StartRD};
   while (!WorkList.empty()) {
-    const CXXRecordDecl *RD = WorkList.pop_back_val();
-    for (const CXXBaseSpecifier &BaseSpec : RD->bases()) {
-      if (const CXXRecordDecl *B = BaseSpec.getType()->getAsCXXRecordDecl()) {
+    CXXRecordDecl const *RD = WorkList.pop_back_val();
+    for (CXXBaseSpecifier const &BaseSpec : RD->bases()) {
+      if (CXXRecordDecl const *B = BaseSpec.getType()->getAsCXXRecordDecl()) {
         if (!SeenBaseTypes.insert(B).second)
           return true;
         WorkList.push_back(B);
@@ -189,9 +186,8 @@
   return false;
 }
 
-void
-CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
-                        unsigned NumBases) {
+void CXXRecordDecl::setBases(CXXBaseSpecifier const *const *Bases,
+                             unsigned NumBases) {
   ASTContext &C = getASTContext();
 
   if (!data().Bases.isOffset() && data().NumBases > 0)
@@ -213,14 +209,14 @@
   llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes;
 
   // The virtual bases of this class.
-  SmallVector<const CXXBaseSpecifier *, 8> VBases;
+  SmallVector<CXXBaseSpecifier const *, 8> VBases;
 
-  data().Bases = new(C) CXXBaseSpecifier [NumBases];
+  data().Bases = new (C) CXXBaseSpecifier[NumBases];
   data().NumBases = NumBases;
   for (unsigned i = 0; i < NumBases; ++i) {
     data().getBases()[i] = *Bases[i];
     // Keep track of inherited vbases for this base class.
-    const CXXBaseSpecifier *Base = Bases[i];
+    CXXBaseSpecifier const *Base = Bases[i];
     QualType BaseType = Base->getType();
     // Skip dependent types; we can't do any checking on them now.
     if (BaseType->isDependentType())
@@ -293,7 +289,7 @@
       data().HasNonLiteralTypeFieldsOrBases = true;
 
     // Now go through all virtual bases of this base and add them.
-    for (const auto &VBase : BaseClassDecl->vbases()) {
+    for (auto const &VBase : BaseClassDecl->vbases()) {
       // Add this base if it's not already in the list.
       if (SeenVBaseTypes.insert(C.getCanonicalType(VBase.getType())).second) {
         VBases.push_back(&VBase);
@@ -328,8 +324,8 @@
       data().Aggregate = false;
 
       // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
-      //   A [default constructor, copy/move constructor, or copy/move assignment
-      //   operator for a class X] is trivial [...] if:
+      //   A [default constructor, copy/move constructor, or copy/move
+      //   assignment operator for a class X] is trivial [...] if:
       //    -- class X has [...] no virtual base classes
       data().HasTrivialSpecialMembers &= SMF_Destructor;
       data().HasTrivialSpecialMembersForCall &= SMF_Destructor;
@@ -566,22 +562,27 @@
   if (!isDependentContext())
     return false;
 
-  return !forallBases([](const CXXRecordDecl *) { return true; });
+  return !forallBases([](CXXRecordDecl const *) { return true; });
 }
 
 bool CXXRecordDecl::isTriviallyCopyable() const {
   // C++0x [class]p5:
   //   A trivially copyable class is a class that:
   //   -- has no non-trivial copy constructors,
-  if (hasNonTrivialCopyConstructor()) return false;
+  if (hasNonTrivialCopyConstructor())
+    return false;
   //   -- has no non-trivial move constructors,
-  if (hasNonTrivialMoveConstructor()) return false;
+  if (hasNonTrivialMoveConstructor())
+    return false;
   //   -- has no non-trivial copy assignment operators,
-  if (hasNonTrivialCopyAssignment()) return false;
+  if (hasNonTrivialCopyAssignment())
+    return false;
   //   -- has no non-trivial move assignment operators, and
-  if (hasNonTrivialMoveAssignment()) return false;
+  if (hasNonTrivialMoveAssignment())
+    return false;
   //   -- has a trivial destructor.
-  if (!hasTrivialDestructor()) return false;
+  if (!hasTrivialDestructor())
+    return false;
 
   return true;
 }
@@ -593,16 +594,16 @@
 }
 
 bool CXXRecordDecl::hasSubobjectAtOffsetZeroOfEmptyBaseType(
-    ASTContext &Ctx, const CXXRecordDecl *XFirst) {
+    ASTContext &Ctx, CXXRecordDecl const *XFirst) {
   if (!getNumBases())
     return false;
 
-  llvm::SmallPtrSet<const CXXRecordDecl*, 8> Bases;
-  llvm::SmallPtrSet<const CXXRecordDecl*, 8> M;
-  SmallVector<const CXXRecordDecl*, 8> WorkList;
+  llvm::SmallPtrSet<CXXRecordDecl const *, 8> Bases;
+  llvm::SmallPtrSet<CXXRecordDecl const *, 8> M;
+  SmallVector<CXXRecordDecl const *, 8> WorkList;
 
   // Visit a type that we have determined is an element of M(S).
-  auto Visit = [&](const CXXRecordDecl *RD) -> bool {
+  auto Visit = [&](CXXRecordDecl const *RD) -> bool {
     RD = RD->getCanonicalDecl();
 
     // C++2a [class]p8:
@@ -639,7 +640,7 @@
     return true;
 
   while (!WorkList.empty()) {
-    const CXXRecordDecl *X = WorkList.pop_back_val();
+    CXXRecordDecl const *X = WorkList.pop_back_val();
 
     // FIXME: We don't check the bases of X. That matches the standard, but
     // that sure looks like a wording bug.
@@ -691,11 +692,9 @@
 }
 
 void CXXRecordDecl::addedMember(Decl *D) {
-  if (!D->isImplicit() &&
-      !isa<FieldDecl>(D) &&
-      !isa<IndirectFieldDecl>(D) &&
+  if (!D->isImplicit() && !isa<FieldDecl>(D) && !isa<IndirectFieldDecl>(D) &&
       (!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class ||
-        cast<TagDecl>(D)->getTagKind() == TTK_Interface))
+       cast<TagDecl>(D)->getTagKind() == TTK_Interface))
     data().HasOnlyCMembers = false;
 
   // Ignore friends and invalid declarations.
@@ -714,7 +713,7 @@
       DUnderlying = UnderlyingFunTmpl->getTemplatedDecl();
   }
 
-  if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
+  if (auto const *Method = dyn_cast<CXXMethodDecl>(D)) {
     if (Method->isVirtual()) {
       // C++ [dcl.init.aggr]p1:
       //   An aggregate is an array or a class with [...] no virtual functions.
@@ -758,7 +757,7 @@
   unsigned SMKind = 0;
 
   // Handle constructors.
-  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
+  if (auto const *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     if (Constructor->isInheritingConstructor()) {
       // Ignore constructor shadow declarations. They are lazily created and
       // so shouldn't affect any properties of the class.
@@ -811,7 +810,7 @@
   }
 
   // Handle constructors, including those inherited from base classes.
-  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(DUnderlying)) {
+  if (auto const *Constructor = dyn_cast<CXXConstructorDecl>(DUnderlying)) {
     // Record if we see any constexpr constructors which are neither copy
     // nor move constructors.
     // C++1z [basic.types]p10:
@@ -825,7 +824,7 @@
   }
 
   // Handle destructors.
-  if (const auto *DD = dyn_cast<CXXDestructorDecl>(D)) {
+  if (auto const *DD = dyn_cast<CXXDestructorDecl>(D)) {
     SMKind |= SMF_Destructor;
 
     if (DD->isUserProvided())
@@ -846,11 +845,11 @@
   }
 
   // Handle member functions.
-  if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
+  if (auto const *Method = dyn_cast<CXXMethodDecl>(D)) {
     if (Method->isCopyAssignmentOperator()) {
       SMKind |= SMF_CopyAssignment;
 
-      const auto *ParamTy =
+      auto const *ParamTy =
           Method->getParamDecl(0)->getType()->getAs<ReferenceType>();
       if (!ParamTy || ParamTy->getPointeeType().isConstQualified())
         data().HasDeclaredCopyAssignmentWithConstParam = true;
@@ -939,7 +938,7 @@
   }
 
   // Handle non-static data members.
-  if (const auto *Field = dyn_cast<FieldDecl>(D)) {
+  if (auto const *Field = dyn_cast<FieldDecl>(D)) {
     ASTContext &Context = getASTContext();
 
     // C++2a [class]p7:
@@ -997,10 +996,17 @@
     //    [...]
     //    -- has the same access control for all non-static data members,
     switch (D->getAccess()) {
-    case AS_private:    data().HasPrivateFields = true;   break;
-    case AS_protected:  data().HasProtectedFields = true; break;
-    case AS_public:     data().HasPublicFields = true;    break;
-    case AS_none:       llvm_unreachable("Invalid access specifier");
+    case AS_private:
+      data().HasPrivateFields = true;
+      break;
+    case AS_protected:
+      data().HasProtectedFields = true;
+      break;
+    case AS_public:
+      data().HasPublicFields = true;
+      break;
+    case AS_none:
+      llvm_unreachable("Invalid access specifier");
     };
     if ((data().HasPrivateFields + data().HasProtectedFields +
          data().HasPublicFields) > 1) {
@@ -1029,8 +1035,9 @@
     //   standard-layout class, and has no non-static data members of type
     //   non-POD struct, non-POD union (or array of such types).
     //
-    // Automatic Reference Counting: the presence of a member of Objective-C pointer type
-    // that does not explicitly have no lifetime makes the class a non-POD.
+    // Automatic Reference Counting: the presence of a member of Objective-C
+    // pointer type that does not explicitly have no lifetime makes the class a
+    // non-POD.
     QualType T = Context.getBaseElementType(Field->getType());
     if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
       if (T.hasNonTrivialObjCLifetime()) {
@@ -1038,8 +1045,8 @@
         //   If a class has a non-static data member of Objective-C pointer
         //   type (or array thereof), it is a non-POD type and its
         //   default constructor (if any), copy constructor, move constructor,
-        //   copy assignment operator, move assignment operator, and destructor are
-        //   non-trivial.
+        //   copy assignment operator, move assignment operator, and destructor
+        //   are non-trivial.
         setHasObjectMember(true);
         struct DefinitionData &Data = data();
         Data.PlainOldData = false;
@@ -1086,7 +1093,8 @@
       data().IsCXX11StandardLayout = false;
 
       // C++1z [class.copy.ctor]p10:
-      //   A defaulted copy constructor for a class X is defined as deleted if X has:
+      //   A defaulted copy constructor for a class X is defined as deleted if X
+      //   has:
       //    -- a non-static data member of rvalue reference type
       if (T->isRValueReferenceType())
         data().DefaultedCopyConstructorIsDeleted = true;
@@ -1141,7 +1149,7 @@
     // those because they are always unnamed.
     bool IsZeroSize = Field->isZeroSize(Context);
 
-    if (const auto *RecordTy = T->getAs<RecordType>()) {
+    if (auto const *RecordTy = T->getAs<RecordType>()) {
       auto *FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl());
       if (FieldRec->getDefinition()) {
         addedClassSubobject(FieldRec);
@@ -1275,7 +1283,7 @@
         if (data().IsCXX11StandardLayout && IsFirstField) {
           // FIXME: We should check all base classes here, not just direct
           // base classes.
-          for (const auto &BI : bases()) {
+          for (auto const &BI : bases()) {
             if (Context.hasSameUnqualifiedType(BI.getType(), T)) {
               data().IsCXX11StandardLayout = false;
               break;
@@ -1332,8 +1340,7 @@
         // C++11 [class.union]p8, DR1460:
         //   a non-static data member of an anonymous union that is a member of
         //   X is also a variant member of X.
-        if (FieldRec->hasVariantMembers() &&
-            Field->isAnonymousStructOrUnion())
+        if (FieldRec->hasVariantMembers() && Field->isAnonymousStructOrUnion())
           data().HasVariantMembers = true;
       }
     } else {
@@ -1371,14 +1378,14 @@
 
   // Handle using declarations of conversion functions.
   if (auto *Shadow = dyn_cast<UsingShadowDecl>(D)) {
-    if (Shadow->getDeclName().getNameKind()
-          == DeclarationName::CXXConversionFunctionName) {
+    if (Shadow->getDeclName().getNameKind() ==
+        DeclarationName::CXXConversionFunctionName) {
       ASTContext &Ctx = getASTContext();
       data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess());
     }
   }
 
-  if (const auto *Using = dyn_cast<UsingDecl>(D)) {
+  if (auto const *Using = dyn_cast<UsingDecl>(D)) {
     if (Using->getDeclName().getNameKind() ==
         DeclarationName::CXXConstructorName) {
       data().HasInheritedConstructor = true;
@@ -1398,7 +1405,7 @@
   // The kind of special member this declaration is, if any.
   unsigned SMKind = 0;
 
-  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
+  if (auto const *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     if (Constructor->isDefaultConstructor()) {
       SMKind |= SMF_DefaultConstructor;
       if (Constructor->isConstexpr())
@@ -1452,7 +1459,7 @@
 void CXXRecordDecl::setTrivialForCallFlags(CXXMethodDecl *D) {
   unsigned SMKind = 0;
 
-  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
+  if (auto const *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     if (Constructor->isCopyConstructor())
       SMKind = SMF_CopyConstructor;
     else if (Constructor->isMoveConstructor())
@@ -1477,12 +1484,13 @@
 }
 
 bool CXXRecordDecl::isGenericLambda() const {
-  if (!isLambda()) return false;
+  if (!isLambda())
+    return false;
   return getLambdaData().IsGenericLambda;
 }
 
 #ifndef NDEBUG
-static bool allLookupResultsAreTheSame(const DeclContext::lookup_result &R) {
+static bool allLookupResultsAreTheSame(DeclContext::lookup_result const &R) {
   for (auto *D : R)
     if (!declaresSameEntity(D, R.front()))
       return false;
@@ -1490,10 +1498,11 @@
 }
 #endif
 
-static NamedDecl* getLambdaCallOperatorHelper(const CXXRecordDecl &RD) {
-  if (!RD.isLambda()) return nullptr;
+static NamedDecl *getLambdaCallOperatorHelper(CXXRecordDecl const &RD) {
+  if (!RD.isLambda())
+    return nullptr;
   DeclarationName Name =
-    RD.getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
+      RD.getASTContext().DeclarationNames.getCXXOperatorName(OO_Call);
   DeclContext::lookup_result Calls = RD.lookup(Name);
 
   assert(!Calls.empty() && "Missing lambda call operator!");
@@ -1502,9 +1511,9 @@
   return Calls.front();
 }
 
-FunctionTemplateDecl* CXXRecordDecl::getDependentLambdaCallOperator() const {
+FunctionTemplateDecl *CXXRecordDecl::getDependentLambdaCallOperator() const {
   NamedDecl *CallOp = getLambdaCallOperatorHelper(*this);
-  return  dyn_cast_or_null<FunctionTemplateDecl>(CallOp);
+  return dyn_cast_or_null<FunctionTemplateDecl>(CallOp);
 }
 
 CXXMethodDecl *CXXRecordDecl::getLambdaCallOperator() const {
@@ -1513,20 +1522,20 @@
   if (CallOp == nullptr)
     return nullptr;
 
-  if (const auto *CallOpTmpl = dyn_cast<FunctionTemplateDecl>(CallOp))
+  if (auto const *CallOpTmpl = dyn_cast<FunctionTemplateDecl>(CallOp))
     return cast<CXXMethodDecl>(CallOpTmpl->getTemplatedDecl());
 
   return cast<CXXMethodDecl>(CallOp);
 }
 
-CXXMethodDecl* CXXRecordDecl::getLambdaStaticInvoker() const {
+CXXMethodDecl *CXXRecordDecl::getLambdaStaticInvoker() const {
   CXXMethodDecl *CallOp = getLambdaCallOperator();
   CallingConv CC = CallOp->getType()->castAs<FunctionType>()->getCallConv();
   return getLambdaStaticInvoker(CC);
 }
 
 static DeclContext::lookup_result
-getLambdaStaticInvokers(const CXXRecordDecl &RD) {
+getLambdaStaticInvokers(CXXRecordDecl const &RD) {
   assert(RD.isLambda() && "Must be a lambda");
   DeclarationName Name =
       &RD.getASTContext().Idents.get(getLambdaStaticInvokerName());
@@ -1534,7 +1543,7 @@
 }
 
 static CXXMethodDecl *getInvokerAsMethod(NamedDecl *ND) {
-  if (const auto *InvokerTemplate = dyn_cast<FunctionTemplateDecl>(ND))
+  if (auto const *InvokerTemplate = dyn_cast<FunctionTemplateDecl>(ND))
     return cast<CXXMethodDecl>(InvokerTemplate->getTemplatedDecl());
   return cast<CXXMethodDecl>(ND);
 }
@@ -1545,7 +1554,7 @@
   DeclContext::lookup_result Invoker = getLambdaStaticInvokers(*this);
 
   for (NamedDecl *ND : Invoker) {
-    const auto *FTy =
+    auto const *FTy =
         cast<ValueDecl>(ND->getAsFunction())->getType()->castAs<FunctionType>();
     if (FTy->getCallConv() == CC)
       return getInvokerAsMethod(ND);
@@ -1555,14 +1564,14 @@
 }
 
 void CXXRecordDecl::getCaptureFields(
-       llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
-       FieldDecl *&ThisCapture) const {
+    llvm::DenseMap<VarDecl const *, FieldDecl *> &Captures,
+    FieldDecl *&ThisCapture) const {
   Captures.clear();
   ThisCapture = nullptr;
 
   LambdaDefinitionData &Lambda = getLambdaData();
   RecordDecl::field_iterator Field = field_begin();
-  for (const LambdaCapture *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures;
+  for (LambdaCapture const *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures;
        C != CEnd; ++C, ++Field) {
     if (C->capturesThis())
       ThisCapture = *Field;
@@ -1574,7 +1583,8 @@
 
 TemplateParameterList *
 CXXRecordDecl::getGenericLambdaTemplateParameterList() const {
-  if (!isGenericLambda()) return nullptr;
+  if (!isGenericLambda())
+    return nullptr;
   CXXMethodDecl *CallOp = getLambdaCallOperator();
   if (FunctionTemplateDecl *Tmpl = CallOp->getDescribedFunctionTemplate())
     return Tmpl->getTemplateParameters();
@@ -1587,12 +1597,13 @@
   if (!List)
     return {};
 
-  assert(std::is_partitioned(List->begin(), List->end(),
-                             [](const NamedDecl *D) { return !D->isImplicit(); })
-         && "Explicit template params should be ordered before implicit ones");
+  assert(std::is_partitioned(
+             List->begin(), List->end(),
+             [](NamedDecl const *D) { return !D->isImplicit(); }) &&
+         "Explicit template params should be ordered before implicit ones");
 
-  const auto ExplicitEnd = llvm::partition_point(
-      *List, [](const NamedDecl *D) { return !D->isImplicit(); });
+  auto const ExplicitEnd = llvm::partition_point(
+      *List, [](NamedDecl const *D) { return !D->isImplicit(); });
   return llvm::makeArrayRef(List->begin(), ExplicitEnd);
 }
 
@@ -1636,15 +1647,15 @@
 /// \param HiddenVBaseCs the set of conversions which were hidden in a
 ///   virtual base along some inheritance path
 static void CollectVisibleConversions(
-    ASTContext &Context, const CXXRecordDecl *Record, bool InVirtual,
+    ASTContext &Context, CXXRecordDecl const *Record, bool InVirtual,
     AccessSpecifier Access,
-    const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
+    llvm::SmallPtrSet<CanQualType, 8> const &ParentHiddenTypes,
     ASTUnresolvedSet &Output, UnresolvedSetImpl &VOutput,
     llvm::SmallPtrSet<NamedDecl *, 8> &HiddenVBaseCs) {
   // The set of types which have conversions in this class or its
   // subclasses.  As an optimization, we don't copy the derived set
   // unless it might change.
-  const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
+  llvm::SmallPtrSet<CanQualType, 8> const *HiddenTypes = &ParentHiddenTypes;
   llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
 
   // Collect the direct conversions and figure out which conversions
@@ -1668,8 +1679,8 @@
 
       // If this conversion isn't hidden, add it to the appropriate output.
       else if (!Hidden) {
-        AccessSpecifier IAccess
-          = CXXRecordDecl::MergeAccess(Access, I.getAccess());
+        AccessSpecifier IAccess =
+            CXXRecordDecl::MergeAccess(Access, I.getAccess());
 
         if (InVirtual)
           VOutput.addDecl(I.getDecl(), IAccess);
@@ -1680,12 +1691,13 @@
   }
 
   // Collect information recursively from any base classes.
-  for (const auto &I : Record->bases()) {
-    const auto *RT = I.getType()->getAs<RecordType>();
-    if (!RT) continue;
+  for (auto const &I : Record->bases()) {
+    auto const *RT = I.getType()->getAs<RecordType>();
+    if (!RT)
+      continue;
 
-    AccessSpecifier BaseAccess
-      = CXXRecordDecl::MergeAccess(Access, I.getAccessSpecifier());
+    AccessSpecifier BaseAccess =
+        CXXRecordDecl::MergeAccess(Access, I.getAccessSpecifier());
     bool BaseInVirtual = InVirtual || I.isVirtual();
 
     auto *Base = cast<CXXRecordDecl>(RT->getDecl());
@@ -1699,7 +1711,7 @@
 /// This would be extremely straightforward if it weren't for virtual
 /// bases.  It might be worth special-casing that, really.
 static void CollectVisibleConversions(ASTContext &Context,
-                                      const CXXRecordDecl *Record,
+                                      CXXRecordDecl const *Record,
                                       ASTUnresolvedSet &Output) {
   // The collection of all conversions in virtual bases that we've
   // found.  These will be added to the output as long as they don't
@@ -1708,7 +1720,7 @@
 
   // The set of conversions in virtual bases that we've determined to
   // be hidden.
-  llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
+  llvm::SmallPtrSet<NamedDecl *, 8> HiddenVBaseCs;
 
   // The set of types hidden by classes derived from this one.
   llvm::SmallPtrSet<CanQualType, 8> HiddenTypes;
@@ -1722,9 +1734,10 @@
     HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));
 
   // Recursively collect conversions from base classes.
-  for (const auto &I : Record->bases()) {
-    const auto *RT = I.getType()->getAs<RecordType>();
-    if (!RT) continue;
+  for (auto const &I : Record->bases()) {
+    auto const *RT = I.getType()->getAs<RecordType>();
+    if (!RT)
+      continue;
 
     CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
                               I.isVirtual(), I.getAccessSpecifier(),
@@ -1732,8 +1745,8 @@
   }
 
   // Add any unhidden conversions provided by virtual bases.
-  for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
-         I != E; ++I) {
+  for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end(); I != E;
+       ++I) {
     if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
       Output.addDecl(Context, I.getDecl(), I.getAccess());
   }
@@ -1760,7 +1773,7 @@
   return llvm::make_range(Set->begin(), Set->end());
 }
 
-void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) {
+void CXXRecordDecl::removeConversion(NamedDecl const *ConvDecl) {
   // This operation is O(N) but extremely rare.  Sema only uses it to
   // remove UsingShadowDecls in a class that were followed by a direct
   // declaration, e.g.:
@@ -1796,14 +1809,13 @@
   return TemplateOrInstantiation.dyn_cast<MemberSpecializationInfo *>();
 }
 
-void
-CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD,
-                                             TemplateSpecializationKind TSK) {
+void CXXRecordDecl::setInstantiationOfMemberClass(
+    CXXRecordDecl *RD, TemplateSpecializationKind TSK) {
   assert(TemplateOrInstantiation.isNull() &&
          "Previous template or instantiation?");
   assert(!isa<ClassTemplatePartialSpecializationDecl>(this));
-  TemplateOrInstantiation
-    = new (getASTContext()) MemberSpecializationInfo(RD, TSK);
+  TemplateOrInstantiation =
+      new (getASTContext()) MemberSpecializationInfo(RD, TSK);
 }
 
 ClassTemplateDecl *CXXRecordDecl::getDescribedClassTemplate() const {
@@ -1814,8 +1826,9 @@
   TemplateOrInstantiation = Template;
 }
 
-TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{
-  if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(this))
+TemplateSpecializationKind
+CXXRecordDecl::getTemplateSpecializationKind() const {
+  if (auto const *Spec = dyn_cast<ClassTemplateSpecializationDecl>(this))
     return Spec->getSpecializationKind();
 
   if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
@@ -1824,8 +1837,8 @@
   return TSK_Undeclared;
 }
 
-void
-CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
+void CXXRecordDecl::setTemplateSpecializationKind(
+    TemplateSpecializationKind TSK) {
   if (auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
     Spec->setSpecializationKind(TSK);
     return;
@@ -1839,9 +1852,9 @@
   llvm_unreachable("Not a class template or member class specialization");
 }
 
-const CXXRecordDecl *CXXRecordDecl::getTemplateInstantiationPattern() const {
+CXXRecordDecl const *CXXRecordDecl::getTemplateInstantiationPattern() const {
   auto GetDefinitionOrSelf =
-      [](const CXXRecordDecl *D) -> const CXXRecordDecl * {
+      [](CXXRecordDecl const *D) -> CXXRecordDecl const * {
     if (auto *Def = D->getDefinition())
       return Def;
     return D;
@@ -1872,7 +1885,7 @@
 
   if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
     if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
-      const CXXRecordDecl *RD = this;
+      CXXRecordDecl const *RD = this;
       while (auto *NewRD = RD->getInstantiatedFromMemberClass())
         RD = NewRD;
       return GetDefinitionOrSelf(RD);
@@ -1888,16 +1901,15 @@
   ASTContext &Context = getASTContext();
   QualType ClassType = Context.getTypeDeclType(this);
 
-  DeclarationName Name
-    = Context.DeclarationNames.getCXXDestructorName(
-                                          Context.getCanonicalType(ClassType));
+  DeclarationName Name = Context.DeclarationNames.getCXXDestructorName(
+      Context.getCanonicalType(ClassType));
 
   DeclContext::lookup_result R = lookup(Name);
 
   return R.empty() ? nullptr : dyn_cast<CXXDestructorDecl>(R.front());
 }
 
-static bool isDeclContextInNamespace(const DeclContext *DC) {
+static bool isDeclContextInNamespace(DeclContext const *DC) {
   while (!DC->isTranslationUnit()) {
     if (DC->isNamespace())
       return true;
@@ -1921,12 +1933,12 @@
     return false;
 
   // No interface-like type can have a method with a definition.
-  for (const auto *const Method : methods())
+  for (auto const *const Method : methods())
     if (Method->isDefined() && !Method->isImplicit())
       return false;
 
   // Check "Special" types.
-  const auto *Uuid = getAttr<UuidAttr>();
+  auto const *Uuid = getAttr<UuidAttr>();
   // MS SDK declares IUnknown/IDispatch both in the root of a TU, or in an
   // extern C++ block directly in the TU.  These are only valid if in one
   // of these two situations.
@@ -1948,18 +1960,16 @@
   if (getNumBases() != 1)
     return false;
 
-  const auto BaseSpec = *bases_begin();
+  auto const BaseSpec = *bases_begin();
   if (BaseSpec.isVirtual() || BaseSpec.getAccessSpecifier() != AS_public)
     return false;
-  const auto *Base = BaseSpec.getType()->getAsCXXRecordDecl();
+  auto const *Base = BaseSpec.getType()->getAsCXXRecordDecl();
   if (Base->isInterface() || !Base->isInterfaceLike())
     return false;
   return true;
 }
 
-void CXXRecordDecl::completeDefinition() {
-  completeDefinition(nullptr);
-}
+void CXXRecordDecl::completeDefinition() { completeDefinition(nullptr); }
 
 void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) {
   RecordDecl::completeDefinition();
@@ -1975,10 +1985,10 @@
 
     bool Done = false;
     for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
-                                     MEnd = FinalOverriders->end();
+                                        MEnd = FinalOverriders->end();
          M != MEnd && !Done; ++M) {
       for (OverridingMethods::iterator SO = M->second.begin(),
-                                    SOEnd = M->second.end();
+                                       SOEnd = M->second.end();
            SO != SOEnd && !Done; ++SO) {
         assert(SO->second.size() > 0 &&
                "All virtual functions have overriding virtual functions");
@@ -1997,8 +2007,8 @@
   }
 
   // Set access bits correctly on the directly-declared conversions.
-  for (conversion_iterator I = conversion_begin(), E = conversion_end();
-       I != E; ++I)
+  for (conversion_iterator I = conversion_begin(), E = conversion_end(); I != E;
+       ++I)
     I.setAccess((*I)->getAccess());
 }
 
@@ -2007,8 +2017,8 @@
       isDependentContext())
     return false;
 
-  for (const auto &B : bases()) {
-    const auto *BaseDecl =
+  for (auto const &B : bases()) {
+    auto const *BaseDecl =
         cast<CXXRecordDecl>(B.getType()->castAs<RecordType>()->getDecl());
     if (BaseDecl->isAbstract())
       return true;
@@ -2023,7 +2033,7 @@
     return false;
   if (Def->hasAttr<FinalAttr>())
     return true;
-  if (const auto *Dtor = Def->getDestructor())
+  if (auto const *Dtor = Def->getDestructor())
     if (Dtor->hasAttr<FinalAttr>())
       return true;
   return false;
@@ -2062,7 +2072,7 @@
 CXXDeductionGuideDecl *
 CXXDeductionGuideDecl::Create(ASTContext &C, DeclContext *DC,
                               SourceLocation StartLoc, ExplicitSpecifier ES,
-                              const DeclarationNameInfo &NameInfo, QualType T,
+                              DeclarationNameInfo const &NameInfo, QualType T,
                               TypeSourceInfo *TInfo, SourceLocation EndLocation,
                               CXXConstructorDecl *Ctor) {
   return new (C, DC) CXXDeductionGuideDecl(C, DC, StartLoc, ES, NameInfo, T,
@@ -2076,8 +2086,9 @@
       QualType(), nullptr, SourceLocation(), nullptr);
 }
 
-RequiresExprBodyDecl *RequiresExprBodyDecl::Create(
-    ASTContext &C, DeclContext *DC, SourceLocation StartLoc) {
+RequiresExprBodyDecl *RequiresExprBodyDecl::Create(ASTContext &C,
+                                                   DeclContext *DC,
+                                                   SourceLocation StartLoc) {
   return new (C, DC) RequiresExprBodyDecl(C, DC, StartLoc);
 }
 
@@ -2089,7 +2100,7 @@
 void CXXMethodDecl::anchor() {}
 
 bool CXXMethodDecl::isStatic() const {
-  const CXXMethodDecl *MD = getCanonicalDecl();
+  CXXMethodDecl const *MD = getCanonicalDecl();
 
   if (MD->getStorageClass() == SC_Static)
     return true;
@@ -2098,9 +2109,9 @@
   return isStaticOverloadedOperator(OOK);
 }
 
-static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
-                                 const CXXMethodDecl *BaseMD) {
-  for (const CXXMethodDecl *MD : DerivedMD->overridden_methods()) {
+static bool recursivelyOverrides(CXXMethodDecl const *DerivedMD,
+                                 CXXMethodDecl const *BaseMD) {
+  for (CXXMethodDecl const *MD : DerivedMD->overridden_methods()) {
     if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl())
       return true;
     if (recursivelyOverrides(MD, BaseMD))
@@ -2110,7 +2121,7 @@
 }
 
 CXXMethodDecl *
-CXXMethodDecl::getCorrespondingMethodDeclaredInClass(const CXXRecordDecl *RD,
+CXXMethodDecl::getCorrespondingMethodDeclaredInClass(CXXRecordDecl const *RD,
                                                      bool MayBeBase) {
   if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl())
     return this;
@@ -2141,12 +2152,12 @@
 }
 
 CXXMethodDecl *
-CXXMethodDecl::getCorrespondingMethodInClass(const CXXRecordDecl *RD,
+CXXMethodDecl::getCorrespondingMethodInClass(CXXRecordDecl const *RD,
                                              bool MayBeBase) {
   if (auto *MD = getCorrespondingMethodDeclaredInClass(RD, MayBeBase))
     return MD;
 
-  llvm::SmallVector<CXXMethodDecl*, 4> FinalOverriders;
+  llvm::SmallVector<CXXMethodDecl *, 4> FinalOverriders;
   auto AddFinalOverrider = [&](CXXMethodDecl *D) {
     // If this function is overridden by a candidate final overrider, it is not
     // a final overrider.
@@ -2166,11 +2177,11 @@
     FinalOverriders.push_back(D);
   };
 
-  for (const auto &I : RD->bases()) {
-    const RecordType *RT = I.getType()->getAs<RecordType>();
+  for (auto const &I : RD->bases()) {
+    RecordType const *RT = I.getType()->getAs<RecordType>();
     if (!RT)
       continue;
-    const auto *Base = cast<CXXRecordDecl>(RT->getDecl());
+    auto const *Base = cast<CXXRecordDecl>(RT->getDecl());
     if (CXXMethodDecl *D = this->getCorrespondingMethodInClass(Base))
       AddFinalOverrider(D);
   }
@@ -2180,7 +2191,7 @@
 
 CXXMethodDecl *
 CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-                      const DeclarationNameInfo &NameInfo, QualType T,
+                      DeclarationNameInfo const &NameInfo, QualType T,
                       TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin,
                       bool isInline, ConstexprSpecKind ConstexprKind,
                       SourceLocation EndLocation,
@@ -2197,7 +2208,7 @@
       ConstexprSpecKind::Unspecified, SourceLocation(), nullptr);
 }
 
-CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(const Expr *Base,
+CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(Expr const *Base,
                                                      bool IsAppleKext) {
   assert(isVirtual() && "this method is expected to be virtual");
 
@@ -2222,7 +2233,7 @@
     return this;
 
   // If we don't even know what we would call, we can't devirtualize.
-  const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType();
+  CXXRecordDecl const *BestDynamicDecl = Base->getBestDynamicClassType();
   if (!BestDynamicDecl)
     return nullptr;
 
@@ -2251,8 +2262,8 @@
   if (BestDynamicDecl->isEffectivelyFinal())
     return DevirtualizedMethod;
 
-  if (const auto *DRE = dyn_cast<DeclRefExpr>(Base)) {
-    if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
+  if (auto const *DRE = dyn_cast<DeclRefExpr>(Base)) {
+    if (auto const *VD = dyn_cast<VarDecl>(DRE->getDecl()))
       if (VD->getType()->isRecordType())
         // This is a record decl. We know the type and can devirtualize it.
         return DevirtualizedMethod;
@@ -2263,8 +2274,8 @@
   // We can devirtualize calls on an object accessed by a class member access
   // expression, since by C++11 [basic.life]p6 we know that it can't refer to
   // a derived class object constructed in the same location.
-  if (const auto *ME = dyn_cast<MemberExpr>(Base)) {
-    const ValueDecl *VD = ME->getMemberDecl();
+  if (auto const *ME = dyn_cast<MemberExpr>(Base)) {
+    ValueDecl const *VD = ME->getMemberDecl();
     return VD->getType()->isRecordType() ? DevirtualizedMethod : nullptr;
   }
 
@@ -2283,7 +2294,7 @@
 }
 
 bool CXXMethodDecl::isUsualDeallocationFunction(
-    SmallVectorImpl<const FunctionDecl *> &PreventedBy) const {
+    SmallVectorImpl<FunctionDecl const *> &PreventedBy) const {
   assert(PreventedBy.empty() && "PreventedBy is expected to be empty");
   if (getOverloadedOperator() != OO_Delete &&
       getOverloadedOperator() != OO_Array_Delete)
@@ -2340,16 +2351,15 @@
   // FIXME(EricWF): Destrying Delete should be a language option. How do we
   // handle when destroying delete is used prior to C++17?
   if (Context.getLangOpts().CPlusPlus17 ||
-      Context.getLangOpts().AlignedAllocation ||
-      isDestroyingOperatorDelete())
+      Context.getLangOpts().AlignedAllocation || isDestroyingOperatorDelete())
     return true;
 
   // This function is a usual deallocation function if there are no
   // single-parameter deallocation functions of the same kind.
   DeclContext::lookup_result R = getDeclContext()->lookup(getDeclName());
   bool Result = true;
-  for (const auto *D : R) {
-    if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
+  for (auto const *D : R) {
+    if (auto const *FD = dyn_cast<FunctionDecl>(D)) {
       if (FD->getNumParams() == 1) {
         PreventedBy.push_back(FD);
         Result = false;
@@ -2366,17 +2376,17 @@
   //  type X, X&, const X&, volatile X& or const volatile X&.
   if (/*operator=*/getOverloadedOperator() != OO_Equal ||
       /*non-static*/ isStatic() ||
-      /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate() ||
+      /*non-template*/ getPrimaryTemplate() || getDescribedFunctionTemplate() ||
       getNumParams() != 1)
     return false;
 
   QualType ParamType = getParamDecl(0)->getType();
-  if (const auto *Ref = ParamType->getAs<LValueReferenceType>())
+  if (auto const *Ref = ParamType->getAs<LValueReferenceType>())
     ParamType = Ref->getPointeeType();
 
   ASTContext &Context = getASTContext();
-  QualType ClassType
-    = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
+  QualType ClassType =
+      Context.getCanonicalType(Context.getTypeDeclType(getParent()));
   return Context.hasSameUnqualifiedType(ClassType, ParamType);
 }
 
@@ -2396,12 +2406,12 @@
   ParamType = ParamType->getPointeeType();
 
   ASTContext &Context = getASTContext();
-  QualType ClassType
-    = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
+  QualType ClassType =
+      Context.getCanonicalType(Context.getTypeDeclType(getParent()));
   return Context.hasSameUnqualifiedType(ClassType, ParamType);
 }
 
-void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) {
+void CXXMethodDecl::addOverriddenMethod(CXXMethodDecl const *MD) {
   assert(MD->isCanonicalDecl() && "Method is not canonical!");
   assert(!MD->getParent()->isDependentContext() &&
          "Can't add an overridden method to a class template!");
@@ -2411,17 +2421,20 @@
 }
 
 CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
-  if (isa<CXXConstructorDecl>(this)) return nullptr;
+  if (isa<CXXConstructorDecl>(this))
+    return nullptr;
   return getASTContext().overridden_methods_begin(this);
 }
 
 CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
-  if (isa<CXXConstructorDecl>(this)) return nullptr;
+  if (isa<CXXConstructorDecl>(this))
+    return nullptr;
   return getASTContext().overridden_methods_end(this);
 }
 
 unsigned CXXMethodDecl::size_overridden_methods() const {
-  if (isa<CXXConstructorDecl>(this)) return 0;
+  if (isa<CXXConstructorDecl>(this))
+    return 0;
   return getASTContext().overridden_methods_size(this);
 }
 
@@ -2432,21 +2445,21 @@
   return getASTContext().overridden_methods(this);
 }
 
-static QualType getThisObjectType(ASTContext &C, const FunctionProtoType *FPT,
-                                  const CXXRecordDecl *Decl) {
+static QualType getThisObjectType(ASTContext &C, FunctionProtoType const *FPT,
+                                  CXXRecordDecl const *Decl) {
   QualType ClassTy = C.getTypeDeclType(Decl);
   return C.getQualifiedType(ClassTy, FPT->getMethodQuals());
 }
 
-QualType CXXMethodDecl::getThisType(const FunctionProtoType *FPT,
-                                    const CXXRecordDecl *Decl) {
+QualType CXXMethodDecl::getThisType(FunctionProtoType const *FPT,
+                                    CXXRecordDecl const *Decl) {
   ASTContext &C = Decl->getASTContext();
   QualType ObjectTy = ::getThisObjectType(C, FPT, Decl);
   return C.getPointerType(ObjectTy);
 }
 
-QualType CXXMethodDecl::getThisObjectType(const FunctionProtoType *FPT,
-                                          const CXXRecordDecl *Decl) {
+QualType CXXMethodDecl::getThisObjectType(FunctionProtoType const *FPT,
+                                          CXXRecordDecl const *Decl) {
   ASTContext &C = Decl->getASTContext();
   return ::getThisObjectType(C, FPT, Decl);
 }
@@ -2472,17 +2485,17 @@
 bool CXXMethodDecl::hasInlineBody() const {
   // If this function is a template instantiation, look at the template from
   // which it was instantiated.
-  const FunctionDecl *CheckFn = getTemplateInstantiationPattern();
+  FunctionDecl const *CheckFn = getTemplateInstantiationPattern();
   if (!CheckFn)
     CheckFn = this;
 
-  const FunctionDecl *fn;
+  FunctionDecl const *fn;
   return CheckFn->isDefined(fn) && !fn->isOutOfLine() &&
          (fn->doesThisDeclarationHaveABody() || fn->willHaveBody());
 }
 
 bool CXXMethodDecl::isLambdaStaticInvoker() const {
-  const CXXRecordDecl *P = getParent();
+  CXXRecordDecl const *P = getParent();
   return P->isLambda() && getDeclName().isIdentifier() &&
          getName() == getLambdaStaticInvokerName();
 }
@@ -2514,27 +2527,26 @@
       IsWritten(false), SourceOrder(0) {}
 
 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
-                                       TypeSourceInfo *TInfo,
-                                       SourceLocation L, Expr *Init,
-                                       SourceLocation R)
+                                       TypeSourceInfo *TInfo, SourceLocation L,
+                                       Expr *Init, SourceLocation R)
     : Initializee(TInfo), Init(Init), LParenLoc(L), RParenLoc(R),
       IsDelegating(true), IsVirtual(false), IsWritten(false), SourceOrder(0) {}
 
-int64_t CXXCtorInitializer::getID(const ASTContext &Context) const {
-  return Context.getAllocator()
-                .identifyKnownAlignedObject<CXXCtorInitializer>(this);
+int64_t CXXCtorInitializer::getID(ASTContext const &Context) const {
+  return Context.getAllocator().identifyKnownAlignedObject<CXXCtorInitializer>(
+      this);
 }
 
 TypeLoc CXXCtorInitializer::getBaseClassLoc() const {
   if (isBaseInitializer())
-    return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
+    return Initializee.get<TypeSourceInfo *>()->getTypeLoc();
   else
     return {};
 }
 
-const Type *CXXCtorInitializer::getBaseClass() const {
+Type const *CXXCtorInitializer::getBaseClass() const {
   if (isBaseInitializer())
-    return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
+    return Initializee.get<TypeSourceInfo *>()->getType().getTypePtr();
   else
     return nullptr;
 }
@@ -2546,7 +2558,7 @@
   if (isAnyMemberInitializer())
     return getMemberLocation();
 
-  if (const auto *TSInfo = Initializee.get<TypeSourceInfo *>())
+  if (auto const *TSInfo = Initializee.get<TypeSourceInfo *>())
     return TSInfo->getTypeLoc().getLocalSourceRange().getBegin();
 
   return {};
@@ -2565,7 +2577,7 @@
 
 CXXConstructorDecl::CXXConstructorDecl(
     ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+    DeclarationNameInfo const &NameInfo, QualType T, TypeSourceInfo *TInfo,
     ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline,
     bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
     InheritedConstructor Inherited, Expr *TrailingRequiresClause)
@@ -2605,12 +2617,12 @@
 
 CXXConstructorDecl *CXXConstructorDecl::Create(
     ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+    DeclarationNameInfo const &NameInfo, QualType T, TypeSourceInfo *TInfo,
     ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline,
     bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
     InheritedConstructor Inherited, Expr *TrailingRequiresClause) {
-  assert(NameInfo.getName().getNameKind()
-         == DeclarationName::CXXConstructorName &&
+  assert(NameInfo.getName().getNameKind() ==
+             DeclarationName::CXXConstructorName &&
          "Name must refer to a constructor");
   unsigned Extra =
       additionalSizeToAlloc<InheritedConstructor, ExplicitSpecifier>(
@@ -2627,7 +2639,7 @@
 CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const {
   assert(isDelegatingConstructor() && "Not a delegating constructor!");
   Expr *E = (*init_begin())->getInit()->IgnoreImplicit();
-  if (const auto *Construct = dyn_cast<CXXConstructExpr>(E))
+  if (auto const *Construct = dyn_cast<CXXConstructExpr>(E))
     return Construct->getConstructor();
 
   return nullptr;
@@ -2641,8 +2653,7 @@
   return getMinRequiredArguments() == 0;
 }
 
-bool
-CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
+bool CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
   return isCopyOrMoveConstructor(TypeQuals) &&
          getParamDecl(0)->getType()->isLValueReferenceType();
 }
@@ -2668,20 +2679,20 @@
       getDescribedFunctionTemplate() != nullptr)
     return false;
 
-  const ParmVarDecl *Param = getParamDecl(0);
+  ParmVarDecl const *Param = getParamDecl(0);
 
   // Do we have a reference type?
-  const auto *ParamRefType = Param->getType()->getAs<ReferenceType>();
+  auto const *ParamRefType = Param->getType()->getAs<ReferenceType>();
   if (!ParamRefType)
     return false;
 
   // Is it a reference to our class type?
   ASTContext &Context = getASTContext();
 
-  CanQualType PointeeType
-    = Context.getCanonicalType(ParamRefType->getPointeeType());
-  CanQualType ClassTy
-    = Context.getCanonicalType(Context.getTagDeclType(getParent()));
+  CanQualType PointeeType =
+      Context.getCanonicalType(ParamRefType->getPointeeType());
+  CanQualType ClassTy =
+      Context.getCanonicalType(Context.getTagDeclType(getParent()));
   if (PointeeType.getUnqualifiedType() != ClassTy)
     return false;
 
@@ -2714,14 +2725,14 @@
   if (!hasOneParamOrDefaultArgs() || getDescribedFunctionTemplate() != nullptr)
     return false;
 
-  const ParmVarDecl *Param = getParamDecl(0);
+  ParmVarDecl const *Param = getParamDecl(0);
 
   ASTContext &Context = getASTContext();
   CanQualType ParamType = Context.getCanonicalType(Param->getType());
 
   // Is it the same as our class type?
-  CanQualType ClassTy
-    = Context.getCanonicalType(Context.getTagDeclType(getParent()));
+  CanQualType ClassTy =
+      Context.getCanonicalType(Context.getTagDeclType(getParent()));
   if (ParamType.getUnqualifiedType() != ClassTy)
     return false;
 
@@ -2730,8 +2741,8 @@
 
 void CXXDestructorDecl::anchor() {}
 
-CXXDestructorDecl *
-CXXDestructorDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
+CXXDestructorDecl *CXXDestructorDecl::CreateDeserialized(ASTContext &C,
+                                                         unsigned ID) {
   return new (C, ID) CXXDestructorDecl(
       C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
       false, false, false, ConstexprSpecKind::Unspecified, nullptr);
@@ -2739,11 +2750,11 @@
 
 CXXDestructorDecl *CXXDestructorDecl::Create(
     ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+    DeclarationNameInfo const &NameInfo, QualType T, TypeSourceInfo *TInfo,
     bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared,
     ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause) {
-  assert(NameInfo.getName().getNameKind()
-         == DeclarationName::CXXDestructorName &&
+  assert(NameInfo.getName().getNameKind() ==
+             DeclarationName::CXXDestructorName &&
          "Name must refer to a destructor");
   return new (C, RD) CXXDestructorDecl(
       C, RD, StartLoc, NameInfo, T, TInfo, UsesFPIntrin, isInline,
@@ -2762,8 +2773,8 @@
 
 void CXXConversionDecl::anchor() {}
 
-CXXConversionDecl *
-CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
+CXXConversionDecl *CXXConversionDecl::CreateDeserialized(ASTContext &C,
+                                                         unsigned ID) {
   return new (C, ID) CXXConversionDecl(
       C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
       false, false, ExplicitSpecifier(), ConstexprSpecKind::Unspecified,
@@ -2772,12 +2783,12 @@
 
 CXXConversionDecl *CXXConversionDecl::Create(
     ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-    const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+    DeclarationNameInfo const &NameInfo, QualType T, TypeSourceInfo *TInfo,
     bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES,
     ConstexprSpecKind ConstexprKind, SourceLocation EndLocation,
     Expr *TrailingRequiresClause) {
-  assert(NameInfo.getName().getNameKind()
-         == DeclarationName::CXXConversionFunctionName &&
+  assert(NameInfo.getName().getNameKind() ==
+             DeclarationName::CXXConversionFunctionName &&
          "Name must refer to a conversion function");
   return new (C, RD) CXXConversionDecl(
       C, RD, StartLoc, NameInfo, T, TInfo, UsesFPIntrin, isInline, ES,
@@ -2800,12 +2811,10 @@
 
 void LinkageSpecDecl::anchor() {}
 
-LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
-                                         DeclContext *DC,
+LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C, DeclContext *DC,
                                          SourceLocation ExternLoc,
                                          SourceLocation LangLoc,
-                                         LanguageIDs Lang,
-                                         bool HasBraces) {
+                                         LanguageIDs Lang, bool HasBraces) {
   return new (C, DC) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, HasBraces);
 }
 
@@ -2817,13 +2826,10 @@
 
 void UsingDirectiveDecl::anchor() {}
 
-UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
-                                               SourceLocation L,
-                                               SourceLocation NamespaceLoc,
-                                           NestedNameSpecifierLoc QualifierLoc,
-                                               SourceLocation IdentLoc,
-                                               NamedDecl *Used,
-                                               DeclContext *CommonAncestor) {
+UsingDirectiveDecl *UsingDirectiveDecl::Create(
+    ASTContext &C, DeclContext *DC, SourceLocation L,
+    SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc,
+    SourceLocation IdentLoc, NamedDecl *Used, DeclContext *CommonAncestor) {
   if (auto *NS = dyn_cast_or_null<NamespaceDecl>(Used))
     Used = NS->getOriginalNamespace();
   return new (C, DC) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierLoc,
@@ -2832,10 +2838,9 @@
 
 UsingDirectiveDecl *UsingDirectiveDecl::CreateDeserialized(ASTContext &C,
                                                            unsigned ID) {
-  return new (C, ID) UsingDirectiveDecl(nullptr, SourceLocation(),
-                                        SourceLocation(),
-                                        NestedNameSpecifierLoc(),
-                                        SourceLocation(), nullptr, nullptr);
+  return new (C, ID) UsingDirectiveDecl(
+      nullptr, SourceLocation(), SourceLocation(), NestedNameSpecifierLoc(),
+      SourceLocation(), nullptr, nullptr);
 }
 
 NamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() {
@@ -2860,8 +2865,8 @@
                                      bool Inline, SourceLocation StartLoc,
                                      SourceLocation IdLoc, IdentifierInfo *Id,
                                      NamespaceDecl *PrevDecl) {
-  return new (C, DC) NamespaceDecl(C, DC, Inline, StartLoc, IdLoc, Id,
-                                   PrevDecl);
+  return new (C, DC)
+      NamespaceDecl(C, DC, Inline, StartLoc, IdLoc, Id, PrevDecl);
 }
 
 NamespaceDecl *NamespaceDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
@@ -2876,7 +2881,7 @@
   return AnonOrFirstNamespaceAndInline.getPointer();
 }
 
-const NamespaceDecl *NamespaceDecl::getOriginalNamespace() const {
+NamespaceDecl const *NamespaceDecl::getOriginalNamespace() const {
   if (isFirstDecl())
     return this;
 
@@ -2911,13 +2916,12 @@
   return getMostRecentDecl();
 }
 
-NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
-                                               SourceLocation UsingLoc,
-                                               SourceLocation AliasLoc,
-                                               IdentifierInfo *Alias,
-                                           NestedNameSpecifierLoc QualifierLoc,
-                                               SourceLocation IdentLoc,
-                                               NamedDecl *Namespace) {
+NamespaceAliasDecl *
+NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
+                           SourceLocation UsingLoc, SourceLocation AliasLoc,
+                           IdentifierInfo *Alias,
+                           NestedNameSpecifierLoc QualifierLoc,
+                           SourceLocation IdentLoc, NamedDecl *Namespace) {
   // FIXME: Preserve the aliased namespace as written.
   if (auto *NS = dyn_cast_or_null<NamespaceDecl>(Namespace))
     Namespace = NS->getOriginalNamespace();
@@ -2925,19 +2929,18 @@
                                         QualifierLoc, IdentLoc, Namespace);
 }
 
-NamespaceAliasDecl *
-NamespaceAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) NamespaceAliasDecl(C, nullptr, SourceLocation(),
-                                        SourceLocation(), nullptr,
-                                        NestedNameSpecifierLoc(),
-                                        SourceLocation(), nullptr);
+NamespaceAliasDecl *NamespaceAliasDecl::CreateDeserialized(ASTContext &C,
+                                                           unsigned ID) {
+  return new (C, ID) NamespaceAliasDecl(
+      C, nullptr, SourceLocation(), SourceLocation(), nullptr,
+      NestedNameSpecifierLoc(), SourceLocation(), nullptr);
 }
 
 void LifetimeExtendedTemporaryDecl::anchor() {}
 
 /// Retrieve the storage duration for the materialized temporary.
 StorageDuration LifetimeExtendedTemporaryDecl::getStorageDuration() const {
-  const ValueDecl *ExtendingDecl = getExtendingDecl();
+  ValueDecl const *ExtendingDecl = getExtendingDecl();
   if (!ExtendingDecl)
     return SD_FullExpression;
   // FIXME: This is not necessarily correct for a temporary materialized
@@ -2979,14 +2982,14 @@
     : NamedDecl(K, nullptr, SourceLocation(), DeclarationName()),
       redeclarable_base(C) {}
 
-UsingShadowDecl *
-UsingShadowDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
+UsingShadowDecl *UsingShadowDecl::CreateDeserialized(ASTContext &C,
+                                                     unsigned ID) {
   return new (C, ID) UsingShadowDecl(UsingShadow, C, EmptyShell());
 }
 
 BaseUsingDecl *UsingShadowDecl::getIntroducer() const {
-  const UsingShadowDecl *Shadow = this;
-  while (const auto *NextShadow =
+  UsingShadowDecl const *Shadow = this;
+  while (auto const *NextShadow =
              dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
     Shadow = NextShadow;
   return cast<BaseUsingDecl>(Shadow->UsingOrNextShadow);
@@ -2998,8 +3001,8 @@
 ConstructorUsingShadowDecl::Create(ASTContext &C, DeclContext *DC,
                                    SourceLocation Loc, UsingDecl *Using,
                                    NamedDecl *Target, bool IsVirtual) {
-  return new (C, DC) ConstructorUsingShadowDecl(C, DC, Loc, Using, Target,
-                                                IsVirtual);
+  return new (C, DC)
+      ConstructorUsingShadowDecl(C, DC, Loc, Using, Target, IsVirtual);
 }
 
 ConstructorUsingShadowDecl *
@@ -3032,7 +3035,7 @@
 
   if (FirstUsingShadow.getPointer() == S) {
     FirstUsingShadow.setPointer(
-      dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
+        dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
     S->UsingOrNextShadow = this;
     return;
   }
@@ -3048,20 +3051,20 @@
 
 UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
                              NestedNameSpecifierLoc QualifierLoc,
-                             const DeclarationNameInfo &NameInfo,
+                             DeclarationNameInfo const &NameInfo,
                              bool HasTypename) {
   return new (C, DC) UsingDecl(DC, UL, QualifierLoc, NameInfo, HasTypename);
 }
 
 UsingDecl *UsingDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) UsingDecl(nullptr, SourceLocation(),
-                               NestedNameSpecifierLoc(), DeclarationNameInfo(),
-                               false);
+  return new (C, ID)
+      UsingDecl(nullptr, SourceLocation(), NestedNameSpecifierLoc(),
+                DeclarationNameInfo(), false);
 }
 
 SourceRange UsingDecl::getSourceRange() const {
-  SourceLocation Begin = isAccessDeclaration()
-    ? getQualifierLoc().getBeginLoc() : UsingLocation;
+  SourceLocation Begin =
+      isAccessDeclaration() ? getQualifierLoc().getBeginLoc() : UsingLocation;
   return SourceRange(Begin, getNameInfo().getEndLoc());
 }
 
@@ -3098,48 +3101,40 @@
   Result->NumExpansions = NumExpansions;
   auto *Trail = Result->getTrailingObjects<NamedDecl *>();
   for (unsigned I = 0; I != NumExpansions; ++I)
-    new (Trail + I) NamedDecl*(nullptr);
+    new (Trail + I) NamedDecl *(nullptr);
   return Result;
 }
 
 void UnresolvedUsingValueDecl::anchor() {}
 
-UnresolvedUsingValueDecl *
-UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC,
-                                 SourceLocation UsingLoc,
-                                 NestedNameSpecifierLoc QualifierLoc,
-                                 const DeclarationNameInfo &NameInfo,
-                                 SourceLocation EllipsisLoc) {
-  return new (C, DC) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc,
-                                              QualifierLoc, NameInfo,
-                                              EllipsisLoc);
+UnresolvedUsingValueDecl *UnresolvedUsingValueDecl::Create(
+    ASTContext &C, DeclContext *DC, SourceLocation UsingLoc,
+    NestedNameSpecifierLoc QualifierLoc, DeclarationNameInfo const &NameInfo,
+    SourceLocation EllipsisLoc) {
+  return new (C, DC) UnresolvedUsingValueDecl(
+      DC, C.DependentTy, UsingLoc, QualifierLoc, NameInfo, EllipsisLoc);
 }
 
 UnresolvedUsingValueDecl *
 UnresolvedUsingValueDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) UnresolvedUsingValueDecl(nullptr, QualType(),
-                                              SourceLocation(),
-                                              NestedNameSpecifierLoc(),
-                                              DeclarationNameInfo(),
-                                              SourceLocation());
+  return new (C, ID) UnresolvedUsingValueDecl(
+      nullptr, QualType(), SourceLocation(), NestedNameSpecifierLoc(),
+      DeclarationNameInfo(), SourceLocation());
 }
 
 SourceRange UnresolvedUsingValueDecl::getSourceRange() const {
-  SourceLocation Begin = isAccessDeclaration()
-    ? getQualifierLoc().getBeginLoc() : UsingLocation;
+  SourceLocation Begin =
+      isAccessDeclaration() ? getQualifierLoc().getBeginLoc() : UsingLocation;
   return SourceRange(Begin, getNameInfo().getEndLoc());
 }
 
 void UnresolvedUsingTypenameDecl::anchor() {}
 
-UnresolvedUsingTypenameDecl *
-UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC,
-                                    SourceLocation UsingLoc,
-                                    SourceLocation TypenameLoc,
-                                    NestedNameSpecifierLoc QualifierLoc,
-                                    SourceLocation TargetNameLoc,
-                                    DeclarationName TargetName,
-                                    SourceLocation EllipsisLoc) {
+UnresolvedUsingTypenameDecl *UnresolvedUsingTypenameDecl::Create(
+    ASTContext &C, DeclContext *DC, SourceLocation UsingLoc,
+    SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc,
+    SourceLocation TargetNameLoc, DeclarationName TargetName,
+    SourceLocation EllipsisLoc) {
   return new (C, DC) UnresolvedUsingTypenameDecl(
       DC, UsingLoc, TypenameLoc, QualifierLoc, TargetNameLoc,
       TargetName.getAsIdentifierInfo(), EllipsisLoc);
@@ -3237,14 +3232,14 @@
   Result->NumBindings = NumBindings;
   auto *Trail = Result->getTrailingObjects<BindingDecl *>();
   for (unsigned I = 0; I != NumBindings; ++I)
-    new (Trail + I) BindingDecl*(nullptr);
+    new (Trail + I) BindingDecl *(nullptr);
   return Result;
 }
 
 void DecompositionDecl::printName(llvm::raw_ostream &os) const {
   os << '[';
   bool Comma = false;
-  for (const auto *B : bindings()) {
+  for (auto const *B : bindings()) {
     if (Comma)
       os << ", ";
     B->printName(os);
@@ -3264,11 +3259,10 @@
   return new (C, DC) MSPropertyDecl(DC, L, N, T, TInfo, StartL, Getter, Setter);
 }
 
-MSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C,
-                                                   unsigned ID) {
-  return new (C, ID) MSPropertyDecl(nullptr, SourceLocation(),
-                                    DeclarationName(), QualType(), nullptr,
-                                    SourceLocation(), nullptr, nullptr);
+MSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
+  return new (C, ID)
+      MSPropertyDecl(nullptr, SourceLocation(), DeclarationName(), QualType(),
+                     nullptr, SourceLocation(), nullptr, nullptr);
 }
 
 void MSGuidDecl::anchor() {}
@@ -3277,7 +3271,7 @@
     : ValueDecl(Decl::MSGuid, DC, SourceLocation(), DeclarationName(), T),
       PartVal(P), APVal() {}
 
-MSGuidDecl *MSGuidDecl::Create(const ASTContext &C, QualType T, Parts P) {
+MSGuidDecl *MSGuidDecl::Create(ASTContext const &C, QualType T, Parts P) {
   DeclContext *DC = C.getTranslationUnitDecl();
   return new (C, DC) MSGuidDecl(DC, T, P);
 }
@@ -3306,8 +3300,7 @@
 
   auto IsInt = [&Ctx](unsigned N) {
     return [&Ctx, N](QualType T) {
-      return T->isUnsignedIntegerOrEnumerationType() &&
-             Ctx.getIntWidth(T) == N;
+      return T->isUnsignedIntegerOrEnumerationType() && Ctx.getIntWidth(T) == N;
     };
   };
 
@@ -3331,7 +3324,8 @@
           return false;
       auto MatcherIt = Fields.begin();
       for (const FieldDecl *FD : RD->fields()) {
-        if (FD->isUnnamedBitfield()) continue;
+        if (FD->isUnnamedBitfield())
+          continue;
         if (FD->isBitField() || MatcherIt == Fields.end() ||
             !(*MatcherIt)(FD->getType()))
           return false;
@@ -3367,21 +3361,21 @@
   return APVal;
 }
 
-static const char *getAccessName(AccessSpecifier AS) {
+static char const *getAccessName(AccessSpecifier AS) {
   switch (AS) {
-    case AS_none:
-      llvm_unreachable("Invalid access specifier!");
-    case AS_public:
-      return "public";
-    case AS_private:
-      return "private";
-    case AS_protected:
-      return "protected";
+  case AS_none:
+    llvm_unreachable("Invalid access specifier!");
+  case AS_public:
+    return "public";
+  case AS_private:
+    return "private";
+  case AS_protected:
+    return "protected";
   }
   llvm_unreachable("Invalid access specifier!");
 }
 
-const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
+StreamingDiagnostic const &clang::operator<<(StreamingDiagnostic const &DB,
                                              AccessSpecifier AS) {
   return DB << getAccessName(AS);
 }
Index: clang/lib/AST/DeclFriend.cpp
===================================================================
--- clang/lib/AST/DeclFriend.cpp
+++ clang/lib/AST/DeclFriend.cpp
@@ -12,10 +12,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/DeclFriend.h"
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
-#include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/Support/Casting.h"
@@ -28,21 +28,18 @@
 
 FriendDecl *FriendDecl::getNextFriendSlowCase() {
   return cast_or_null<FriendDecl>(
-                           NextFriend.get(getASTContext().getExternalSource()));
+      NextFriend.get(getASTContext().getExternalSource()));
 }
 
-FriendDecl *FriendDecl::Create(ASTContext &C, DeclContext *DC,
-                               SourceLocation L,
-                               FriendUnion Friend,
-                               SourceLocation FriendL,
-                          ArrayRef<TemplateParameterList *> FriendTypeTPLists) {
+FriendDecl *
+FriendDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
+                   FriendUnion Friend, SourceLocation FriendL,
+                   ArrayRef<TemplateParameterList *> FriendTypeTPLists) {
 #ifndef NDEBUG
   if (Friend.is<NamedDecl *>()) {
-    const auto *D = Friend.get<NamedDecl*>();
-    assert(isa<FunctionDecl>(D) ||
-           isa<CXXRecordDecl>(D) ||
-           isa<FunctionTemplateDecl>(D) ||
-           isa<ClassTemplateDecl>(D));
+    auto const *D = Friend.get<NamedDecl *>();
+    assert(isa<FunctionDecl>(D) || isa<CXXRecordDecl>(D) ||
+           isa<FunctionTemplateDecl>(D) || isa<ClassTemplateDecl>(D));
 
     // As a temporary hack, we permit template instantiation to point
     // to the original declaration when instantiating members.
@@ -56,8 +53,8 @@
   std::size_t Extra =
       FriendDecl::additionalSizeToAlloc<TemplateParameterList *>(
           FriendTypeTPLists.size());
-  auto *FD = new (C, DC, Extra) FriendDecl(DC, L, Friend, FriendL,
-                                           FriendTypeTPLists);
+  auto *FD =
+      new (C, DC, Extra) FriendDecl(DC, L, Friend, FriendL, FriendTypeTPLists);
   cast<CXXRecordDecl>(DC)->pushFriendDecl(FD);
   return FD;
 }
Index: clang/lib/AST/DeclGroup.cpp
===================================================================
--- clang/lib/AST/DeclGroup.cpp
+++ clang/lib/AST/DeclGroup.cpp
@@ -17,15 +17,15 @@
 
 using namespace clang;
 
-DeclGroup* DeclGroup::Create(ASTContext &C, Decl **Decls, unsigned NumDecls) {
+DeclGroup *DeclGroup::Create(ASTContext &C, Decl **Decls, unsigned NumDecls) {
   assert(NumDecls > 1 && "Invalid DeclGroup");
   unsigned Size = totalSizeToAlloc<Decl *>(NumDecls);
   void *Mem = C.Allocate(Size, alignof(DeclGroup));
   new (Mem) DeclGroup(NumDecls, Decls);
-  return static_cast<DeclGroup*>(Mem);
+  return static_cast<DeclGroup *>(Mem);
 }
 
-DeclGroup::DeclGroup(unsigned numdecls, Decl** decls) : NumDecls(numdecls) {
+DeclGroup::DeclGroup(unsigned numdecls, Decl **decls) : NumDecls(numdecls) {
   assert(numdecls > 0);
   assert(decls);
   std::uninitialized_copy(decls, decls + numdecls,
Index: clang/lib/AST/DeclObjC.cpp
===================================================================
--- clang/lib/AST/DeclObjC.cpp
+++ clang/lib/AST/DeclObjC.cpp
@@ -42,17 +42,18 @@
 // ObjCListBase
 //===----------------------------------------------------------------------===//
 
-void ObjCListBase::set(void *const* InList, unsigned Elts, ASTContext &Ctx) {
+void ObjCListBase::set(void *const *InList, unsigned Elts, ASTContext &Ctx) {
   List = nullptr;
-  if (Elts == 0) return;  // Setting to an empty list is a noop.
+  if (Elts == 0)
+    return; // Setting to an empty list is a noop.
 
-  List = new (Ctx) void*[Elts];
+  List = new (Ctx) void *[Elts];
   NumElts = Elts;
-  memcpy(List, InList, sizeof(void*)*Elts);
+  memcpy(List, InList, sizeof(void *) * Elts);
 }
 
-void ObjCProtocolList::set(ObjCProtocolDecl* const* InList, unsigned Elts,
-                           const SourceLocation *Locs, ASTContext &Ctx) {
+void ObjCProtocolList::set(ObjCProtocolDecl *const *InList, unsigned Elts,
+                           SourceLocation const *Locs, ASTContext &Ctx) {
   if (Elts == 0)
     return;
 
@@ -76,11 +77,10 @@
 
 /// getIvarDecl - This method looks up an ivar in this ContextDecl.
 ///
-ObjCIvarDecl *
-ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
+ObjCIvarDecl *ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
   lookup_result R = lookup(Id);
-  for (lookup_iterator Ivar = R.begin(), IvarEnd = R.end();
-       Ivar != IvarEnd; ++Ivar) {
+  for (lookup_iterator Ivar = R.begin(), IvarEnd = R.end(); Ivar != IvarEnd;
+       ++Ivar) {
     if (auto *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
       return ivar;
   }
@@ -88,13 +88,12 @@
 }
 
 // Get the local instance/class method declared in this interface.
-ObjCMethodDecl *
-ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
-                             bool AllowHidden) const {
+ObjCMethodDecl *ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
+                                             bool AllowHidden) const {
   // If this context is a hidden protocol definition, don't find any
   // methods there.
-  if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
-    if (const ObjCProtocolDecl *Def = Proto->getDefinition())
+  if (auto const *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
+    if (ObjCProtocolDecl const *Def = Proto->getDefinition())
       if (!Def->isUnconditionallyVisible() && !AllowHidden)
         return nullptr;
   }
@@ -107,8 +106,8 @@
   // + (float) class_method;
   // @end
   lookup_result R = lookup(Sel);
-  for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
-       Meth != MethEnd; ++Meth) {
+  for (lookup_iterator Meth = R.begin(), MethEnd = R.end(); Meth != MethEnd;
+       ++Meth) {
     auto *MD = dyn_cast<ObjCMethodDecl>(*Meth);
     if (MD && MD->isInstanceMethod() == isInstance)
       return MD;
@@ -122,20 +121,20 @@
 /// property.  This is because, user must provide a setter method for the
 /// category's 'readwrite' property.
 bool ObjCContainerDecl::HasUserDeclaredSetterMethod(
-    const ObjCPropertyDecl *Property) const {
+    ObjCPropertyDecl const *Property) const {
   Selector Sel = Property->getSetterName();
   lookup_result R = lookup(Sel);
-  for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
-       Meth != MethEnd; ++Meth) {
+  for (lookup_iterator Meth = R.begin(), MethEnd = R.end(); Meth != MethEnd;
+       ++Meth) {
     auto *MD = dyn_cast<ObjCMethodDecl>(*Meth);
     if (MD && MD->isInstanceMethod() && !MD->isImplicit())
       return true;
   }
 
-  if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
+  if (auto const *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
     // Also look into categories, including class extensions, looking
     // for a user declared instance method.
-    for (const auto *Cat : ID->visible_categories()) {
+    for (auto const *Cat : ID->visible_categories()) {
       if (ObjCMethodDecl *MD = Cat->getInstanceMethod(Sel))
         if (!MD->isImplicit())
           return true;
@@ -145,7 +144,7 @@
       // declaration of this property. If one found, presumably a setter will
       // be provided (properties declared in categories will not get
       // auto-synthesized).
-      for (const auto *P : Cat->properties())
+      for (auto const *P : Cat->properties())
         if (P->getIdentifier() == Property->getIdentifier()) {
           if (P->getPropertyAttributes() &
               ObjCPropertyAttribute::kind_readwrite)
@@ -155,7 +154,7 @@
     }
 
     // Also look into protocols, for a user declared instance method.
-    for (const auto *Proto : ID->all_referenced_protocols())
+    for (auto const *Proto : ID->all_referenced_protocols())
       if (Proto->HasUserDeclaredSetterMethod(Property))
         return true;
 
@@ -167,21 +166,21 @@
       OSC = OSC->getSuperClass();
     }
   }
-  if (const auto *PD = dyn_cast<ObjCProtocolDecl>(this))
-    for (const auto *PI : PD->protocols())
+  if (auto const *PD = dyn_cast<ObjCProtocolDecl>(this))
+    for (auto const *PI : PD->protocols())
       if (PI->HasUserDeclaredSetterMethod(Property))
         return true;
   return false;
 }
 
 ObjCPropertyDecl *
-ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
-                                   const IdentifierInfo *propertyID,
+ObjCPropertyDecl::findPropertyDecl(DeclContext const *DC,
+                                   IdentifierInfo const *propertyID,
                                    ObjCPropertyQueryKind queryKind) {
   // If this context is a hidden protocol definition, don't find any
   // property.
-  if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(DC)) {
-    if (const ObjCProtocolDecl *Def = Proto->getDefinition())
+  if (auto const *Proto = dyn_cast<ObjCProtocolDecl>(DC)) {
+    if (ObjCProtocolDecl const *Def = Proto->getDefinition())
       if (!Def->isUnconditionallyVisible())
         return nullptr;
   }
@@ -189,17 +188,15 @@
   // If context is class, then lookup property in its visible extensions.
   // This comes before property is looked up in primary class.
   if (auto *IDecl = dyn_cast<ObjCInterfaceDecl>(DC)) {
-    for (const auto *Ext : IDecl->visible_extensions())
-      if (ObjCPropertyDecl *PD = ObjCPropertyDecl::findPropertyDecl(Ext,
-                                                       propertyID,
-                                                       queryKind))
+    for (auto const *Ext : IDecl->visible_extensions())
+      if (ObjCPropertyDecl *PD =
+              ObjCPropertyDecl::findPropertyDecl(Ext, propertyID, queryKind))
         return PD;
   }
 
   DeclContext::lookup_result R = DC->lookup(propertyID);
   ObjCPropertyDecl *classProp = nullptr;
-  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
-       ++I)
+  for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I)
     if (auto *PD = dyn_cast<ObjCPropertyDecl>(*I)) {
       // If queryKind is unknown, we return the instance property if one
       // exists; otherwise we return the class property.
@@ -235,71 +232,69 @@
 /// FindPropertyDeclaration - Finds declaration of the property given its name
 /// in 'PropertyId' and returns it. It returns 0, if not found.
 ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration(
-    const IdentifierInfo *PropertyId,
-    ObjCPropertyQueryKind QueryKind) const {
+    IdentifierInfo const *PropertyId, ObjCPropertyQueryKind QueryKind) const {
   // Don't find properties within hidden protocol definitions.
-  if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
-    if (const ObjCProtocolDecl *Def = Proto->getDefinition())
+  if (auto const *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
+    if (ObjCProtocolDecl const *Def = Proto->getDefinition())
       if (!Def->isUnconditionallyVisible())
         return nullptr;
   }
 
   // Search the extensions of a class first; they override what's in
   // the class itself.
-  if (const auto *ClassDecl = dyn_cast<ObjCInterfaceDecl>(this)) {
-    for (const auto *Ext : ClassDecl->visible_extensions()) {
+  if (auto const *ClassDecl = dyn_cast<ObjCInterfaceDecl>(this)) {
+    for (auto const *Ext : ClassDecl->visible_extensions()) {
       if (auto *P = Ext->FindPropertyDeclaration(PropertyId, QueryKind))
         return P;
     }
   }
 
-  if (ObjCPropertyDecl *PD =
-        ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId,
-                                           QueryKind))
+  if (ObjCPropertyDecl *PD = ObjCPropertyDecl::findPropertyDecl(
+          cast<DeclContext>(this), PropertyId, QueryKind))
     return PD;
 
   switch (getKind()) {
-    default:
-      break;
-    case Decl::ObjCProtocol: {
-      const auto *PID = cast<ObjCProtocolDecl>(this);
-      for (const auto *I : PID->protocols())
-        if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
-                                                             QueryKind))
+  default:
+    break;
+  case Decl::ObjCProtocol: {
+    auto const *PID = cast<ObjCProtocolDecl>(this);
+    for (auto const *I : PID->protocols())
+      if (ObjCPropertyDecl *P =
+              I->FindPropertyDeclaration(PropertyId, QueryKind))
+        return P;
+    break;
+  }
+  case Decl::ObjCInterface: {
+    auto const *OID = cast<ObjCInterfaceDecl>(this);
+    // Look through categories (but not extensions; they were handled above).
+    for (auto const *Cat : OID->visible_categories()) {
+      if (!Cat->IsClassExtension())
+        if (ObjCPropertyDecl *P =
+                Cat->FindPropertyDeclaration(PropertyId, QueryKind))
           return P;
-      break;
     }
-    case Decl::ObjCInterface: {
-      const auto *OID = cast<ObjCInterfaceDecl>(this);
-      // Look through categories (but not extensions; they were handled above).
-      for (const auto *Cat : OID->visible_categories()) {
-        if (!Cat->IsClassExtension())
-          if (ObjCPropertyDecl *P = Cat->FindPropertyDeclaration(
-                                             PropertyId, QueryKind))
-            return P;
-      }
 
-      // Look through protocols.
-      for (const auto *I : OID->all_referenced_protocols())
-        if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
-                                                             QueryKind))
-          return P;
+    // Look through protocols.
+    for (auto const *I : OID->all_referenced_protocols())
+      if (ObjCPropertyDecl *P =
+              I->FindPropertyDeclaration(PropertyId, QueryKind))
+        return P;
 
-      // Finally, check the super class.
-      if (const ObjCInterfaceDecl *superClass = OID->getSuperClass())
-        return superClass->FindPropertyDeclaration(PropertyId, QueryKind);
-      break;
-    }
-    case Decl::ObjCCategory: {
-      const auto *OCD = cast<ObjCCategoryDecl>(this);
-      // Look through protocols.
-      if (!OCD->IsClassExtension())
-        for (const auto *I : OCD->protocols())
-          if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
-                                                               QueryKind))
-            return P;
-      break;
-    }
+    // Finally, check the super class.
+    if (ObjCInterfaceDecl const *superClass = OID->getSuperClass())
+      return superClass->FindPropertyDeclaration(PropertyId, QueryKind);
+    break;
+  }
+  case Decl::ObjCCategory: {
+    auto const *OCD = cast<ObjCCategoryDecl>(this);
+    // Look through protocols.
+    if (!OCD->IsClassExtension())
+      for (auto const *I : OCD->protocols())
+        if (ObjCPropertyDecl *P =
+                I->FindPropertyDeclaration(PropertyId, QueryKind))
+          return P;
+    break;
+  }
   }
   return nullptr;
 }
@@ -312,13 +307,13 @@
     return written;
 
   // If there is a definition, return its type parameter list.
-  if (const ObjCInterfaceDecl *def = getDefinition())
+  if (ObjCInterfaceDecl const *def = getDefinition())
     return def->getTypeParamListAsWritten();
 
   // Otherwise, look at previous declarations to determine whether any
   // of them has a type parameter list, skipping over those
   // declarations that do not.
-  for (const ObjCInterfaceDecl *decl = getMostRecentDecl(); decl;
+  for (ObjCInterfaceDecl const *decl = getMostRecentDecl(); decl;
        decl = decl->getPreviousDecl()) {
     if (ObjCTypeParamList *written = decl->getTypeParamListAsWritten())
       return written;
@@ -344,7 +339,7 @@
   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  if (const ObjCObjectType *superType = getSuperClassType()) {
+  if (ObjCObjectType const *superType = getSuperClassType()) {
     if (ObjCInterfaceDecl *superDecl = superType->getInterface()) {
       if (ObjCInterfaceDecl *superDef = superDecl->getDefinition())
         return superDef;
@@ -366,10 +361,8 @@
 /// FindPropertyVisibleInPrimaryClass - Finds declaration of the property
 /// with name 'PropertyId' in the primary class; including those in protocols
 /// (direct or indirect) used by the primary class.
-ObjCPropertyDecl *
-ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
-                       IdentifierInfo *PropertyId,
-                       ObjCPropertyQueryKind QueryKind) const {
+ObjCPropertyDecl *ObjCInterfaceDecl::FindPropertyVisibleInPrimaryClass(
+    IdentifierInfo *PropertyId, ObjCPropertyQueryKind QueryKind) const {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;
@@ -377,34 +370,32 @@
   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  if (ObjCPropertyDecl *PD =
-      ObjCPropertyDecl::findPropertyDecl(cast<DeclContext>(this), PropertyId,
-                                         QueryKind))
+  if (ObjCPropertyDecl *PD = ObjCPropertyDecl::findPropertyDecl(
+          cast<DeclContext>(this), PropertyId, QueryKind))
     return PD;
 
   // Look through protocols.
-  for (const auto *I : all_referenced_protocols())
-    if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
-                                                         QueryKind))
+  for (auto const *I : all_referenced_protocols())
+    if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId, QueryKind))
       return P;
 
   return nullptr;
 }
 
-void ObjCInterfaceDecl::collectPropertiesToImplement(PropertyMap &PM,
-                                                     PropertyDeclOrder &PO) const {
+void ObjCInterfaceDecl::collectPropertiesToImplement(
+    PropertyMap &PM, PropertyDeclOrder &PO) const {
   for (auto *Prop : properties()) {
     PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
     PO.push_back(Prop);
   }
-  for (const auto *Ext : known_extensions()) {
-    const ObjCCategoryDecl *ClassExt = Ext;
+  for (auto const *Ext : known_extensions()) {
+    ObjCCategoryDecl const *ClassExt = Ext;
     for (auto *Prop : ClassExt->properties()) {
       PM[std::make_pair(Prop->getIdentifier(), Prop->isClassProperty())] = Prop;
       PO.push_back(Prop);
     }
   }
-  for (const auto *PI : all_referenced_protocols())
+  for (auto const *PI : all_referenced_protocols())
     PI->collectPropertiesToImplement(PM, PO);
   // Note, the properties declared only in class extensions are still copied
   // into the main @interface's property list, and therefore we don't
@@ -412,7 +403,7 @@
 }
 
 bool ObjCInterfaceDecl::isArcWeakrefUnavailable() const {
-  const ObjCInterfaceDecl *Class = this;
+  ObjCInterfaceDecl const *Class = this;
   while (Class) {
     if (Class->hasAttr<ArcWeakrefUnavailableAttr>())
       return true;
@@ -421,8 +412,8 @@
   return false;
 }
 
-const ObjCInterfaceDecl *ObjCInterfaceDecl::isObjCRequiresPropertyDefs() const {
-  const ObjCInterfaceDecl *Class = this;
+ObjCInterfaceDecl const *ObjCInterfaceDecl::isObjCRequiresPropertyDefs() const {
+  ObjCInterfaceDecl const *Class = this;
   while (Class) {
     if (Class->hasAttr<ObjCRequiresPropertyDefsAttr>())
       return Class;
@@ -432,8 +423,7 @@
 }
 
 void ObjCInterfaceDecl::mergeClassExtensionProtocolList(
-                              ObjCProtocolDecl *const* ExtList, unsigned ExtNum,
-                              ASTContext &C) {
+    ObjCProtocolDecl *const *ExtList, unsigned ExtNum, ASTContext &C) {
   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
@@ -469,12 +459,13 @@
   ProtocolRefs.append(all_referenced_protocol_begin(),
                       all_referenced_protocol_end());
 
-  data().AllReferencedProtocols.set(ProtocolRefs.data(), ProtocolRefs.size(),C);
+  data().AllReferencedProtocols.set(ProtocolRefs.data(), ProtocolRefs.size(),
+                                    C);
 }
 
-const ObjCInterfaceDecl *
+ObjCInterfaceDecl const *
 ObjCInterfaceDecl::findInterfaceWithDesignatedInitializers() const {
-  const ObjCInterfaceDecl *IFace = this;
+  ObjCInterfaceDecl const *IFace = this;
   while (IFace) {
     if (IFace->hasDesignatedInitializers())
       return IFace;
@@ -485,19 +476,19 @@
   return nullptr;
 }
 
-static bool isIntroducingInitializers(const ObjCInterfaceDecl *D) {
-  for (const auto *MD : D->instance_methods()) {
+static bool isIntroducingInitializers(ObjCInterfaceDecl const *D) {
+  for (auto const *MD : D->instance_methods()) {
     if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
       return true;
   }
-  for (const auto *Ext : D->visible_extensions()) {
-    for (const auto *MD : Ext->instance_methods()) {
+  for (auto const *Ext : D->visible_extensions()) {
+    for (auto const *MD : Ext->instance_methods()) {
       if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
         return true;
     }
   }
-  if (const auto *ImplD = D->getImplementation()) {
-    for (const auto *MD : ImplD->instance_methods()) {
+  if (auto const *ImplD = D->getImplementation()) {
+    for (auto const *MD : ImplD->instance_methods()) {
       if (MD->getMethodFamily() == OMF_init && !MD->isOverriding())
         return true;
     }
@@ -520,47 +511,47 @@
     } else {
       if (auto SuperD = getSuperClass()) {
         data().InheritedDesignatedInitializers =
-          SuperD->declaresOrInheritsDesignatedInitializers() ?
-            DefinitionData::IDI_Inherited :
-            DefinitionData::IDI_NotInherited;
+            SuperD->declaresOrInheritsDesignatedInitializers()
+                ? DefinitionData::IDI_Inherited
+                : DefinitionData::IDI_NotInherited;
       } else {
         data().InheritedDesignatedInitializers =
-          DefinitionData::IDI_NotInherited;
+            DefinitionData::IDI_NotInherited;
       }
     }
-    assert(data().InheritedDesignatedInitializers
-             != DefinitionData::IDI_Unknown);
+    assert(data().InheritedDesignatedInitializers !=
+           DefinitionData::IDI_Unknown);
     return data().InheritedDesignatedInitializers ==
-        DefinitionData::IDI_Inherited;
+           DefinitionData::IDI_Inherited;
   }
 
   llvm_unreachable("unexpected InheritedDesignatedInitializers value");
 }
 
 void ObjCInterfaceDecl::getDesignatedInitializers(
-    llvm::SmallVectorImpl<const ObjCMethodDecl *> &Methods) const {
+    llvm::SmallVectorImpl<ObjCMethodDecl const *> &Methods) const {
   // Check for a complete definition and recover if not so.
   if (!isThisDeclarationADefinition())
     return;
   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  const ObjCInterfaceDecl *IFace= findInterfaceWithDesignatedInitializers();
+  ObjCInterfaceDecl const *IFace = findInterfaceWithDesignatedInitializers();
   if (!IFace)
     return;
 
-  for (const auto *MD : IFace->instance_methods())
+  for (auto const *MD : IFace->instance_methods())
     if (MD->isThisDeclarationADesignatedInitializer())
       Methods.push_back(MD);
-  for (const auto *Ext : IFace->visible_extensions()) {
-    for (const auto *MD : Ext->instance_methods())
+  for (auto const *Ext : IFace->visible_extensions()) {
+    for (auto const *MD : Ext->instance_methods())
       if (MD->isThisDeclarationADesignatedInitializer())
         Methods.push_back(MD);
   }
 }
 
-bool ObjCInterfaceDecl::isDesignatedInitializer(Selector Sel,
-                                      const ObjCMethodDecl **InitMethod) const {
+bool ObjCInterfaceDecl::isDesignatedInitializer(
+    Selector Sel, ObjCMethodDecl const **InitMethod) const {
   bool HasCompleteDef = isThisDeclarationADefinition();
   // During deserialization the data record for the ObjCInterfaceDecl could
   // be made invariant by reusing the canonical decl. Take this into account
@@ -576,19 +567,19 @@
   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  const ObjCInterfaceDecl *IFace= findInterfaceWithDesignatedInitializers();
+  ObjCInterfaceDecl const *IFace = findInterfaceWithDesignatedInitializers();
   if (!IFace)
     return false;
 
-  if (const ObjCMethodDecl *MD = IFace->getInstanceMethod(Sel)) {
+  if (ObjCMethodDecl const *MD = IFace->getInstanceMethod(Sel)) {
     if (MD->isThisDeclarationADesignatedInitializer()) {
       if (InitMethod)
         *InitMethod = MD;
       return true;
     }
   }
-  for (const auto *Ext : IFace->visible_extensions()) {
-    if (const ObjCMethodDecl *MD = Ext->getInstanceMethod(Sel)) {
+  for (auto const *Ext : IFace->visible_extensions()) {
+    if (ObjCMethodDecl const *MD = Ext->getInstanceMethod(Sel)) {
       if (MD->isThisDeclarationADesignatedInitializer()) {
         if (InitMethod)
           *InitMethod = MD;
@@ -619,8 +610,9 @@
   }
 }
 
-ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
-                                              ObjCInterfaceDecl *&clsDeclared) {
+ObjCIvarDecl *
+ObjCInterfaceDecl::lookupInstanceVariable(IdentifierInfo *ID,
+                                          ObjCInterfaceDecl *&clsDeclared) {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;
@@ -628,14 +620,14 @@
   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  ObjCInterfaceDecl* ClassDecl = this;
+  ObjCInterfaceDecl *ClassDecl = this;
   while (ClassDecl != nullptr) {
     if (ObjCIvarDecl *I = ClassDecl->getIvarDecl(ID)) {
       clsDeclared = ClassDecl;
       return I;
     }
 
-    for (const auto *Ext : ClassDecl->visible_extensions()) {
+    for (auto const *Ext : ClassDecl->visible_extensions()) {
       if (ObjCIvarDecl *I = Ext->getIvarDecl(ID)) {
         clsDeclared = ClassDecl;
         return I;
@@ -648,10 +640,10 @@
 }
 
 /// lookupInheritedClass - This method returns ObjCInterfaceDecl * of the super
-/// class whose name is passed as argument. If it is not one of the super classes
-/// the it returns NULL.
-ObjCInterfaceDecl *ObjCInterfaceDecl::lookupInheritedClass(
-                                        const IdentifierInfo*ICName) {
+/// class whose name is passed as argument. If it is not one of the super
+/// classes the it returns NULL.
+ObjCInterfaceDecl *
+ObjCInterfaceDecl::lookupInheritedClass(IdentifierInfo const *ICName) {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;
@@ -659,7 +651,7 @@
   if (data().ExternallyCompleted)
     LoadExternalDefinition();
 
-  ObjCInterfaceDecl* ClassDecl = this;
+  ObjCInterfaceDecl *ClassDecl = this;
   while (ClassDecl != nullptr) {
     if (ClassDecl->getIdentifier() == ICName)
       return ClassDecl;
@@ -681,17 +673,15 @@
 /// the class, its categories, and its super classes (using a linear search).
 /// When argument category "C" is specified, any implicit method found
 /// in this category is ignored.
-ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
-                                                bool isInstance,
-                                                bool shallowCategoryLookup,
-                                                bool followSuper,
-                                                const ObjCCategoryDecl *C) const
-{
+ObjCMethodDecl *
+ObjCInterfaceDecl::lookupMethod(Selector Sel, bool isInstance,
+                                bool shallowCategoryLookup, bool followSuper,
+                                ObjCCategoryDecl const *C) const {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;
 
-  const ObjCInterfaceDecl* ClassDecl = this;
+  ObjCInterfaceDecl const *ClassDecl = this;
   ObjCMethodDecl *MethodDecl = nullptr;
 
   if (data().ExternallyCompleted)
@@ -703,29 +693,28 @@
       return MethodDecl;
 
     // 2. Didn't find one yet - now look through categories.
-    for (const auto *Cat : ClassDecl->visible_categories())
+    for (auto const *Cat : ClassDecl->visible_categories())
       if ((MethodDecl = Cat->getMethod(Sel, isInstance)))
         if (C != Cat || !MethodDecl->isImplicit())
           return MethodDecl;
 
     // 3. Didn't find one yet - look through primary class's protocols.
-    for (const auto *I : ClassDecl->protocols())
+    for (auto const *I : ClassDecl->protocols())
       if ((MethodDecl = I->lookupMethod(Sel, isInstance)))
         return MethodDecl;
 
     // 4. Didn't find one yet - now look through categories' protocols
     if (!shallowCategoryLookup)
-      for (const auto *Cat : ClassDecl->visible_categories()) {
+      for (auto const *Cat : ClassDecl->visible_categories()) {
         // Didn't find one yet - look through protocols.
-        const ObjCList<ObjCProtocolDecl> &Protocols =
-          Cat->getReferencedProtocols();
+        ObjCList<ObjCProtocolDecl> const &Protocols =
+            Cat->getReferencedProtocols();
         for (auto *Protocol : Protocols)
           if ((MethodDecl = Protocol->lookupMethod(Sel, isInstance)))
             if (C != Cat || !MethodDecl->isImplicit())
               return MethodDecl;
       }
 
-
     if (!followSuper)
       return nullptr;
 
@@ -738,9 +727,8 @@
 // Will search "local" class/category implementations for a method decl.
 // If failed, then we search in class's root for an instance method.
 // Returns 0 if no method is found.
-ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(
-                                   const Selector &Sel,
-                                   bool Instance) const {
+ObjCMethodDecl *ObjCInterfaceDecl::lookupPrivateMethod(Selector const &Sel,
+                                                       bool Instance) const {
   // FIXME: Should make sure no callers ever do this.
   if (!hasDefinition())
     return nullptr;
@@ -832,25 +820,25 @@
 
 bool ObjCMethodDecl::isThisDeclarationADesignatedInitializer() const {
   return getMethodFamily() == OMF_init &&
-      hasAttr<ObjCDesignatedInitializerAttr>();
+         hasAttr<ObjCDesignatedInitializerAttr>();
 }
 
-bool ObjCMethodDecl::definedInNSObject(const ASTContext &Ctx) const {
-  if (const auto *PD = dyn_cast<const ObjCProtocolDecl>(getDeclContext()))
+bool ObjCMethodDecl::definedInNSObject(ASTContext const &Ctx) const {
+  if (auto const *PD = dyn_cast<const ObjCProtocolDecl>(getDeclContext()))
     return PD->getIdentifier() == Ctx.getNSObjectName();
-  if (const auto *ID = dyn_cast<const ObjCInterfaceDecl>(getDeclContext()))
+  if (auto const *ID = dyn_cast<const ObjCInterfaceDecl>(getDeclContext()))
     return ID->getIdentifier() == Ctx.getNSObjectName();
   return false;
 }
 
 bool ObjCMethodDecl::isDesignatedInitializerForTheInterface(
-    const ObjCMethodDecl **InitMethod) const {
+    ObjCMethodDecl const **InitMethod) const {
   if (getMethodFamily() != OMF_init)
     return false;
-  const DeclContext *DC = getDeclContext();
+  DeclContext const *DC = getDeclContext();
   if (isa<ObjCProtocolDecl>(DC))
     return false;
-  if (const ObjCInterfaceDecl *ID = getClassInterface())
+  if (ObjCInterfaceDecl const *ID = getClassInterface())
     return ID->isDesignatedInitializer(getSelector(), InitMethod);
   return false;
 }
@@ -859,7 +847,7 @@
   return Body.get(getASTContext().getExternalSource());
 }
 
-void ObjCMethodDecl::setAsRedeclaration(const ObjCMethodDecl *PrevMethod) {
+void ObjCMethodDecl::setAsRedeclaration(ObjCMethodDecl const *PrevMethod) {
   assert(PrevMethod);
   getASTContext().setObjCMethodRedeclaration(PrevMethod, this);
   setIsRedeclaration(true);
@@ -867,7 +855,7 @@
 }
 
 void ObjCMethodDecl::setParamsAndSelLocs(ASTContext &C,
-                                         ArrayRef<ParmVarDecl*> Params,
+                                         ArrayRef<ParmVarDecl *> Params,
                                          ArrayRef<SourceLocation> SelLocs) {
   ParamsAndSelLocs = nullptr;
   NumParams = Params.size();
@@ -885,21 +873,21 @@
 }
 
 void ObjCMethodDecl::getSelectorLocs(
-                               SmallVectorImpl<SourceLocation> &SelLocs) const {
+    SmallVectorImpl<SourceLocation> &SelLocs) const {
   for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i)
     SelLocs.push_back(getSelectorLoc(i));
 }
 
 void ObjCMethodDecl::setMethodParams(ASTContext &C,
-                                     ArrayRef<ParmVarDecl*> Params,
+                                     ArrayRef<ParmVarDecl *> Params,
                                      ArrayRef<SourceLocation> SelLocs) {
   assert((!SelLocs.empty() || isImplicit()) &&
          "No selector locs for non-implicit method");
   if (isImplicit())
     return setParamsAndSelLocs(C, Params, llvm::None);
 
-  setSelLocsKind(hasStandardSelectorLocs(getSelector(), SelLocs, Params,
-                                        DeclEndLoc));
+  setSelLocsKind(
+      hasStandardSelectorLocs(getSelector(), SelLocs, Params, DeclEndLoc));
   if (getSelLocsKind() != SelLoc_NonStandard)
     return setParamsAndSelLocs(C, Params, llvm::None);
 
@@ -913,7 +901,7 @@
   ASTContext &Ctx = getASTContext();
   ObjCMethodDecl *Redecl = nullptr;
   if (hasRedeclaration())
-    Redecl = const_cast<ObjCMethodDecl*>(Ctx.getObjCMethodRedeclaration(this));
+    Redecl = const_cast<ObjCMethodDecl *>(Ctx.getObjCMethodRedeclaration(this));
   if (Redecl)
     return Redecl;
 
@@ -960,7 +948,7 @@
 
 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() {
   auto *CtxD = cast<Decl>(getDeclContext());
-  const auto &Sel = getSelector();
+  auto const &Sel = getSelector();
 
   if (auto *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface()) {
@@ -1005,16 +993,28 @@
     return family;
 
   // Check for an explicit attribute.
-  if (const ObjCMethodFamilyAttr *attr = getAttr<ObjCMethodFamilyAttr>()) {
+  if (ObjCMethodFamilyAttr const *attr = getAttr<ObjCMethodFamilyAttr>()) {
     // The unfortunate necessity of mapping between enums here is due
     // to the attributes framework.
     switch (attr->getFamily()) {
-    case ObjCMethodFamilyAttr::OMF_None: family = OMF_None; break;
-    case ObjCMethodFamilyAttr::OMF_alloc: family = OMF_alloc; break;
-    case ObjCMethodFamilyAttr::OMF_copy: family = OMF_copy; break;
-    case ObjCMethodFamilyAttr::OMF_init: family = OMF_init; break;
-    case ObjCMethodFamilyAttr::OMF_mutableCopy: family = OMF_mutableCopy; break;
-    case ObjCMethodFamilyAttr::OMF_new: family = OMF_new; break;
+    case ObjCMethodFamilyAttr::OMF_None:
+      family = OMF_None;
+      break;
+    case ObjCMethodFamilyAttr::OMF_alloc:
+      family = OMF_alloc;
+      break;
+    case ObjCMethodFamilyAttr::OMF_copy:
+      family = OMF_copy;
+      break;
+    case ObjCMethodFamilyAttr::OMF_init:
+      family = OMF_init;
+      break;
+    case ObjCMethodFamilyAttr::OMF_mutableCopy:
+      family = OMF_mutableCopy;
+      break;
+    case ObjCMethodFamilyAttr::OMF_new:
+      family = OMF_new;
+      break;
     }
     ObjCMethodDeclBits.Family = family;
     return family;
@@ -1022,7 +1022,8 @@
 
   family = getSelector().getMethodFamily();
   switch (family) {
-  case OMF_None: break;
+  case OMF_None:
+    break;
 
   // init only has a conventional meaning for an instance method, and
   // it has to return an object.
@@ -1083,7 +1084,6 @@
       }
     }
     break;
-
   }
 
   // Cache the result.
@@ -1092,7 +1092,7 @@
 }
 
 QualType ObjCMethodDecl::getSelfType(ASTContext &Context,
-                                     const ObjCInterfaceDecl *OID,
+                                     ObjCInterfaceDecl const *OID,
                                      bool &selfIsPseudoStrong,
                                      bool &selfIsConsumed) const {
   QualType selfTy;
@@ -1125,8 +1125,7 @@
         selfTy = selfTy.withConst();
         selfIsPseudoStrong = true;
       }
-    }
-    else {
+    } else {
       assert(isClassMethod());
       // 'self' is always const in class methods.
       selfTy = selfTy.withConst();
@@ -1137,10 +1136,10 @@
 }
 
 void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
-                                          const ObjCInterfaceDecl *OID) {
+                                          ObjCInterfaceDecl const *OID) {
   bool selfIsPseudoStrong, selfIsConsumed;
   QualType selfTy =
-    getSelfType(Context, OID, selfIsPseudoStrong, selfIsConsumed);
+      getSelfType(Context, OID, selfIsPseudoStrong, selfIsConsumed);
   auto *Self = ImplicitParamDecl::Create(Context, this, SourceLocation(),
                                          &Context.Idents.get("self"), selfTy,
                                          ImplicitParamDecl::ObjCSelf);
@@ -1178,7 +1177,7 @@
 }
 
 SourceRange ObjCMethodDecl::getReturnTypeSourceRange() const {
-  const auto *TSI = getReturnTypeSourceInfo();
+  auto const *TSI = getReturnTypeSourceInfo();
   if (TSI)
     return TSI->getTypeLoc().getSourceRange();
   return SourceRange();
@@ -1186,36 +1185,35 @@
 
 QualType ObjCMethodDecl::getSendResultType() const {
   ASTContext &Ctx = getASTContext();
-  return getReturnType().getNonLValueExprType(Ctx)
-           .substObjCTypeArgs(Ctx, {}, ObjCSubstitutionContext::Result);
+  return getReturnType().getNonLValueExprType(Ctx).substObjCTypeArgs(
+      Ctx, {}, ObjCSubstitutionContext::Result);
 }
 
 QualType ObjCMethodDecl::getSendResultType(QualType receiverType) const {
   // FIXME: Handle related result types here.
 
-  return getReturnType().getNonLValueExprType(getASTContext())
-           .substObjCMemberType(receiverType, getDeclContext(),
-                                ObjCSubstitutionContext::Result);
+  return getReturnType()
+      .getNonLValueExprType(getASTContext())
+      .substObjCMemberType(receiverType, getDeclContext(),
+                           ObjCSubstitutionContext::Result);
 }
 
-static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
-                                            const ObjCMethodDecl *Method,
-                               SmallVectorImpl<const ObjCMethodDecl *> &Methods,
-                                            bool MovedToSuper) {
+static void CollectOverriddenMethodsRecurse(
+    ObjCContainerDecl const *Container, ObjCMethodDecl const *Method,
+    SmallVectorImpl<ObjCMethodDecl const *> &Methods, bool MovedToSuper) {
   if (!Container)
     return;
 
   // In categories look for overridden methods from protocols. A method from
   // category is not "overridden" since it is considered as the "same" method
   // (same USR) as the one from the interface.
-  if (const auto *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
+  if (auto const *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
     // Check whether we have a matching method at this category but only if we
     // are at the super class level.
     if (MovedToSuper)
-      if (ObjCMethodDecl *
-            Overridden = Container->getMethod(Method->getSelector(),
-                                              Method->isInstanceMethod(),
-                                              /*AllowHidden=*/true))
+      if (ObjCMethodDecl *Overridden = Container->getMethod(
+              Method->getSelector(), Method->isInstanceMethod(),
+              /*AllowHidden=*/true))
         if (Method != Overridden) {
           // We found an override at this category; there is no need to look
           // into its protocols.
@@ -1223,16 +1221,15 @@
           return;
         }
 
-    for (const auto *P : Category->protocols())
+    for (auto const *P : Category->protocols())
       CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
     return;
   }
 
   // Check whether we have a matching method at this level.
-  if (const ObjCMethodDecl *
-        Overridden = Container->getMethod(Method->getSelector(),
-                                          Method->isInstanceMethod(),
-                                          /*AllowHidden=*/true))
+  if (ObjCMethodDecl const *Overridden = Container->getMethod(
+          Method->getSelector(), Method->isInstanceMethod(),
+          /*AllowHidden=*/true))
     if (Method != Overridden) {
       // We found an override at this level; there is no need to look
       // into other protocols or categories.
@@ -1240,75 +1237,77 @@
       return;
     }
 
-  if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)){
-    for (const auto *P : Protocol->protocols())
+  if (auto const *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
+    for (auto const *P : Protocol->protocols())
       CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
   }
 
-  if (const auto *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
-    for (const auto *P : Interface->protocols())
+  if (auto const *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
+    for (auto const *P : Interface->protocols())
       CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
 
-    for (const auto *Cat : Interface->known_categories())
+    for (auto const *Cat : Interface->known_categories())
       CollectOverriddenMethodsRecurse(Cat, Method, Methods, MovedToSuper);
 
-    if (const ObjCInterfaceDecl *Super = Interface->getSuperClass())
+    if (ObjCInterfaceDecl const *Super = Interface->getSuperClass())
       return CollectOverriddenMethodsRecurse(Super, Method, Methods,
                                              /*MovedToSuper=*/true);
   }
 }
 
-static inline void CollectOverriddenMethods(const ObjCContainerDecl *Container,
-                                            const ObjCMethodDecl *Method,
-                             SmallVectorImpl<const ObjCMethodDecl *> &Methods) {
+inline static void
+CollectOverriddenMethods(ObjCContainerDecl const *Container,
+                         ObjCMethodDecl const *Method,
+                         SmallVectorImpl<ObjCMethodDecl const *> &Methods) {
   CollectOverriddenMethodsRecurse(Container, Method, Methods,
                                   /*MovedToSuper=*/false);
 }
 
-static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method,
-                          SmallVectorImpl<const ObjCMethodDecl *> &overridden) {
+static void collectOverriddenMethodsSlow(
+    ObjCMethodDecl const *Method,
+    SmallVectorImpl<ObjCMethodDecl const *> &overridden) {
   assert(Method->isOverriding());
 
-  if (const auto *ProtD =
+  if (auto const *ProtD =
           dyn_cast<ObjCProtocolDecl>(Method->getDeclContext())) {
     CollectOverriddenMethods(ProtD, Method, overridden);
 
-  } else if (const auto *IMD =
+  } else if (auto const *IMD =
                  dyn_cast<ObjCImplDecl>(Method->getDeclContext())) {
-    const ObjCInterfaceDecl *ID = IMD->getClassInterface();
+    ObjCInterfaceDecl const *ID = IMD->getClassInterface();
     if (!ID)
       return;
     // Start searching for overridden methods using the method from the
     // interface as starting point.
-    if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
-                                                    Method->isInstanceMethod(),
-                                                    /*AllowHidden=*/true))
+    if (ObjCMethodDecl const *IFaceMeth =
+            ID->getMethod(Method->getSelector(), Method->isInstanceMethod(),
+                          /*AllowHidden=*/true))
       Method = IFaceMeth;
     CollectOverriddenMethods(ID, Method, overridden);
 
-  } else if (const auto *CatD =
+  } else if (auto const *CatD =
                  dyn_cast<ObjCCategoryDecl>(Method->getDeclContext())) {
-    const ObjCInterfaceDecl *ID = CatD->getClassInterface();
+    ObjCInterfaceDecl const *ID = CatD->getClassInterface();
     if (!ID)
       return;
     // Start searching for overridden methods using the method from the
     // interface as starting point.
-    if (const ObjCMethodDecl *IFaceMeth = ID->getMethod(Method->getSelector(),
-                                                     Method->isInstanceMethod(),
-                                                     /*AllowHidden=*/true))
+    if (ObjCMethodDecl const *IFaceMeth =
+            ID->getMethod(Method->getSelector(), Method->isInstanceMethod(),
+                          /*AllowHidden=*/true))
       Method = IFaceMeth;
     CollectOverriddenMethods(ID, Method, overridden);
 
   } else {
     CollectOverriddenMethods(
-                  dyn_cast_or_null<ObjCContainerDecl>(Method->getDeclContext()),
-                  Method, overridden);
+        dyn_cast_or_null<ObjCContainerDecl>(Method->getDeclContext()), Method,
+        overridden);
   }
 }
 
 void ObjCMethodDecl::getOverriddenMethods(
-                    SmallVectorImpl<const ObjCMethodDecl *> &Overridden) const {
-  const ObjCMethodDecl *Method = this;
+    SmallVectorImpl<ObjCMethodDecl const *> &Overridden) const {
+  ObjCMethodDecl const *Method = this;
 
   if (Method->isRedeclaration()) {
     Method = cast<ObjCContainerDecl>(Method->getDeclContext())
@@ -1323,7 +1322,7 @@
   }
 }
 
-const ObjCPropertyDecl *
+ObjCPropertyDecl const *
 ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const {
   Selector Sel = getSelector();
   unsigned NumArgs = Sel.getNumArgs();
@@ -1331,7 +1330,7 @@
     return nullptr;
 
   if (isPropertyAccessor()) {
-    const auto *Container = cast<ObjCContainerDecl>(getParent());
+    auto const *Container = cast<ObjCContainerDecl>(getParent());
     // For accessor stubs, go back to the interface.
     if (auto *ImplDecl = dyn_cast<ObjCImplDecl>(Container))
       if (isSynthesizedAccessorStub())
@@ -1343,18 +1342,16 @@
     /// Local function that attempts to find a matching property within the
     /// given Objective-C container.
     auto findMatchingProperty =
-      [&](const ObjCContainerDecl *Container) -> const ObjCPropertyDecl * {
+        [&](ObjCContainerDecl const *Container) -> ObjCPropertyDecl const * {
       if (IsInstance) {
         for (const auto *I : Container->instance_properties()) {
-          Selector NextSel = IsGetter ? I->getGetterName()
-                                      : I->getSetterName();
+          Selector NextSel = IsGetter ? I->getGetterName() : I->getSetterName();
           if (NextSel == Sel)
             return I;
         }
       } else {
         for (const auto *I : Container->class_properties()) {
-          Selector NextSel = IsGetter ? I->getGetterName()
-                                      : I->getSetterName();
+          Selector NextSel = IsGetter ? I->getGetterName() : I->getSetterName();
           if (NextSel == Sel)
             return I;
         }
@@ -1364,14 +1361,14 @@
     };
 
     // Look in the container we were given.
-    if (const auto *Found = findMatchingProperty(Container))
+    if (auto const *Found = findMatchingProperty(Container))
       return Found;
 
     // If we're in a category or extension, look in the main class.
-    const ObjCInterfaceDecl *ClassDecl = nullptr;
-    if (const auto *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
+    ObjCInterfaceDecl const *ClassDecl = nullptr;
+    if (auto const *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
       ClassDecl = Category->getClassInterface();
-      if (const auto *Found = findMatchingProperty(ClassDecl))
+      if (auto const *Found = findMatchingProperty(ClassDecl))
         return Found;
     } else {
       // Determine whether the container is a class.
@@ -1380,19 +1377,19 @@
     assert(ClassDecl && "Failed to find main class");
 
     // If we have a class, check its visible extensions.
-    for (const auto *Ext : ClassDecl->visible_extensions()) {
+    for (auto const *Ext : ClassDecl->visible_extensions()) {
       if (Ext == Container)
         continue;
-      if (const auto *Found = findMatchingProperty(Ext))
+      if (auto const *Found = findMatchingProperty(Ext))
         return Found;
     }
 
     assert(isSynthesizedAccessorStub() && "expected an accessor stub");
 
-    for (const auto *Cat : ClassDecl->known_categories()) {
+    for (auto const *Cat : ClassDecl->known_categories()) {
       if (Cat == Container)
         continue;
-      if (const auto *Found = findMatchingProperty(Cat))
+      if (auto const *Found = findMatchingProperty(Cat))
         return Found;
     }
 
@@ -1402,12 +1399,12 @@
   if (!CheckOverrides)
     return nullptr;
 
-  using OverridesTy = SmallVector<const ObjCMethodDecl *, 8>;
+  using OverridesTy = SmallVector<ObjCMethodDecl const *, 8>;
 
   OverridesTy Overrides;
   getOverriddenMethods(Overrides);
-  for (const auto *Override : Overrides)
-    if (const ObjCPropertyDecl *Prop = Override->findPropertyDecl(false))
+  for (auto const *Override : Overrides)
+    if (ObjCPropertyDecl const *Prop = Override->findPropertyDecl(false))
       return Prop;
 
   return nullptr;
@@ -1419,17 +1416,13 @@
 
 void ObjCTypeParamDecl::anchor() {}
 
-ObjCTypeParamDecl *ObjCTypeParamDecl::Create(ASTContext &ctx, DeclContext *dc,
-                                             ObjCTypeParamVariance variance,
-                                             SourceLocation varianceLoc,
-                                             unsigned index,
-                                             SourceLocation nameLoc,
-                                             IdentifierInfo *name,
-                                             SourceLocation colonLoc,
-                                             TypeSourceInfo *boundInfo) {
+ObjCTypeParamDecl *ObjCTypeParamDecl::Create(
+    ASTContext &ctx, DeclContext *dc, ObjCTypeParamVariance variance,
+    SourceLocation varianceLoc, unsigned index, SourceLocation nameLoc,
+    IdentifierInfo *name, SourceLocation colonLoc, TypeSourceInfo *boundInfo) {
   auto *TPDecl =
-    new (ctx, dc) ObjCTypeParamDecl(ctx, dc, variance, varianceLoc, index,
-                                    nameLoc, name, colonLoc, boundInfo);
+      new (ctx, dc) ObjCTypeParamDecl(ctx, dc, variance, varianceLoc, index,
+                                      nameLoc, name, colonLoc, boundInfo);
   QualType TPType = ctx.getObjCTypeParamType(TPDecl, {});
   TPDecl->setTypeForDecl(TPType.getTypePtr());
   return TPDecl;
@@ -1437,10 +1430,9 @@
 
 ObjCTypeParamDecl *ObjCTypeParamDecl::CreateDeserialized(ASTContext &ctx,
                                                          unsigned ID) {
-  return new (ctx, ID) ObjCTypeParamDecl(ctx, nullptr,
-                                         ObjCTypeParamVariance::Invariant,
-                                         SourceLocation(), 0, SourceLocation(),
-                                         nullptr, SourceLocation(), nullptr);
+  return new (ctx, ID) ObjCTypeParamDecl(
+      ctx, nullptr, ObjCTypeParamVariance::Invariant, SourceLocation(), 0,
+      SourceLocation(), nullptr, SourceLocation(), nullptr);
 }
 
 SourceRange ObjCTypeParamDecl::getSourceRange() const {
@@ -1449,8 +1441,7 @@
     startLoc = getLocation();
 
   if (hasExplicitBound()) {
-    return SourceRange(startLoc,
-                       getTypeSourceInfo()->getTypeLoc().getEndLoc());
+    return SourceRange(startLoc, getTypeSourceInfo()->getTypeLoc().getEndLoc());
   }
 
   return SourceRange(startLoc);
@@ -1466,11 +1457,10 @@
   std::copy(typeParams.begin(), typeParams.end(), begin());
 }
 
-ObjCTypeParamList *ObjCTypeParamList::create(
-                     ASTContext &ctx,
-                     SourceLocation lAngleLoc,
-                     ArrayRef<ObjCTypeParamDecl *> typeParams,
-                     SourceLocation rAngleLoc) {
+ObjCTypeParamList *
+ObjCTypeParamList::create(ASTContext &ctx, SourceLocation lAngleLoc,
+                          ArrayRef<ObjCTypeParamDecl *> typeParams,
+                          SourceLocation rAngleLoc) {
   void *mem =
       ctx.Allocate(totalSizeToAlloc<ObjCTypeParamDecl *>(typeParams.size()),
                    alignof(ObjCTypeParamList));
@@ -1478,7 +1468,7 @@
 }
 
 void ObjCTypeParamList::gatherDefaultTypeArgs(
-       SmallVectorImpl<QualType> &typeArgs) const {
+    SmallVectorImpl<QualType> &typeArgs) const {
   typeArgs.reserve(size());
   for (auto typeParam : *this)
     typeArgs.push_back(typeParam->getUnderlyingType());
@@ -1488,32 +1478,27 @@
 // ObjCInterfaceDecl
 //===----------------------------------------------------------------------===//
 
-ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
-                                             DeclContext *DC,
-                                             SourceLocation atLoc,
-                                             IdentifierInfo *Id,
-                                             ObjCTypeParamList *typeParamList,
-                                             ObjCInterfaceDecl *PrevDecl,
-                                             SourceLocation ClassLoc,
-                                             bool isInternal){
-  auto *Result = new (C, DC)
-      ObjCInterfaceDecl(C, DC, atLoc, Id, typeParamList, ClassLoc, PrevDecl,
-                        isInternal);
+ObjCInterfaceDecl *ObjCInterfaceDecl::Create(
+    ASTContext const &C, DeclContext *DC, SourceLocation atLoc,
+    IdentifierInfo *Id, ObjCTypeParamList *typeParamList,
+    ObjCInterfaceDecl *PrevDecl, SourceLocation ClassLoc, bool isInternal) {
+  auto *Result = new (C, DC) ObjCInterfaceDecl(C, DC, atLoc, Id, typeParamList,
+                                               ClassLoc, PrevDecl, isInternal);
   Result->Data.setInt(!C.getLangOpts().Modules);
   C.getObjCInterfaceType(Result, PrevDecl);
   return Result;
 }
 
-ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(const ASTContext &C,
+ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(ASTContext const &C,
                                                          unsigned ID) {
-  auto *Result = new (C, ID)
-      ObjCInterfaceDecl(C, nullptr, SourceLocation(), nullptr, nullptr,
-                        SourceLocation(), nullptr, false);
+  auto *Result =
+      new (C, ID) ObjCInterfaceDecl(C, nullptr, SourceLocation(), nullptr,
+                                    nullptr, SourceLocation(), nullptr, false);
   Result->Data.setInt(!C.getLangOpts().Modules);
   return Result;
 }
 
-ObjCInterfaceDecl::ObjCInterfaceDecl(const ASTContext &C, DeclContext *DC,
+ObjCInterfaceDecl::ObjCInterfaceDecl(ASTContext const &C, DeclContext *DC,
                                      SourceLocation AtLoc, IdentifierInfo *Id,
                                      ObjCTypeParamList *typeParamList,
                                      SourceLocation CLoc,
@@ -1536,7 +1521,7 @@
   assert(data().ExternallyCompleted && "Class is not externally completed");
   data().ExternallyCompleted = false;
   getASTContext().getExternalSource()->CompleteType(
-                                        const_cast<ObjCInterfaceDecl *>(this));
+      const_cast<ObjCInterfaceDecl *>(this));
 }
 
 void ObjCInterfaceDecl::setExternallyCompleted() {
@@ -1564,30 +1549,28 @@
   return data().HasDesignatedInitializers;
 }
 
-StringRef
-ObjCInterfaceDecl::getObjCRuntimeNameAsString() const {
-  if (const auto *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
+StringRef ObjCInterfaceDecl::getObjCRuntimeNameAsString() const {
+  if (auto const *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
     return ObjCRTName->getMetadataName();
 
   return getName();
 }
 
-StringRef
-ObjCImplementationDecl::getObjCRuntimeNameAsString() const {
+StringRef ObjCImplementationDecl::getObjCRuntimeNameAsString() const {
   if (ObjCInterfaceDecl *ID =
-      const_cast<ObjCImplementationDecl*>(this)->getClassInterface())
+          const_cast<ObjCImplementationDecl *>(this)->getClassInterface())
     return ID->getObjCRuntimeNameAsString();
 
   return getName();
 }
 
 ObjCImplementationDecl *ObjCInterfaceDecl::getImplementation() const {
-  if (const ObjCInterfaceDecl *Def = getDefinition()) {
+  if (ObjCInterfaceDecl const *Def = getDefinition()) {
     if (data().ExternallyCompleted)
       LoadExternalDefinition();
 
     return getASTContext().getObjCImplementation(
-             const_cast<ObjCInterfaceDecl*>(Def));
+        const_cast<ObjCInterfaceDecl *>(Def));
   }
 
   // FIXME: Should make sure no callers ever do this.
@@ -1608,9 +1591,8 @@
       : Size(size), Ivar(ivar) {}
 };
 
-bool operator<(const SynthesizeIvarChunk & LHS,
-               const SynthesizeIvarChunk &RHS) {
-    return LHS.Size < RHS.Size;
+bool operator<(SynthesizeIvarChunk const &LHS, SynthesizeIvarChunk const &RHS) {
+  return LHS.Size < RHS.Size;
 }
 
 } // namespace
@@ -1633,21 +1615,22 @@
   if (!data().IvarList) {
     if (!ivar_empty()) {
       ObjCInterfaceDecl::ivar_iterator I = ivar_begin(), E = ivar_end();
-      data().IvarList = *I; ++I;
+      data().IvarList = *I;
+      ++I;
       for (curIvar = data().IvarList; I != E; curIvar = *I, ++I)
         curIvar->setNextIvar(*I);
     }
 
-    for (const auto *Ext : known_extensions()) {
+    for (auto const *Ext : known_extensions()) {
       if (!Ext->ivar_empty()) {
-        ObjCCategoryDecl::ivar_iterator
-          I = Ext->ivar_begin(),
-          E = Ext->ivar_end();
+        ObjCCategoryDecl::ivar_iterator I = Ext->ivar_begin(),
+                                        E = Ext->ivar_end();
         if (!data().IvarList) {
-          data().IvarList = *I; ++I;
+          data().IvarList = *I;
+          ++I;
           curIvar = data().IvarList;
         }
-        for ( ;I != E; curIvar = *I, ++I)
+        for (; I != E; curIvar = *I, ++I)
           curIvar->setNextIvar(*I);
       }
     }
@@ -1656,7 +1639,7 @@
 
   // cached and complete!
   if (!data().IvarListMissingImplementation)
-      return data().IvarList;
+    return data().IvarList;
 
   if (ObjCImplementationDecl *ImplDecl = getImplementation()) {
     data().IvarListMissingImplementation = false;
@@ -1665,7 +1648,7 @@
       for (auto *IV : ImplDecl->ivars()) {
         if (IV->getSynthesize() && !IV->isInvalidDecl()) {
           layout.push_back(SynthesizeIvarChunk(
-                             IV->getASTContext().getTypeSize(IV->getType()), IV));
+              IV->getASTContext().getTypeSize(IV->getType()), IV));
           continue;
         }
         if (!data().IvarList)
@@ -1680,10 +1663,11 @@
         llvm::stable_sort(layout);
         unsigned Ix = 0, EIx = layout.size();
         if (!data().IvarList) {
-          data().IvarList = layout[0].Ivar; Ix++;
+          data().IvarList = layout[0].Ivar;
+          Ix++;
           curIvar = data().IvarList;
         }
-        for ( ; Ix != EIx; curIvar = layout[Ix].Ivar, Ix++)
+        for (; Ix != EIx; curIvar = layout[Ix].Ivar, Ix++)
           curIvar->setNextIvar(layout[Ix].Ivar);
       }
     }
@@ -1713,7 +1697,7 @@
 
 ObjCMethodDecl *
 ObjCInterfaceDecl::getCategoryInstanceMethod(Selector Sel) const {
-  for (const auto *Cat : visible_categories()) {
+  for (auto const *Cat : visible_categories()) {
     if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
       if (ObjCMethodDecl *MD = Impl->getInstanceMethod(Sel))
         return MD;
@@ -1723,7 +1707,7 @@
 }
 
 ObjCMethodDecl *ObjCInterfaceDecl::getCategoryClassMethod(Selector Sel) const {
-  for (const auto *Cat : visible_categories()) {
+  for (auto const *Cat : visible_categories()) {
     if (ObjCCategoryImplDecl *Impl = Cat->getImplementation())
       if (ObjCMethodDecl *MD = Impl->getClassMethod(Sel))
         return MD;
@@ -1736,14 +1720,14 @@
 /// has been implemented in IDecl class, its super class or categories (if
 /// lookupCategory is true).
 bool ObjCInterfaceDecl::ClassImplementsProtocol(ObjCProtocolDecl *lProto,
-                                    bool lookupCategory,
-                                    bool RHSIsQualifiedID) {
+                                                bool lookupCategory,
+                                                bool RHSIsQualifiedID) {
   if (!hasDefinition())
     return false;
 
   ObjCInterfaceDecl *IDecl = this;
   // 1st, look up the class.
-  for (auto *PI : IDecl->protocols()){
+  for (auto *PI : IDecl->protocols()) {
     if (getASTContext().ProtocolCompatibleWithProtocol(lProto, PI))
       return true;
     // This is dubious and is added to be compatible with gcc.  In gcc, it is
@@ -1759,7 +1743,7 @@
 
   // 2nd, look up the category.
   if (lookupCategory)
-    for (const auto *Cat : visible_categories()) {
+    for (auto const *Cat : visible_categories()) {
       for (auto *PI : Cat->protocols())
         if (getASTContext().ProtocolCompatibleWithProtocol(lProto, PI))
           return true;
@@ -1767,9 +1751,8 @@
 
   // 3rd, look up the super class(s)
   if (IDecl->getSuperClass())
-    return
-  IDecl->getSuperClass()->ClassImplementsProtocol(lProto, lookupCategory,
-                                                  RHSIsQualifiedID);
+    return IDecl->getSuperClass()->ClassImplementsProtocol(
+        lProto, lookupCategory, RHSIsQualifiedID);
 
   return false;
 }
@@ -1812,18 +1795,18 @@
     ID->setIvarList(nullptr);
   }
 
-  return new (C, DC) ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo, ac, BW,
-                                  synthesized);
+  return new (C, DC)
+      ObjCIvarDecl(DC, StartLoc, IdLoc, Id, T, TInfo, ac, BW, synthesized);
 }
 
 ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) ObjCIvarDecl(nullptr, SourceLocation(), SourceLocation(),
-                                  nullptr, QualType(), nullptr,
-                                  ObjCIvarDecl::None, nullptr, false);
+  return new (C, ID)
+      ObjCIvarDecl(nullptr, SourceLocation(), SourceLocation(), nullptr,
+                   QualType(), nullptr, ObjCIvarDecl::None, nullptr, false);
 }
 
-const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
-  const auto *DC = cast<ObjCContainerDecl>(getDeclContext());
+ObjCInterfaceDecl const *ObjCIvarDecl::getContainingInterface() const {
+  auto const *DC = cast<ObjCContainerDecl>(getDeclContext());
 
   switch (DC->getKind()) {
   default:
@@ -1833,7 +1816,7 @@
 
     // Ivars can only appear in class extension categories.
   case ObjCCategory: {
-    const auto *CD = cast<ObjCCategoryDecl>(DC);
+    auto const *CD = cast<ObjCCategoryDecl>(DC);
     assert(CD->IsClassExtension() && "invalid container for ivar!");
     return CD->getClassInterface();
   }
@@ -1857,18 +1840,19 @@
 
 void ObjCAtDefsFieldDecl::anchor() {}
 
-ObjCAtDefsFieldDecl
-*ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
-                             SourceLocation StartLoc,  SourceLocation IdLoc,
-                             IdentifierInfo *Id, QualType T, Expr *BW) {
+ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::Create(ASTContext &C, DeclContext *DC,
+                                                 SourceLocation StartLoc,
+                                                 SourceLocation IdLoc,
+                                                 IdentifierInfo *Id, QualType T,
+                                                 Expr *BW) {
   return new (C, DC) ObjCAtDefsFieldDecl(DC, StartLoc, IdLoc, Id, T, BW);
 }
 
 ObjCAtDefsFieldDecl *ObjCAtDefsFieldDecl::CreateDeserialized(ASTContext &C,
                                                              unsigned ID) {
-  return new (C, ID) ObjCAtDefsFieldDecl(nullptr, SourceLocation(),
-                                         SourceLocation(), nullptr, QualType(),
-                                         nullptr);
+  return new (C, ID)
+      ObjCAtDefsFieldDecl(nullptr, SourceLocation(), SourceLocation(), nullptr,
+                          QualType(), nullptr);
 }
 
 //===----------------------------------------------------------------------===//
@@ -1901,9 +1885,8 @@
 
 ObjCProtocolDecl *ObjCProtocolDecl::CreateDeserialized(ASTContext &C,
                                                        unsigned ID) {
-  ObjCProtocolDecl *Result =
-      new (C, ID) ObjCProtocolDecl(C, nullptr, nullptr, SourceLocation(),
-                                   SourceLocation(), nullptr);
+  ObjCProtocolDecl *Result = new (C, ID) ObjCProtocolDecl(
+      C, nullptr, nullptr, SourceLocation(), SourceLocation(), nullptr);
   Result->Data.setInt(!C.getLangOpts().Modules);
   return Result;
 }
@@ -1913,15 +1896,15 @@
 }
 
 void ObjCProtocolDecl::getImpliedProtocols(
-    llvm::DenseSet<const ObjCProtocolDecl *> &IPs) const {
-  std::queue<const ObjCProtocolDecl *> WorkQueue;
+    llvm::DenseSet<ObjCProtocolDecl const *> &IPs) const {
+  std::queue<ObjCProtocolDecl const *> WorkQueue;
   WorkQueue.push(this);
 
   while (!WorkQueue.empty()) {
-    const auto *PD = WorkQueue.front();
+    auto const *PD = WorkQueue.front();
     WorkQueue.pop();
-    for (const auto *Parent : PD->protocols()) {
-      const auto *Can = Parent->getCanonicalDecl();
+    for (auto const *Parent : PD->protocols()) {
+      auto const *Can = Parent->getCanonicalDecl();
       auto Result = IPs.insert(Can);
       if (Result.second)
         WorkQueue.push(Parent);
@@ -1950,14 +1933,14 @@
 
   // If there is no definition or the definition is hidden, we don't find
   // anything.
-  const ObjCProtocolDecl *Def = getDefinition();
+  ObjCProtocolDecl const *Def = getDefinition();
   if (!Def || !Def->isUnconditionallyVisible())
     return nullptr;
 
   if ((MethodDecl = getMethod(Sel, isInstance)))
     return MethodDecl;
 
-  for (const auto *I : protocols())
+  for (auto const *I : protocols())
     if ((MethodDecl = I->lookupMethod(Sel, isInstance)))
       return MethodDecl;
   return nullptr;
@@ -1977,9 +1960,9 @@
     RD->Data = this->Data;
 }
 
-void ObjCProtocolDecl::collectPropertiesToImplement(PropertyMap &PM,
-                                                    PropertyDeclOrder &PO) const {
-  if (const ObjCProtocolDecl *PDecl = getDefinition()) {
+void ObjCProtocolDecl::collectPropertiesToImplement(
+    PropertyMap &PM, PropertyDeclOrder &PO) const {
+  if (ObjCProtocolDecl const *PDecl = getDefinition()) {
     for (auto *Prop : PDecl->properties()) {
       // Insert into PM if not there already.
       PM.insert(std::make_pair(
@@ -1988,15 +1971,15 @@
       PO.push_back(Prop);
     }
     // Scan through protocol's protocols.
-    for (const auto *PI : PDecl->protocols())
+    for (auto const *PI : PDecl->protocols())
       PI->collectPropertiesToImplement(PM, PO);
   }
 }
 
 void ObjCProtocolDecl::collectInheritedProtocolProperties(
-    const ObjCPropertyDecl *Property, ProtocolPropertySet &PS,
+    ObjCPropertyDecl const *Property, ProtocolPropertySet &PS,
     PropertyDeclOrder &PO) const {
-  if (const ObjCProtocolDecl *PDecl = getDefinition()) {
+  if (ObjCProtocolDecl const *PDecl = getDefinition()) {
     if (!PS.insert(PDecl).second)
       return;
     for (auto *Prop : PDecl->properties()) {
@@ -2008,14 +1991,13 @@
       }
     }
     // Scan through protocol's protocols which did not have a matching property.
-    for (const auto *PI : PDecl->protocols())
+    for (auto const *PI : PDecl->protocols())
       PI->collectInheritedProtocolProperties(Property, PS, PO);
   }
 }
 
-StringRef
-ObjCProtocolDecl::getObjCRuntimeNameAsString() const {
-  if (const auto *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
+StringRef ObjCProtocolDecl::getObjCRuntimeNameAsString() const {
+  if (auto const *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
     return ObjCRTName->getMetadataName();
 
   return getName();
@@ -2040,19 +2022,15 @@
   setTypeParamList(typeParamList);
 }
 
-ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC,
-                                           SourceLocation AtLoc,
-                                           SourceLocation ClassNameLoc,
-                                           SourceLocation CategoryNameLoc,
-                                           IdentifierInfo *Id,
-                                           ObjCInterfaceDecl *IDecl,
-                                           ObjCTypeParamList *typeParamList,
-                                           SourceLocation IvarLBraceLoc,
-                                           SourceLocation IvarRBraceLoc) {
-  auto *CatDecl =
-      new (C, DC) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, CategoryNameLoc, Id,
-                                   IDecl, typeParamList, IvarLBraceLoc,
-                                   IvarRBraceLoc);
+ObjCCategoryDecl *ObjCCategoryDecl::Create(
+    ASTContext &C, DeclContext *DC, SourceLocation AtLoc,
+    SourceLocation ClassNameLoc, SourceLocation CategoryNameLoc,
+    IdentifierInfo *Id, ObjCInterfaceDecl *IDecl,
+    ObjCTypeParamList *typeParamList, SourceLocation IvarLBraceLoc,
+    SourceLocation IvarRBraceLoc) {
+  auto *CatDecl = new (C, DC)
+      ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, CategoryNameLoc, Id, IDecl,
+                       typeParamList, IvarLBraceLoc, IvarRBraceLoc);
   if (IDecl) {
     // Link this category into its class's category list.
     CatDecl->NextClassCategory = IDecl->getCategoryListRaw();
@@ -2068,14 +2046,14 @@
 
 ObjCCategoryDecl *ObjCCategoryDecl::CreateDeserialized(ASTContext &C,
                                                        unsigned ID) {
-  return new (C, ID) ObjCCategoryDecl(nullptr, SourceLocation(),
-                                      SourceLocation(), SourceLocation(),
-                                      nullptr, nullptr, nullptr);
+  return new (C, ID)
+      ObjCCategoryDecl(nullptr, SourceLocation(), SourceLocation(),
+                       SourceLocation(), nullptr, nullptr, nullptr);
 }
 
 ObjCCategoryImplDecl *ObjCCategoryDecl::getImplementation() const {
   return getASTContext().getObjCImplementation(
-                                           const_cast<ObjCCategoryDecl*>(this));
+      const_cast<ObjCCategoryDecl *>(this));
 }
 
 void ObjCCategoryDecl::setImplementation(ObjCCategoryImplDecl *ImplD) {
@@ -2098,11 +2076,9 @@
 void ObjCCategoryImplDecl::anchor() {}
 
 ObjCCategoryImplDecl *
-ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC,
-                             IdentifierInfo *Id,
+ObjCCategoryImplDecl::Create(ASTContext &C, DeclContext *DC, IdentifierInfo *Id,
                              ObjCInterfaceDecl *ClassInterface,
-                             SourceLocation nameLoc,
-                             SourceLocation atStartLoc,
+                             SourceLocation nameLoc, SourceLocation atStartLoc,
                              SourceLocation CategoryNameLoc) {
   if (ClassInterface && ClassInterface->hasDefinition())
     ClassInterface = ClassInterface->getDefinition();
@@ -2112,14 +2088,14 @@
 
 ObjCCategoryImplDecl *ObjCCategoryImplDecl::CreateDeserialized(ASTContext &C,
                                                                unsigned ID) {
-  return new (C, ID) ObjCCategoryImplDecl(nullptr, nullptr, nullptr,
-                                          SourceLocation(), SourceLocation(),
-                                          SourceLocation());
+  return new (C, ID)
+      ObjCCategoryImplDecl(nullptr, nullptr, nullptr, SourceLocation(),
+                           SourceLocation(), SourceLocation());
 }
 
 ObjCCategoryDecl *ObjCCategoryImplDecl::getCategoryDecl() const {
   // The class interface might be NULL if we are working with invalid code.
-  if (const ObjCInterfaceDecl *ID = getClassInterface())
+  if (ObjCInterfaceDecl const *ID = getClassInterface())
     return ID->FindCategoryDeclaration(getIdentifier());
   return nullptr;
 }
@@ -2150,8 +2126,8 @@
 /// FindPropertyImplIvarDecl - This method lookup the ivar in the list of
 /// properties implemented in this \@implementation block and returns
 /// the implemented property that uses it.
-ObjCPropertyImplDecl *ObjCImplDecl::
-FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const {
+ObjCPropertyImplDecl *
+ObjCImplDecl::FindPropertyImplIvarDecl(IdentifierInfo *ivarId) const {
   for (auto *PID : property_impls())
     if (PID->getPropertyIvarDecl() &&
         PID->getPropertyIvarDecl()->getIdentifier() == ivarId)
@@ -2162,9 +2138,9 @@
 /// FindPropertyImplDecl - This method looks up a previous ObjCPropertyImplDecl
 /// added to the list of those properties \@synthesized/\@dynamic in this
 /// category \@implementation block.
-ObjCPropertyImplDecl *ObjCImplDecl::
-FindPropertyImplDecl(IdentifierInfo *Id,
-                     ObjCPropertyQueryKind QueryKind) const {
+ObjCPropertyImplDecl *
+ObjCImplDecl::FindPropertyImplDecl(IdentifierInfo *Id,
+                                   ObjCPropertyQueryKind QueryKind) const {
   ObjCPropertyImplDecl *ClassPropImpl = nullptr;
   for (auto *PID : property_impls())
     // If queryKind is unknown, we return the instance property if one
@@ -2190,7 +2166,7 @@
 }
 
 raw_ostream &clang::operator<<(raw_ostream &OS,
-                               const ObjCCategoryImplDecl &CID) {
+                               ObjCCategoryImplDecl const &CID) {
   OS << CID.getName();
   return OS;
 }
@@ -2201,20 +2177,16 @@
 
 void ObjCImplementationDecl::anchor() {}
 
-ObjCImplementationDecl *
-ObjCImplementationDecl::Create(ASTContext &C, DeclContext *DC,
-                               ObjCInterfaceDecl *ClassInterface,
-                               ObjCInterfaceDecl *SuperDecl,
-                               SourceLocation nameLoc,
-                               SourceLocation atStartLoc,
-                               SourceLocation superLoc,
-                               SourceLocation IvarLBraceLoc,
-                               SourceLocation IvarRBraceLoc) {
+ObjCImplementationDecl *ObjCImplementationDecl::Create(
+    ASTContext &C, DeclContext *DC, ObjCInterfaceDecl *ClassInterface,
+    ObjCInterfaceDecl *SuperDecl, SourceLocation nameLoc,
+    SourceLocation atStartLoc, SourceLocation superLoc,
+    SourceLocation IvarLBraceLoc, SourceLocation IvarRBraceLoc) {
   if (ClassInterface && ClassInterface->hasDefinition())
     ClassInterface = ClassInterface->getDefinition();
-  return new (C, DC) ObjCImplementationDecl(DC, ClassInterface, SuperDecl,
-                                            nameLoc, atStartLoc, superLoc,
-                                            IvarLBraceLoc, IvarRBraceLoc);
+  return new (C, DC)
+      ObjCImplementationDecl(DC, ClassInterface, SuperDecl, nameLoc, atStartLoc,
+                             superLoc, IvarLBraceLoc, IvarRBraceLoc);
 }
 
 ObjCImplementationDecl *
@@ -2223,14 +2195,14 @@
                                             SourceLocation(), SourceLocation());
 }
 
-void ObjCImplementationDecl::setIvarInitializers(ASTContext &C,
-                                             CXXCtorInitializer ** initializers,
-                                                 unsigned numInitializers) {
+void ObjCImplementationDecl::setIvarInitializers(
+    ASTContext &C, CXXCtorInitializer **initializers,
+    unsigned numInitializers) {
   if (numInitializers > 0) {
     NumIvarInitializers = numInitializers;
-    auto **ivarInitializers = new (C) CXXCtorInitializer*[NumIvarInitializers];
+    auto **ivarInitializers = new (C) CXXCtorInitializer *[NumIvarInitializers];
     memcpy(ivarInitializers, initializers,
-           numInitializers * sizeof(CXXCtorInitializer*));
+           numInitializers * sizeof(CXXCtorInitializer *));
     IvarInitializers = ivarInitializers;
   }
 }
@@ -2241,7 +2213,7 @@
 }
 
 raw_ostream &clang::operator<<(raw_ostream &OS,
-                               const ObjCImplementationDecl &ID) {
+                               ObjCImplementationDecl const &ID) {
   OS << ID.getName();
   return OS;
 }
@@ -2254,16 +2226,15 @@
 
 ObjCCompatibleAliasDecl *
 ObjCCompatibleAliasDecl::Create(ASTContext &C, DeclContext *DC,
-                                SourceLocation L,
-                                IdentifierInfo *Id,
-                                ObjCInterfaceDecl* AliasedClass) {
+                                SourceLocation L, IdentifierInfo *Id,
+                                ObjCInterfaceDecl *AliasedClass) {
   return new (C, DC) ObjCCompatibleAliasDecl(DC, L, Id, AliasedClass);
 }
 
 ObjCCompatibleAliasDecl *
 ObjCCompatibleAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) ObjCCompatibleAliasDecl(nullptr, SourceLocation(),
-                                             nullptr, nullptr);
+  return new (C, ID)
+      ObjCCompatibleAliasDecl(nullptr, SourceLocation(), nullptr, nullptr);
 }
 
 //===----------------------------------------------------------------------===//
@@ -2273,22 +2244,20 @@
 void ObjCPropertyDecl::anchor() {}
 
 ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C, DeclContext *DC,
-                                           SourceLocation L,
-                                           IdentifierInfo *Id,
+                                           SourceLocation L, IdentifierInfo *Id,
                                            SourceLocation AtLoc,
-                                           SourceLocation LParenLoc,
-                                           QualType T,
+                                           SourceLocation LParenLoc, QualType T,
                                            TypeSourceInfo *TSI,
                                            PropertyControl propControl) {
-  return new (C, DC) ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T, TSI,
-                                      propControl);
+  return new (C, DC)
+      ObjCPropertyDecl(DC, L, Id, AtLoc, LParenLoc, T, TSI, propControl);
 }
 
 ObjCPropertyDecl *ObjCPropertyDecl::CreateDeserialized(ASTContext &C,
                                                        unsigned ID) {
-  return new (C, ID) ObjCPropertyDecl(nullptr, SourceLocation(), nullptr,
-                                      SourceLocation(), SourceLocation(),
-                                      QualType(), nullptr, None);
+  return new (C, ID)
+      ObjCPropertyDecl(nullptr, SourceLocation(), nullptr, SourceLocation(),
+                       SourceLocation(), QualType(), nullptr, None);
 }
 
 QualType ObjCPropertyDecl::getUsageType(QualType objectType) const {
@@ -2305,23 +2274,20 @@
 // ObjCPropertyImplDecl
 //===----------------------------------------------------------------------===//
 
-ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C,
-                                                   DeclContext *DC,
-                                                   SourceLocation atLoc,
-                                                   SourceLocation L,
-                                                   ObjCPropertyDecl *property,
-                                                   Kind PK,
-                                                   ObjCIvarDecl *ivar,
-                                                   SourceLocation ivarLoc) {
-  return new (C, DC) ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar,
-                                          ivarLoc);
+ObjCPropertyImplDecl *
+ObjCPropertyImplDecl::Create(ASTContext &C, DeclContext *DC,
+                             SourceLocation atLoc, SourceLocation L,
+                             ObjCPropertyDecl *property, Kind PK,
+                             ObjCIvarDecl *ivar, SourceLocation ivarLoc) {
+  return new (C, DC)
+      ObjCPropertyImplDecl(DC, atLoc, L, property, PK, ivar, ivarLoc);
 }
 
 ObjCPropertyImplDecl *ObjCPropertyImplDecl::CreateDeserialized(ASTContext &C,
                                                                unsigned ID) {
-  return new (C, ID) ObjCPropertyImplDecl(nullptr, SourceLocation(),
-                                          SourceLocation(), nullptr, Dynamic,
-                                          nullptr, SourceLocation());
+  return new (C, ID)
+      ObjCPropertyImplDecl(nullptr, SourceLocation(), SourceLocation(), nullptr,
+                           Dynamic, nullptr, SourceLocation());
 }
 
 SourceRange ObjCPropertyImplDecl::getSourceRange() const {
Index: clang/lib/AST/DeclOpenMP.cpp
===================================================================
--- clang/lib/AST/DeclOpenMP.cpp
+++ clang/lib/AST/DeclOpenMP.cpp
@@ -11,10 +11,10 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
-#include "clang/AST/DeclOpenMP.h"
 #include "clang/AST/Expr.h"
 
 using namespace clang;
@@ -52,7 +52,7 @@
 // OMPAllocateDecl Implementation.
 //===----------------------------------------------------------------------===//
 
-void OMPAllocateDecl::anchor() { }
+void OMPAllocateDecl::anchor() {}
 
 OMPAllocateDecl *OMPAllocateDecl::Create(ASTContext &C, DeclContext *DC,
                                          SourceLocation L, ArrayRef<Expr *> VL,
@@ -127,7 +127,7 @@
   return cast_or_null<OMPDeclareReductionDecl>(
       PrevDeclInScope.get(getASTContext().getExternalSource()));
 }
-const OMPDeclareReductionDecl *
+OMPDeclareReductionDecl const *
 OMPDeclareReductionDecl::getPrevDeclInScope() const {
   return cast_or_null<OMPDeclareReductionDecl>(
       PrevDeclInScope.get(getASTContext().getExternalSource()));
@@ -160,7 +160,7 @@
       PrevDeclInScope.get(getASTContext().getExternalSource()));
 }
 
-const OMPDeclareMapperDecl *OMPDeclareMapperDecl::getPrevDeclInScope() const {
+OMPDeclareMapperDecl const *OMPDeclareMapperDecl::getPrevDeclInScope() const {
   return cast_or_null<OMPDeclareMapperDecl>(
       PrevDeclInScope.get(getASTContext().getExternalSource()));
 }
Index: clang/lib/AST/DeclPrinter.cpp
===================================================================
--- clang/lib/AST/DeclPrinter.cpp
+++ clang/lib/AST/DeclPrinter.cpp
@@ -25,123 +25,123 @@
 using namespace clang;
 
 namespace {
-  class DeclPrinter : public DeclVisitor<DeclPrinter> {
-    raw_ostream &Out;
-    PrintingPolicy Policy;
-    const ASTContext &Context;
-    unsigned Indentation;
-    bool PrintInstantiation;
-
-    raw_ostream& Indent() { return Indent(Indentation); }
-    raw_ostream& Indent(unsigned Indentation);
-    void ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls);
-
-    void Print(AccessSpecifier AS);
-    void PrintConstructorInitializers(CXXConstructorDecl *CDecl,
-                                      std::string &Proto);
-
-    /// Print an Objective-C method type in parentheses.
-    ///
-    /// \param Quals The Objective-C declaration qualifiers.
-    /// \param T The type to print.
-    void PrintObjCMethodType(ASTContext &Ctx, Decl::ObjCDeclQualifier Quals,
-                             QualType T);
-
-    void PrintObjCTypeParams(ObjCTypeParamList *Params);
-
-  public:
-    DeclPrinter(raw_ostream &Out, const PrintingPolicy &Policy,
-                const ASTContext &Context, unsigned Indentation = 0,
-                bool PrintInstantiation = false)
-        : Out(Out), Policy(Policy), Context(Context), Indentation(Indentation),
-          PrintInstantiation(PrintInstantiation) {}
-
-    void VisitDeclContext(DeclContext *DC, bool Indent = true);
-
-    void VisitTranslationUnitDecl(TranslationUnitDecl *D);
-    void VisitTypedefDecl(TypedefDecl *D);
-    void VisitTypeAliasDecl(TypeAliasDecl *D);
-    void VisitEnumDecl(EnumDecl *D);
-    void VisitRecordDecl(RecordDecl *D);
-    void VisitEnumConstantDecl(EnumConstantDecl *D);
-    void VisitEmptyDecl(EmptyDecl *D);
-    void VisitFunctionDecl(FunctionDecl *D);
-    void VisitFriendDecl(FriendDecl *D);
-    void VisitFieldDecl(FieldDecl *D);
-    void VisitVarDecl(VarDecl *D);
-    void VisitLabelDecl(LabelDecl *D);
-    void VisitParmVarDecl(ParmVarDecl *D);
-    void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
-    void VisitImportDecl(ImportDecl *D);
-    void VisitStaticAssertDecl(StaticAssertDecl *D);
-    void VisitNamespaceDecl(NamespaceDecl *D);
-    void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
-    void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
-    void VisitCXXRecordDecl(CXXRecordDecl *D);
-    void VisitLinkageSpecDecl(LinkageSpecDecl *D);
-    void VisitTemplateDecl(const TemplateDecl *D);
-    void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
-    void VisitClassTemplateDecl(ClassTemplateDecl *D);
-    void VisitClassTemplateSpecializationDecl(
-                                            ClassTemplateSpecializationDecl *D);
-    void VisitClassTemplatePartialSpecializationDecl(
-                                     ClassTemplatePartialSpecializationDecl *D);
-    void VisitObjCMethodDecl(ObjCMethodDecl *D);
-    void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
-    void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
-    void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
-    void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
-    void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
-    void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
-    void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
-    void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
-    void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
-    void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
-    void VisitUsingDecl(UsingDecl *D);
-    void VisitUsingEnumDecl(UsingEnumDecl *D);
-    void VisitUsingShadowDecl(UsingShadowDecl *D);
-    void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
-    void VisitOMPAllocateDecl(OMPAllocateDecl *D);
-    void VisitOMPRequiresDecl(OMPRequiresDecl *D);
-    void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
-    void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
-    void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
-    void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP);
-    void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *NTTP);
-
-    void printTemplateParameters(const TemplateParameterList *Params,
-                                 bool OmitTemplateKW = false);
-    void printTemplateArguments(llvm::ArrayRef<TemplateArgument> Args,
-                                const TemplateParameterList *Params,
-                                bool TemplOverloaded);
-    void printTemplateArguments(llvm::ArrayRef<TemplateArgumentLoc> Args,
-                                const TemplateParameterList *Params,
-                                bool TemplOverloaded);
-    void prettyPrintAttributes(Decl *D);
-    void prettyPrintPragmas(Decl *D);
-    void printDeclType(QualType T, StringRef DeclName, bool Pack = false);
-  };
-}
+class DeclPrinter : public DeclVisitor<DeclPrinter> {
+  raw_ostream &Out;
+  PrintingPolicy Policy;
+  ASTContext const &Context;
+  unsigned Indentation;
+  bool PrintInstantiation;
+
+  raw_ostream &Indent() { return Indent(Indentation); }
+  raw_ostream &Indent(unsigned Indentation);
+  void ProcessDeclGroup(SmallVectorImpl<Decl *> &Decls);
+
+  void Print(AccessSpecifier AS);
+  void PrintConstructorInitializers(CXXConstructorDecl *CDecl,
+                                    std::string &Proto);
+
+  /// Print an Objective-C method type in parentheses.
+  ///
+  /// \param Quals The Objective-C declaration qualifiers.
+  /// \param T The type to print.
+  void PrintObjCMethodType(ASTContext &Ctx, Decl::ObjCDeclQualifier Quals,
+                           QualType T);
+
+  void PrintObjCTypeParams(ObjCTypeParamList *Params);
+
+public:
+  DeclPrinter(raw_ostream &Out, PrintingPolicy const &Policy,
+              ASTContext const &Context, unsigned Indentation = 0,
+              bool PrintInstantiation = false)
+      : Out(Out), Policy(Policy), Context(Context), Indentation(Indentation),
+        PrintInstantiation(PrintInstantiation) {}
+
+  void VisitDeclContext(DeclContext *DC, bool Indent = true);
+
+  void VisitTranslationUnitDecl(TranslationUnitDecl *D);
+  void VisitTypedefDecl(TypedefDecl *D);
+  void VisitTypeAliasDecl(TypeAliasDecl *D);
+  void VisitEnumDecl(EnumDecl *D);
+  void VisitRecordDecl(RecordDecl *D);
+  void VisitEnumConstantDecl(EnumConstantDecl *D);
+  void VisitEmptyDecl(EmptyDecl *D);
+  void VisitFunctionDecl(FunctionDecl *D);
+  void VisitFriendDecl(FriendDecl *D);
+  void VisitFieldDecl(FieldDecl *D);
+  void VisitVarDecl(VarDecl *D);
+  void VisitLabelDecl(LabelDecl *D);
+  void VisitParmVarDecl(ParmVarDecl *D);
+  void VisitFileScopeAsmDecl(FileScopeAsmDecl *D);
+  void VisitImportDecl(ImportDecl *D);
+  void VisitStaticAssertDecl(StaticAssertDecl *D);
+  void VisitNamespaceDecl(NamespaceDecl *D);
+  void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
+  void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
+  void VisitCXXRecordDecl(CXXRecordDecl *D);
+  void VisitLinkageSpecDecl(LinkageSpecDecl *D);
+  void VisitTemplateDecl(TemplateDecl const *D);
+  void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
+  void VisitClassTemplateDecl(ClassTemplateDecl *D);
+  void VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D);
+  void VisitClassTemplatePartialSpecializationDecl(
+      ClassTemplatePartialSpecializationDecl *D);
+  void VisitObjCMethodDecl(ObjCMethodDecl *D);
+  void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
+  void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
+  void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
+  void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
+  void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
+  void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
+  void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
+  void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
+  void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
+  void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
+  void VisitUsingDecl(UsingDecl *D);
+  void VisitUsingEnumDecl(UsingEnumDecl *D);
+  void VisitUsingShadowDecl(UsingShadowDecl *D);
+  void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
+  void VisitOMPAllocateDecl(OMPAllocateDecl *D);
+  void VisitOMPRequiresDecl(OMPRequiresDecl *D);
+  void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
+  void VisitOMPDeclareMapperDecl(OMPDeclareMapperDecl *D);
+  void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
+  void VisitTemplateTypeParmDecl(TemplateTypeParmDecl const *TTP);
+  void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl const *NTTP);
+
+  void printTemplateParameters(TemplateParameterList const *Params,
+                               bool OmitTemplateKW = false);
+  void printTemplateArguments(llvm::ArrayRef<TemplateArgument> Args,
+                              TemplateParameterList const *Params,
+                              bool TemplOverloaded);
+  void printTemplateArguments(llvm::ArrayRef<TemplateArgumentLoc> Args,
+                              TemplateParameterList const *Params,
+                              bool TemplOverloaded);
+  void prettyPrintAttributes(Decl *D);
+  void prettyPrintPragmas(Decl *D);
+  void printDeclType(QualType T, StringRef DeclName, bool Pack = false);
+};
+} // namespace
 
 void Decl::print(raw_ostream &Out, unsigned Indentation,
                  bool PrintInstantiation) const {
-  print(Out, getASTContext().getPrintingPolicy(), Indentation, PrintInstantiation);
+  print(Out, getASTContext().getPrintingPolicy(), Indentation,
+        PrintInstantiation);
 }
 
-void Decl::print(raw_ostream &Out, const PrintingPolicy &Policy,
+void Decl::print(raw_ostream &Out, PrintingPolicy const &Policy,
                  unsigned Indentation, bool PrintInstantiation) const {
   DeclPrinter Printer(Out, Policy, getASTContext(), Indentation,
                       PrintInstantiation);
-  Printer.Visit(const_cast<Decl*>(this));
+  Printer.Visit(const_cast<Decl *>(this));
 }
 
-void TemplateParameterList::print(raw_ostream &Out, const ASTContext &Context,
+void TemplateParameterList::print(raw_ostream &Out, ASTContext const &Context,
                                   bool OmitTemplateKW) const {
   print(Out, Context, Context.getPrintingPolicy(), OmitTemplateKW);
 }
 
-void TemplateParameterList::print(raw_ostream &Out, const ASTContext &Context,
-                                  const PrintingPolicy &Policy,
+void TemplateParameterList::print(raw_ostream &Out, ASTContext const &Context,
+                                  PrintingPolicy const &Policy,
                                   bool OmitTemplateKW) const {
   DeclPrinter Printer(Out, Policy, Context);
   Printer.printTemplateParameters(this, OmitTemplateKW);
@@ -151,21 +151,21 @@
   // FIXME: This should be on the Type class!
   QualType BaseType = T;
   while (!BaseType->isSpecifierType()) {
-    if (const PointerType *PTy = BaseType->getAs<PointerType>())
+    if (PointerType const *PTy = BaseType->getAs<PointerType>())
       BaseType = PTy->getPointeeType();
-    else if (const BlockPointerType *BPy = BaseType->getAs<BlockPointerType>())
+    else if (BlockPointerType const *BPy = BaseType->getAs<BlockPointerType>())
       BaseType = BPy->getPointeeType();
-    else if (const ArrayType* ATy = dyn_cast<ArrayType>(BaseType))
+    else if (ArrayType const *ATy = dyn_cast<ArrayType>(BaseType))
       BaseType = ATy->getElementType();
-    else if (const FunctionType* FTy = BaseType->getAs<FunctionType>())
+    else if (FunctionType const *FTy = BaseType->getAs<FunctionType>())
       BaseType = FTy->getReturnType();
-    else if (const VectorType *VTy = BaseType->getAs<VectorType>())
+    else if (VectorType const *VTy = BaseType->getAs<VectorType>())
       BaseType = VTy->getElementType();
-    else if (const ReferenceType *RTy = BaseType->getAs<ReferenceType>())
+    else if (ReferenceType const *RTy = BaseType->getAs<ReferenceType>())
       BaseType = RTy->getPointeeType();
-    else if (const AutoType *ATy = BaseType->getAs<AutoType>())
+    else if (AutoType const *ATy = BaseType->getAs<AutoType>())
       BaseType = ATy->getDeducedType();
-    else if (const ParenType *PTy = BaseType->getAs<ParenType>())
+    else if (ParenType const *PTy = BaseType->getAs<ParenType>())
       BaseType = PTy->desugar();
     else
       // This must be a syntax error.
@@ -174,38 +174,38 @@
   return BaseType;
 }
 
-static QualType getDeclType(Decl* D) {
-  if (TypedefNameDecl* TDD = dyn_cast<TypedefNameDecl>(D))
+static QualType getDeclType(Decl *D) {
+  if (TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(D))
     return TDD->getUnderlyingType();
-  if (ValueDecl* VD = dyn_cast<ValueDecl>(D))
+  if (ValueDecl *VD = dyn_cast<ValueDecl>(D))
     return VD->getType();
   return QualType();
 }
 
-void Decl::printGroup(Decl** Begin, unsigned NumDecls,
-                      raw_ostream &Out, const PrintingPolicy &Policy,
-                      unsigned Indentation) {
+void Decl::printGroup(Decl **Begin, unsigned NumDecls, raw_ostream &Out,
+                      PrintingPolicy const &Policy, unsigned Indentation) {
   if (NumDecls == 1) {
     (*Begin)->print(Out, Policy, Indentation);
     return;
   }
 
-  Decl** End = Begin + NumDecls;
-  TagDecl* TD = dyn_cast<TagDecl>(*Begin);
+  Decl **End = Begin + NumDecls;
+  TagDecl *TD = dyn_cast<TagDecl>(*Begin);
   if (TD)
     ++Begin;
 
   PrintingPolicy SubPolicy(Policy);
 
   bool isFirst = true;
-  for ( ; Begin != End; ++Begin) {
+  for (; Begin != End; ++Begin) {
     if (isFirst) {
-      if(TD)
+      if (TD)
         SubPolicy.IncludeTagDefinition = true;
       SubPolicy.SuppressSpecifiers = false;
       isFirst = false;
     } else {
-      if (!isFirst) Out << ", ";
+      if (!isFirst)
+        Out << ", ";
       SubPolicy.IncludeTagDefinition = false;
       SubPolicy.SuppressSpecifiers = true;
     }
@@ -216,7 +216,7 @@
 
 LLVM_DUMP_METHOD void DeclContext::dumpDeclContext() const {
   // Get the translation unit
-  const DeclContext *DC = this;
+  DeclContext const *DC = this;
   while (!DC->isTranslationUnit())
     DC = DC->getParent();
 
@@ -225,7 +225,7 @@
   Printer.VisitDeclContext(const_cast<DeclContext *>(this), /*Indent=*/false);
 }
 
-raw_ostream& DeclPrinter::Indent(unsigned Indentation) {
+raw_ostream &DeclPrinter::Indent(unsigned Indentation) {
   for (unsigned i = 0; i != Indentation; ++i)
     Out << "  ";
   return Out;
@@ -285,16 +285,15 @@
   T.print(Out, Policy, (Pack ? "..." : "") + DeclName, Indentation);
 }
 
-void DeclPrinter::ProcessDeclGroup(SmallVectorImpl<Decl*>& Decls) {
+void DeclPrinter::ProcessDeclGroup(SmallVectorImpl<Decl *> &Decls) {
   this->Indent();
   Decl::printGroup(Decls.data(), Decls.size(), Out, Policy, Indentation);
   Out << ";\n";
   Decls.clear();
-
 }
 
 void DeclPrinter::Print(AccessSpecifier AS) {
-  const auto AccessSpelling = getAccessSpelling(AS);
+  auto const AccessSpelling = getAccessSpelling(AS);
   if (AccessSpelling.empty())
     llvm_unreachable("No access specifier!");
   Out << AccessSpelling;
@@ -303,7 +302,7 @@
 void DeclPrinter::PrintConstructorInitializers(CXXConstructorDecl *CDecl,
                                                std::string &Proto) {
   bool HasInitializerList = false;
-  for (const auto *BMInitializer : CDecl->inits()) {
+  for (auto const *BMInitializer : CDecl->inits()) {
     if (BMInitializer->isInClassMemberInitializer())
       continue;
 
@@ -378,7 +377,7 @@
   if (Indent)
     Indentation += Policy.Indentation;
 
-  SmallVector<Decl*, 2> Decls;
+  SmallVector<Decl *, 2> Decls;
   for (DeclContext::decl_iterator D = DC->decls_begin(), DEnd = DC->decls_end();
        D != DEnd; ++D) {
 
@@ -444,7 +443,7 @@
     Visit(*D);
 
     // FIXME: Need to be able to tell the DeclPrinter when
-    const char *Terminator = nullptr;
+    char const *Terminator = nullptr;
     if (isa<OMPThreadPrivateDecl>(*D) || isa<OMPDeclareReductionDecl>(*D) ||
         isa<OMPDeclareMapperDecl>(*D) || isa<OMPRequiresDecl>(*D) ||
         isa<OMPAllocateDecl>(*D))
@@ -462,11 +461,9 @@
       else
         Terminator = ";";
     } else if (isa<NamespaceDecl>(*D) || isa<LinkageSpecDecl>(*D) ||
-             isa<ObjCImplementationDecl>(*D) ||
-             isa<ObjCInterfaceDecl>(*D) ||
-             isa<ObjCProtocolDecl>(*D) ||
-             isa<ObjCCategoryImplDecl>(*D) ||
-             isa<ObjCCategoryDecl>(*D))
+               isa<ObjCImplementationDecl>(*D) || isa<ObjCInterfaceDecl>(*D) ||
+               isa<ObjCProtocolDecl>(*D) || isa<ObjCCategoryImplDecl>(*D) ||
+               isa<ObjCCategoryDecl>(*D))
       Terminator = nullptr;
     else if (isa<EnumConstantDecl>(*D)) {
       DeclContext::decl_iterator Next = D;
@@ -482,7 +479,9 @@
         ((isa<FunctionDecl>(*D) &&
           cast<FunctionDecl>(*D)->doesThisDeclarationHaveABody()) ||
          (isa<FunctionTemplateDecl>(*D) &&
-          cast<FunctionTemplateDecl>(*D)->getTemplatedDecl()->doesThisDeclarationHaveABody())))
+          cast<FunctionTemplateDecl>(*D)
+              ->getTemplatedDecl()
+              ->doesThisDeclarationHaveABody())))
       ; // StmtPrinter already added '\n' after CompoundStmt.
     else
       Out << "\n";
@@ -576,7 +575,7 @@
 
 static void printExplicitSpecifier(ExplicitSpecifier ES, llvm::raw_ostream &Out,
                                    PrintingPolicy &Policy, unsigned Indentation,
-                                   const ASTContext &Context) {
+                                   ASTContext const &Context) {
   std::string Proto = "explicit";
   llvm::raw_string_ostream EOut(Proto);
   if (ES.getExpr()) {
@@ -608,20 +607,32 @@
   CXXDeductionGuideDecl *GuideDecl = dyn_cast<CXXDeductionGuideDecl>(D);
   if (!Policy.SuppressSpecifiers) {
     switch (D->getStorageClass()) {
-    case SC_None: break;
-    case SC_Extern: Out << "extern "; break;
-    case SC_Static: Out << "static "; break;
-    case SC_PrivateExtern: Out << "__private_extern__ "; break;
-    case SC_Auto: case SC_Register:
+    case SC_None:
+      break;
+    case SC_Extern:
+      Out << "extern ";
+      break;
+    case SC_Static:
+      Out << "static ";
+      break;
+    case SC_PrivateExtern:
+      Out << "__private_extern__ ";
+      break;
+    case SC_Auto:
+    case SC_Register:
       llvm_unreachable("invalid for functions");
     }
 
-    if (D->isInlineSpecified())  Out << "inline ";
-    if (D->isVirtualAsWritten()) Out << "virtual ";
-    if (D->isModulePrivate())    Out << "__module_private__ ";
+    if (D->isInlineSpecified())
+      Out << "inline ";
+    if (D->isVirtualAsWritten())
+      Out << "virtual ";
+    if (D->isModulePrivate())
+      Out << "__module_private__ ";
     if (D->isConstexprSpecified() && !D->isExplicitlyDefaulted())
       Out << "constexpr ";
-    if (D->isConsteval())        Out << "consteval ";
+    if (D->isConsteval())
+      Out << "consteval ";
     ExplicitSpecifier ExplicitSpec = ExplicitSpecifier::getFromDecl(D);
     if (ExplicitSpec.isSpecified())
       printExplicitSpecifier(ExplicitSpec, Out, Policy, Indentation, Context);
@@ -636,7 +647,7 @@
   } else {
     llvm::raw_string_ostream OS(Proto);
     if (!Policy.SuppressScope) {
-      if (const NestedNameSpecifier *NS = D->getQualifier()) {
+      if (NestedNameSpecifier const *NS = D->getQualifier()) {
         NS->print(OS, Policy);
       }
     }
@@ -648,27 +659,27 @@
   if (D->isFunctionTemplateSpecialization()) {
     llvm::raw_string_ostream POut(Proto);
     DeclPrinter TArgPrinter(POut, SubPolicy, Context, Indentation);
-    const auto *TArgAsWritten = D->getTemplateSpecializationArgsAsWritten();
-    const TemplateParameterList *TPL = D->getTemplateSpecializationInfo()
+    auto const *TArgAsWritten = D->getTemplateSpecializationArgsAsWritten();
+    TemplateParameterList const *TPL = D->getTemplateSpecializationInfo()
                                            ->getTemplate()
                                            ->getTemplateParameters();
     if (TArgAsWritten && !Policy.PrintCanonicalTypes)
       TArgPrinter.printTemplateArguments(TArgAsWritten->arguments(), TPL,
                                          /*TemplOverloaded*/ true);
-    else if (const TemplateArgumentList *TArgs =
+    else if (TemplateArgumentList const *TArgs =
                  D->getTemplateSpecializationArgs())
       TArgPrinter.printTemplateArguments(TArgs->asArray(), TPL,
                                          /*TemplOverloaded*/ true);
   }
 
   QualType Ty = D->getType();
-  while (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
+  while (ParenType const *PT = dyn_cast<ParenType>(Ty)) {
     Proto = '(' + Proto + ')';
     Ty = PT->getInnerType();
   }
 
-  if (const FunctionType *AFT = Ty->getAs<FunctionType>()) {
-    const FunctionProtoType *FT = nullptr;
+  if (FunctionType const *AFT = Ty->getAs<FunctionType>()) {
+    FunctionProtoType const *FT = nullptr;
     if (D->hasWrittenPrototype())
       FT = dyn_cast<FunctionProtoType>(AFT);
 
@@ -677,12 +688,14 @@
       llvm::raw_string_ostream POut(Proto);
       DeclPrinter ParamPrinter(POut, SubPolicy, Context, Indentation);
       for (unsigned i = 0, e = D->getNumParams(); i != e; ++i) {
-        if (i) POut << ", ";
+        if (i)
+          POut << ", ";
         ParamPrinter.VisitParmVarDecl(D->getParamDecl(i));
       }
 
       if (FT->isVariadic()) {
-        if (D->getNumParams()) POut << ", ";
+        if (D->getNumParams())
+          POut << ", ";
         POut << "...";
       }
     } else if (D->doesThisDeclarationHaveABody() && !D->hasPrototype()) {
@@ -806,19 +819,15 @@
       printTemplateParameters(D->getFriendTypeTemplateParameterList(i));
     Out << "friend ";
     Out << " " << TSI->getType().getAsString(Policy);
-  }
-  else if (FunctionDecl *FD =
-      dyn_cast<FunctionDecl>(D->getFriendDecl())) {
+  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D->getFriendDecl())) {
     Out << "friend ";
     VisitFunctionDecl(FD);
-  }
-  else if (FunctionTemplateDecl *FTD =
-           dyn_cast<FunctionTemplateDecl>(D->getFriendDecl())) {
+  } else if (FunctionTemplateDecl *FTD =
+                 dyn_cast<FunctionTemplateDecl>(D->getFriendDecl())) {
     Out << "friend ";
     VisitFunctionTemplateDecl(FTD);
-  }
-  else if (ClassTemplateDecl *CTD =
-           dyn_cast<ClassTemplateDecl>(D->getFriendDecl())) {
+  } else if (ClassTemplateDecl *CTD =
+                 dyn_cast<ClassTemplateDecl>(D->getFriendDecl())) {
     Out << "friend ";
     VisitRedeclarableTemplateDecl(CTD);
   }
@@ -831,8 +840,9 @@
   if (!Policy.SuppressSpecifiers && D->isModulePrivate())
     Out << "__module_private__ ";
 
-  Out << D->getASTContext().getUnqualifiedObjCPointerType(D->getType()).
-         stream(Policy, D->getName(), Indentation);
+  Out << D->getASTContext()
+             .getUnqualifiedObjCPointerType(D->getType())
+             .stream(Policy, D->getName(), Indentation);
 
   if (D->isBitField()) {
     Out << " : ";
@@ -851,16 +861,15 @@
   prettyPrintAttributes(D);
 }
 
-void DeclPrinter::VisitLabelDecl(LabelDecl *D) {
-  Out << *D << ":";
-}
+void DeclPrinter::VisitLabelDecl(LabelDecl *D) { Out << *D << ":"; }
 
 void DeclPrinter::VisitVarDecl(VarDecl *D) {
   prettyPrintPragmas(D);
 
-  QualType T = D->getTypeSourceInfo()
-    ? D->getTypeSourceInfo()->getType()
-    : D->getASTContext().getUnqualifiedObjCPointerType(D->getType());
+  QualType T =
+      D->getTypeSourceInfo()
+          ? D->getTypeSourceInfo()->getType()
+          : D->getASTContext().getUnqualifiedObjCPointerType(D->getType());
 
   if (!Policy.SuppressSpecifiers) {
     StorageClass SC = D->getStorageClass();
@@ -899,7 +908,7 @@
       if (D->getInitStyle() == VarDecl::CallInit &&
           !Construct->isListInitialization()) {
         ImplicitInit = Construct->getNumArgs() == 0 ||
-          Construct->getArg(0)->isDefaultArgument();
+                       Construct->getArg(0)->isDefaultArgument();
       }
     }
     if (!ImplicitInit) {
@@ -919,9 +928,7 @@
   prettyPrintAttributes(D);
 }
 
-void DeclPrinter::VisitParmVarDecl(ParmVarDecl *D) {
-  VisitVarDecl(D);
-}
+void DeclPrinter::VisitParmVarDecl(ParmVarDecl *D) { VisitVarDecl(D); }
 
 void DeclPrinter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) {
   Out << "__asm (";
@@ -931,8 +938,7 @@
 }
 
 void DeclPrinter::VisitImportDecl(ImportDecl *D) {
-  Out << "@import " << D->getImportedModule()->getFullModuleName()
-      << ";\n";
+  Out << "@import " << D->getImportedModule()->getFullModuleName() << ";\n";
 }
 
 void DeclPrinter::VisitStaticAssertDecl(StaticAssertDecl *D) {
@@ -976,9 +982,7 @@
   Out << *D->getAliasedNamespace();
 }
 
-void DeclPrinter::VisitEmptyDecl(EmptyDecl *D) {
-  prettyPrintAttributes(D);
-}
+void DeclPrinter::VisitEmptyDecl(EmptyDecl *D) { prettyPrintAttributes(D); }
 
 void DeclPrinter::VisitCXXRecordDecl(CXXRecordDecl *D) {
   // FIXME: add printing of pragma attributes if required.
@@ -994,8 +998,8 @@
     if (auto S = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
       ArrayRef<TemplateArgument> Args = S->getTemplateArgs().asArray();
       if (!Policy.PrintCanonicalTypes)
-        if (const auto* TSI = S->getTypeAsWritten())
-          if (const auto *TST =
+        if (auto const *TSI = S->getTypeAsWritten())
+          if (auto const *TST =
                   dyn_cast<TemplateSpecializationType>(TSI->getType()))
             Args = TST->template_arguments();
       printTemplateArguments(
@@ -1009,7 +1013,8 @@
     if (D->getNumBases()) {
       Out << " : ";
       for (CXXRecordDecl::base_class_iterator Base = D->bases_begin(),
-             BaseEnd = D->bases_end(); Base != BaseEnd; ++Base) {
+                                              BaseEnd = D->bases_end();
+           Base != BaseEnd; ++Base) {
         if (Base != D->bases_begin())
           Out << ", ";
 
@@ -1041,7 +1046,7 @@
 }
 
 void DeclPrinter::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
-  const char *l;
+  char const *l;
   if (D->getLanguage() == LinkageSpecDecl::lang_c)
     l = "C";
   else {
@@ -1059,7 +1064,7 @@
     Visit(*D->decls_begin());
 }
 
-void DeclPrinter::printTemplateParameters(const TemplateParameterList *Params,
+void DeclPrinter::printTemplateParameters(TemplateParameterList const *Params,
                                           bool OmitTemplateKW) {
   assert(Params);
 
@@ -1068,7 +1073,7 @@
   Out << '<';
 
   bool NeedComma = false;
-  for (const Decl *Param : *Params) {
+  for (Decl const *Param : *Params) {
     if (Param->isImplicit())
       continue;
 
@@ -1077,7 +1082,7 @@
     else
       NeedComma = true;
 
-    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
+    if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
       VisitTemplateTypeParmDecl(TTP);
     } else if (auto NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
       VisitNonTypeTemplateParmDecl(NTTP);
@@ -1093,7 +1098,7 @@
 }
 
 void DeclPrinter::printTemplateArguments(ArrayRef<TemplateArgument> Args,
-                                         const TemplateParameterList *Params,
+                                         TemplateParameterList const *Params,
                                          bool TemplOverloaded) {
   Out << "<";
   for (size_t I = 0, E = Args.size(); I < E; ++I) {
@@ -1110,7 +1115,7 @@
 }
 
 void DeclPrinter::printTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
-                                         const TemplateParameterList *Params,
+                                         TemplateParameterList const *Params,
                                          bool TemplOverloaded) {
   Out << "<";
   for (size_t I = 0, E = Args.size(); I < E; ++I) {
@@ -1126,11 +1131,11 @@
   Out << ">";
 }
 
-void DeclPrinter::VisitTemplateDecl(const TemplateDecl *D) {
+void DeclPrinter::VisitTemplateDecl(TemplateDecl const *D) {
   printTemplateParameters(D->getTemplateParameters());
 
-  if (const TemplateTemplateParmDecl *TTP =
-        dyn_cast<TemplateTemplateParmDecl>(D)) {
+  if (TemplateTemplateParmDecl const *TTP =
+          dyn_cast<TemplateTemplateParmDecl>(D)) {
     Out << "class";
 
     if (TTP->isParameterPack())
@@ -1142,8 +1147,8 @@
       Out << TTP->getDeclName();
   } else if (auto *TD = D->getTemplatedDecl())
     Visit(TD);
-  else if (const auto *Concept = dyn_cast<ConceptDecl>(D)) {
-    Out << "concept " << Concept->getName() << " = " ;
+  else if (auto const *Concept = dyn_cast<ConceptDecl>(D)) {
+    Out << "concept " << Concept->getName() << " = ";
     Concept->getConstraintExpr()->printPretty(Out, nullptr, Policy, Indentation,
                                               "\n", &Context);
   }
@@ -1152,7 +1157,7 @@
 void DeclPrinter::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
   prettyPrintPragmas(D->getTemplatedDecl());
   // Print any leading template parameter lists.
-  if (const FunctionDecl *FD = D->getTemplatedDecl()) {
+  if (FunctionDecl const *FD = D->getTemplatedDecl()) {
     for (unsigned I = 0, NumTemplateParams = FD->getNumTemplateParameterLists();
          I < NumTemplateParams; ++I)
       printTemplateParameters(FD->getTemplateParameterList(I));
@@ -1168,7 +1173,7 @@
   if (PrintInstantiation &&
       !isa<CXXDeductionGuideDecl>(D->getTemplatedDecl())) {
     FunctionDecl *PrevDecl = D->getTemplatedDecl();
-    const FunctionDecl *Def;
+    FunctionDecl const *Def;
     if (PrevDecl->isDefined(Def) && Def != PrevDecl)
       return;
     for (auto *I : D->specializations())
@@ -1197,13 +1202,13 @@
 }
 
 void DeclPrinter::VisitClassTemplateSpecializationDecl(
-                                           ClassTemplateSpecializationDecl *D) {
+    ClassTemplateSpecializationDecl *D) {
   Out << "template<> ";
   VisitCXXRecordDecl(D);
 }
 
 void DeclPrinter::VisitClassTemplatePartialSpecializationDecl(
-                                    ClassTemplatePartialSpecializationDecl *D) {
+    ClassTemplatePartialSpecializationDecl *D) {
   printTemplateParameters(D->getTemplateParameters());
   VisitCXXRecordDecl(D);
 }
@@ -1281,14 +1286,13 @@
 
   std::string name = OMD->getSelector().getAsString();
   std::string::size_type pos, lastPos = 0;
-  for (const auto *PI : OMD->parameters()) {
+  for (auto const *PI : OMD->parameters()) {
     // FIXME: selector is missing here!
     pos = name.find_first_of(':', lastPos);
     if (lastPos != 0)
       Out << " ";
     Out << name.substr(lastPos, pos - lastPos) << ':';
-    PrintObjCMethodType(OMD->getASTContext(),
-                        PI->getObjCDeclQualifier(),
+    PrintObjCMethodType(OMD->getASTContext(), PI->getObjCDeclQualifier(),
                         PI->getType());
     Out << *PI;
     lastPos = pos + 1;
@@ -1298,7 +1302,7 @@
     Out << name;
 
   if (OMD->isVariadic())
-      Out << ", ...";
+    Out << ", ...";
 
   prettyPrintAttributes(OMD);
 
@@ -1306,8 +1310,7 @@
     Out << ' ';
     OMD->getBody()->printPretty(Out, nullptr, Policy, Indentation, "\n",
                                 &Context);
-  }
-  else if (Policy.PolishForDeclaration)
+  } else if (Policy.PolishForDeclaration)
     Out << ';';
 }
 
@@ -1325,14 +1328,15 @@
     Out << "{\n";
     eolnOut = true;
     Indentation += Policy.Indentation;
-    for (const auto *I : OID->ivars()) {
-      Indent() << I->getASTContext().getUnqualifiedObjCPointerType(I->getType()).
-                    getAsString(Policy) << ' ' << *I << ";\n";
+    for (auto const *I : OID->ivars()) {
+      Indent() << I->getASTContext()
+                      .getUnqualifiedObjCPointerType(I->getType())
+                      .getAsString(Policy)
+               << ' ' << *I << ";\n";
     }
     Indentation -= Policy.Indentation;
     Out << "}\n";
-  }
-  else if (SID || (OID->decls_begin() != OID->decls_end())) {
+  } else if (SID || (OID->decls_begin() != OID->decls_end())) {
     Out << "\n";
     eolnOut = true;
   }
@@ -1367,10 +1371,11 @@
     Out << " : " << QualType(OID->getSuperClassType(), 0).getAsString(Policy);
 
   // Protocols?
-  const ObjCList<ObjCProtocolDecl> &Protocols = OID->getReferencedProtocols();
+  ObjCList<ObjCProtocolDecl> const &Protocols = OID->getReferencedProtocols();
   if (!Protocols.empty()) {
     for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
-         E = Protocols.end(); I != E; ++I)
+                                              E = Protocols.end();
+         I != E; ++I)
       Out << (I == Protocols.begin() ? '<' : ',') << **I;
     Out << "> ";
   }
@@ -1379,15 +1384,15 @@
     Out << "{\n";
     eolnOut = true;
     Indentation += Policy.Indentation;
-    for (const auto *I : OID->ivars()) {
+    for (auto const *I : OID->ivars()) {
       Indent() << I->getASTContext()
                       .getUnqualifiedObjCPointerType(I->getType())
-                      .getAsString(Policy) << ' ' << *I << ";\n";
+                      .getAsString(Policy)
+               << ' ' << *I << ";\n";
     }
     Indentation -= Policy.Indentation;
     Out << "}\n";
-  }
-  else if (SID || (OID->decls_begin() != OID->decls_end())) {
+  } else if (SID || (OID->decls_begin() != OID->decls_end())) {
     Out << "\n";
     eolnOut = true;
   }
@@ -1405,11 +1410,12 @@
     return;
   }
   // Protocols?
-  const ObjCList<ObjCProtocolDecl> &Protocols = PID->getReferencedProtocols();
+  ObjCList<ObjCProtocolDecl> const &Protocols = PID->getReferencedProtocols();
   if (!Protocols.empty()) {
     Out << "@protocol " << *PID;
     for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
-         E = Protocols.end(); I != E; ++I)
+                                              E = Protocols.end();
+         I != E; ++I)
       Out << (I == Protocols.begin() ? '<' : ',') << **I;
     Out << ">\n";
   } else
@@ -1420,7 +1426,7 @@
 
 void DeclPrinter::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *PID) {
   Out << "@implementation ";
-  if (const auto *CID = PID->getClassInterface())
+  if (auto const *CID = PID->getClassInterface())
     Out << *CID;
   else
     Out << "<<error-type>>";
@@ -1433,7 +1439,7 @@
 
 void DeclPrinter::VisitObjCCategoryDecl(ObjCCategoryDecl *PID) {
   Out << "@interface ";
-  if (const auto *CID = PID->getClassInterface())
+  if (auto const *CID = PID->getClassInterface())
     Out << *CID;
   else
     Out << "<<error-type>>";
@@ -1444,9 +1450,11 @@
   if (PID->ivar_size() > 0) {
     Out << "{\n";
     Indentation += Policy.Indentation;
-    for (const auto *I : PID->ivars())
-      Indent() << I->getASTContext().getUnqualifiedObjCPointerType(I->getType()).
-                    getAsString(Policy) << ' ' << *I << ";\n";
+    for (auto const *I : PID->ivars())
+      Indent() << I->getASTContext()
+                      .getUnqualifiedObjCPointerType(I->getType())
+                      .getAsString(Policy)
+               << ' ' << *I << ";\n";
     Indentation -= Policy.Indentation;
     Out << "}\n";
   }
@@ -1458,8 +1466,8 @@
 }
 
 void DeclPrinter::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *AID) {
-  Out << "@compatibility_alias " << *AID
-      << ' ' << *AID->getClassInterface() << ";\n";
+  Out << "@compatibility_alias " << *AID << ' ' << *AID->getClassInterface()
+      << ";\n";
 }
 
 /// PrintObjCPropertyDecl - print a property declaration.
@@ -1566,11 +1574,12 @@
       }
     }
 
-    (void) first; // Silence dead store warning due to idiomatic code.
+    (void)first; // Silence dead store warning due to idiomatic code.
     Out << ")";
   }
-  std::string TypeStr = PDecl->getASTContext().getUnqualifiedObjCPointerType(T).
-      getAsString(Policy);
+  std::string TypeStr =
+      PDecl->getASTContext().getUnqualifiedObjCPointerType(T).getAsString(
+          Policy);
   Out << ' ' << TypeStr;
   if (!StringRef(TypeStr).endswith("*"))
     Out << ' ';
@@ -1598,8 +1607,8 @@
 
   // Use the correct record name when the using declaration is used for
   // inheriting constructors.
-  for (const auto *Shadow : D->shadows()) {
-    if (const auto *ConstructorShadow =
+  for (auto const *Shadow : D->shadows()) {
+    if (auto const *ConstructorShadow =
             dyn_cast<ConstructorUsingShadowDecl>(Shadow)) {
       assert(Shadow->getDeclContext() == ConstructorShadow->getDeclContext());
       Out << *ConstructorShadow->getNominatedBaseClass();
@@ -1613,8 +1622,8 @@
   Out << "using enum " << D->getEnumDecl();
 }
 
-void
-DeclPrinter::VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D) {
+void DeclPrinter::VisitUnresolvedUsingTypenameDecl(
+    UnresolvedUsingTypenameDecl *D) {
   Out << "using typename ";
   D->getQualifier()->print(Out, Policy);
   Out << D->getDeclName();
@@ -1636,7 +1645,7 @@
   if (!D->varlist_empty()) {
     for (OMPThreadPrivateDecl::varlist_iterator I = D->varlist_begin(),
                                                 E = D->varlist_end();
-                                                I != E; ++I) {
+         I != E; ++I) {
       Out << (I == D->varlist_begin() ? '(' : ',');
       NamedDecl *ND = cast<DeclRefExpr>(*I)->getDecl();
       ND->printQualifiedName(Out);
@@ -1678,7 +1687,7 @@
   if (!D->isInvalidDecl()) {
     Out << "#pragma omp declare reduction (";
     if (D->getDeclName().getNameKind() == DeclarationName::CXXOperatorName) {
-      const char *OpName =
+      char const *OpName =
           getOperatorSpelling(D->getDeclName().getCXXOverloadedOperator());
       assert(OpName && "not an overloaded operator");
       Out << OpName;
@@ -1734,8 +1743,8 @@
   D->getInit()->printPretty(Out, nullptr, Policy, Indentation, "\n", &Context);
 }
 
-void DeclPrinter::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *TTP) {
-  if (const TypeConstraint *TC = TTP->getTypeConstraint())
+void DeclPrinter::VisitTemplateTypeParmDecl(TemplateTypeParmDecl const *TTP) {
+  if (TypeConstraint const *TC = TTP->getTypeConstraint())
     TC->print(Out, Policy);
   else if (TTP->wasDeclaredWithTypename())
     Out << "typename";
@@ -1757,7 +1766,7 @@
 }
 
 void DeclPrinter::VisitNonTypeTemplateParmDecl(
-    const NonTypeTemplateParmDecl *NTTP) {
+    NonTypeTemplateParmDecl const *NTTP) {
   StringRef Name;
   if (IdentifierInfo *II = NTTP->getIdentifier())
     Name = II->getName();
Index: clang/lib/AST/DeclTemplate.cpp
===================================================================
--- clang/lib/AST/DeclTemplate.cpp
+++ clang/lib/AST/DeclTemplate.cpp
@@ -43,8 +43,7 @@
 // TemplateParameterList Implementation
 //===----------------------------------------------------------------------===//
 
-
-TemplateParameterList::TemplateParameterList(const ASTContext& C,
+TemplateParameterList::TemplateParameterList(ASTContext const &C,
                                              SourceLocation TemplateLoc,
                                              SourceLocation LAngleLoc,
                                              ArrayRef<NamedDecl *> Params,
@@ -59,19 +58,19 @@
     begin()[Idx] = P;
 
     bool IsPack = P->isTemplateParameterPack();
-    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
+    if (auto const *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
       if (!IsPack && NTTP->getType()->containsUnexpandedParameterPack())
         ContainsUnexpandedParameterPack = true;
       if (NTTP->hasPlaceholderTypeConstraint())
         HasConstrainedParameters = true;
-    } else if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P)) {
+    } else if (auto const *TTP = dyn_cast<TemplateTemplateParmDecl>(P)) {
       if (!IsPack &&
           TTP->getTemplateParameters()->containsUnexpandedParameterPack())
         ContainsUnexpandedParameterPack = true;
-    } else if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
-      if (const TypeConstraint *TC = TTP->getTypeConstraint()) {
+    } else if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
+      if (TypeConstraint const *TC = TTP->getTypeConstraint()) {
         if (TC->getImmediatelyDeclaredConstraint()
-            ->containsUnexpandedParameterPack())
+                ->containsUnexpandedParameterPack())
           ContainsUnexpandedParameterPack = true;
       }
       if (TTP->hasTypeConstraint())
@@ -99,12 +98,12 @@
   // An implicit constrained parameter might have had a use of an unexpanded
   // pack added to it after the template parameter list was created. All
   // implicit parameters are at the end of the parameter list.
-  for (const NamedDecl *Param : llvm::reverse(asArray())) {
+  for (NamedDecl const *Param : llvm::reverse(asArray())) {
     if (!Param->isImplicit())
       break;
 
-    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
-      const auto *TC = TTP->getTypeConstraint();
+    if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
+      auto const *TC = TTP->getTypeConstraint();
       if (TC && TC->getImmediatelyDeclaredConstraint()
                     ->containsUnexpandedParameterPack())
         return true;
@@ -115,7 +114,7 @@
 }
 
 TemplateParameterList *
-TemplateParameterList::Create(const ASTContext &C, SourceLocation TemplateLoc,
+TemplateParameterList::Create(ASTContext const &C, SourceLocation TemplateLoc,
                               SourceLocation LAngleLoc,
                               ArrayRef<NamedDecl *> Params,
                               SourceLocation RAngleLoc, Expr *RequiresClause) {
@@ -128,7 +127,7 @@
 
 unsigned TemplateParameterList::getMinRequiredArguments() const {
   unsigned NumRequiredArgs = 0;
-  for (const NamedDecl *P : asArray()) {
+  for (NamedDecl const *P : asArray()) {
     if (P->isTemplateParameterPack()) {
       if (Optional<unsigned> Expansions = getExpandedPackSize(P)) {
         NumRequiredArgs += *Expansions;
@@ -137,10 +136,10 @@
       break;
     }
 
-    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
+    if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(P)) {
       if (TTP->hasDefaultArgument())
         break;
-    } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
+    } else if (auto const *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
       if (NTTP->hasDefaultArgument())
         break;
     } else if (cast<TemplateTemplateParmDecl>(P)->hasDefaultArgument())
@@ -156,10 +155,10 @@
   if (size() == 0)
     return 0;
 
-  const NamedDecl *FirstParm = getParam(0);
-  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm))
+  NamedDecl const *FirstParm = getParam(0);
+  if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm))
     return TTP->getDepth();
-  else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
+  else if (auto const *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
     return NTTP->getDepth();
   else
     return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
@@ -170,20 +169,20 @@
   for (NamedDecl *P : *Params) {
     P->setDeclContext(Owner);
 
-    if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
+    if (auto const *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
       AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner);
   }
 }
 
-void TemplateParameterList::
-getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+void TemplateParameterList::getAssociatedConstraints(
+    llvm::SmallVectorImpl<Expr const *> &AC) const {
   if (HasConstrainedParameters)
-    for (const NamedDecl *Param : *this) {
-      if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
-        if (const auto *TC = TTP->getTypeConstraint())
+    for (NamedDecl const *Param : *this) {
+      if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
+        if (auto const *TC = TTP->getTypeConstraint())
           AC.push_back(TC->getImmediatelyDeclaredConstraint());
-      } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
-        if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
+      } else if (auto const *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
+        if (Expr const *E = NTTP->getPlaceholderTypeConstraint())
           AC.push_back(E);
       }
     }
@@ -196,11 +195,11 @@
 }
 
 bool TemplateParameterList::shouldIncludeTypeForArgument(
-    const TemplateParameterList *TPL, unsigned Idx) {
+    TemplateParameterList const *TPL, unsigned Idx) {
   if (!TPL || Idx >= TPL->size())
     return true;
-  const NamedDecl *TemplParam = TPL->getParam(Idx);
-  if (const auto *ParamValueDecl =
+  NamedDecl const *TemplParam = TPL->getParam(Idx);
+  if (auto const *ParamValueDecl =
           dyn_cast<NonTypeTemplateParmDecl>(TemplParam))
     if (ParamValueDecl->getType()->getContainedDeducedType())
       return true;
@@ -209,8 +208,8 @@
 
 namespace clang {
 
-void *allocateDefaultArgStorageChain(const ASTContext &C) {
-  return new (C) char[sizeof(void*) * 2];
+void *allocateDefaultArgStorageChain(ASTContext const &C) {
+  return new (C) char[sizeof(void *) * 2];
 }
 
 } // namespace clang
@@ -226,11 +225,11 @@
 
 void TemplateDecl::anchor() {}
 
-void TemplateDecl::
-getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
+void TemplateDecl::getAssociatedConstraints(
+    llvm::SmallVectorImpl<Expr const *> &AC) const {
   TemplateParams->getAssociatedConstraints(AC);
   if (auto *FD = dyn_cast_or_null<FunctionDecl>(getTemplatedDecl()))
-    if (const Expr *TRC = FD->getTrailingRequiresClause())
+    if (Expr const *TRC = FD->getTrailingRequiresClause())
       AC.push_back(TRC);
 }
 
@@ -248,14 +247,15 @@
 
 void RedeclarableTemplateDecl::anchor() {}
 
-RedeclarableTemplateDecl::CommonBase *RedeclarableTemplateDecl::getCommonPtr() const {
+RedeclarableTemplateDecl::CommonBase *
+RedeclarableTemplateDecl::getCommonPtr() const {
   if (Common)
     return Common;
 
   // Walk the previous-declaration chain until we either find a declaration
   // with a common pointer or we run out of previous declarations.
-  SmallVector<const RedeclarableTemplateDecl *, 2> PrevDecls;
-  for (const RedeclarableTemplateDecl *Prev = getPreviousDecl(); Prev;
+  SmallVector<RedeclarableTemplateDecl const *, 2> PrevDecls;
+  for (RedeclarableTemplateDecl const *Prev = getPreviousDecl(); Prev;
        Prev = Prev->getPreviousDecl()) {
     if (Prev->Common) {
       Common = Prev->Common;
@@ -274,7 +274,7 @@
   }
 
   // Update any previous declarations we saw with the common pointer.
-  for (const RedeclarableTemplateDecl *Prev : PrevDecls)
+  for (RedeclarableTemplateDecl const *Prev : PrevDecls)
     Prev->Common = Common;
 
   return Common;
@@ -293,11 +293,11 @@
   }
 }
 
-template<class EntryType, typename... ProfileArguments>
+template <class EntryType, typename... ProfileArguments>
 typename RedeclarableTemplateDecl::SpecEntryTraits<EntryType>::DeclType *
 RedeclarableTemplateDecl::findSpecializationImpl(
     llvm::FoldingSetVector<EntryType> &Specs, void *&InsertPos,
-    ProfileArguments&&... ProfileArgs) {
+    ProfileArguments &&...ProfileArgs) {
   using SETraits = SpecEntryTraits<EntryType>;
 
   llvm::FoldingSetNodeID ID;
@@ -307,7 +307,7 @@
   return Entry ? SETraits::getDecl(Entry)->getMostRecentDecl() : nullptr;
 }
 
-template<class Derived, class EntryType>
+template <class Derived, class EntryType>
 void RedeclarableTemplateDecl::addSpecializationImpl(
     llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
     void *InsertPos) {
@@ -316,8 +316,7 @@
   if (InsertPos) {
 #ifndef NDEBUG
     void *CorrectInsertPos;
-    assert(!findSpecializationImpl(Specializations,
-                                   CorrectInsertPos,
+    assert(!findSpecializationImpl(Specializations, CorrectInsertPos,
                                    SETraits::getTemplateArgs(Entry)) &&
            InsertPos == CorrectInsertPos &&
            "given incorrect InsertPos for specialization");
@@ -339,12 +338,10 @@
 // FunctionTemplateDecl Implementation
 //===----------------------------------------------------------------------===//
 
-FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C,
-                                                   DeclContext *DC,
-                                                   SourceLocation L,
-                                                   DeclarationName Name,
-                                               TemplateParameterList *Params,
-                                                   NamedDecl *Decl) {
+FunctionTemplateDecl *
+FunctionTemplateDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
+                             DeclarationName Name,
+                             TemplateParameterList *Params, NamedDecl *Decl) {
   AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
   return new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl);
 }
@@ -379,7 +376,7 @@
 }
 
 void FunctionTemplateDecl::addSpecialization(
-      FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
+    FunctionTemplateSpecializationInfo *Info, void *InsertPos) {
   addSpecializationImpl<FunctionTemplateDecl>(getSpecializations(), Info,
                                               InsertPos);
 }
@@ -438,8 +435,7 @@
 // ClassTemplateDecl Implementation
 //===----------------------------------------------------------------------===//
 
-ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C,
-                                             DeclContext *DC,
+ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C, DeclContext *DC,
                                              SourceLocation L,
                                              DeclarationName Name,
                                              TemplateParameterList *Params,
@@ -490,61 +486,60 @@
 }
 
 ClassTemplatePartialSpecializationDecl *
-ClassTemplateDecl::findPartialSpecialization(
-    ArrayRef<TemplateArgument> Args,
-    TemplateParameterList *TPL, void *&InsertPos) {
+ClassTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
+                                             TemplateParameterList *TPL,
+                                             void *&InsertPos) {
   return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
                                 TPL);
 }
 
 static void ProfileTemplateParameterList(ASTContext &C,
-    llvm::FoldingSetNodeID &ID, const TemplateParameterList *TPL) {
-  const Expr *RC = TPL->getRequiresClause();
+                                         llvm::FoldingSetNodeID &ID,
+                                         TemplateParameterList const *TPL) {
+  Expr const *RC = TPL->getRequiresClause();
   ID.AddBoolean(RC != nullptr);
   if (RC)
     RC->Profile(ID, C, /*Canonical=*/true);
   ID.AddInteger(TPL->size());
   for (NamedDecl *D : *TPL) {
-    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
+    if (auto const *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) {
       ID.AddInteger(0);
       ID.AddBoolean(NTTP->isParameterPack());
       NTTP->getType().getCanonicalType().Profile(ID);
       continue;
     }
-    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(D)) {
+    if (auto const *TTP = dyn_cast<TemplateTypeParmDecl>(D)) {
       ID.AddInteger(1);
       ID.AddBoolean(TTP->isParameterPack());
       ID.AddBoolean(TTP->hasTypeConstraint());
-      if (const TypeConstraint *TC = TTP->getTypeConstraint())
+      if (TypeConstraint const *TC = TTP->getTypeConstraint())
         TC->getImmediatelyDeclaredConstraint()->Profile(ID, C,
                                                         /*Canonical=*/true);
       continue;
     }
-    const auto *TTP = cast<TemplateTemplateParmDecl>(D);
+    auto const *TTP = cast<TemplateTemplateParmDecl>(D);
     ID.AddInteger(2);
     ID.AddBoolean(TTP->isParameterPack());
     ProfileTemplateParameterList(C, ID, TTP->getTemplateParameters());
   }
 }
 
-void
-ClassTemplatePartialSpecializationDecl::Profile(llvm::FoldingSetNodeID &ID,
-    ArrayRef<TemplateArgument> TemplateArgs, TemplateParameterList *TPL,
-    ASTContext &Context) {
+void ClassTemplatePartialSpecializationDecl::Profile(
+    llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
+    TemplateParameterList *TPL, ASTContext &Context) {
   ID.AddInteger(TemplateArgs.size());
-  for (const TemplateArgument &TemplateArg : TemplateArgs)
+  for (TemplateArgument const &TemplateArg : TemplateArgs)
     TemplateArg.Profile(ID, Context);
   ProfileTemplateParameterList(Context, ID, TPL);
 }
 
 void ClassTemplateDecl::AddPartialSpecialization(
-                                      ClassTemplatePartialSpecializationDecl *D,
-                                      void *InsertPos) {
+    ClassTemplatePartialSpecializationDecl *D, void *InsertPos) {
   if (InsertPos)
     getPartialSpecializations().InsertNode(D, InsertPos);
   else {
-    ClassTemplatePartialSpecializationDecl *Existing
-      = getPartialSpecializations().GetOrInsertNode(D);
+    ClassTemplatePartialSpecializationDecl *Existing =
+        getPartialSpecializations().GetOrInsertNode(D);
     (void)Existing;
     assert(Existing->isCanonicalDecl() && "Non-canonical specialization?");
   }
@@ -555,8 +550,8 @@
 
 void ClassTemplateDecl::getPartialSpecializations(
     SmallVectorImpl<ClassTemplatePartialSpecializationDecl *> &PS) const {
-  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs
-    = getPartialSpecializations();
+  llvm::FoldingSetVector<ClassTemplatePartialSpecializationDecl> &PartialSpecs =
+      getPartialSpecializations();
   PS.clear();
   PS.reserve(PartialSpecs.size());
   for (ClassTemplatePartialSpecializationDecl &P : PartialSpecs)
@@ -577,9 +572,10 @@
 
 ClassTemplatePartialSpecializationDecl *
 ClassTemplateDecl::findPartialSpecInstantiatedFromMember(
-                                    ClassTemplatePartialSpecializationDecl *D) {
+    ClassTemplatePartialSpecializationDecl *D) {
   Decl *DCanon = D->getCanonicalDecl();
-  for (ClassTemplatePartialSpecializationDecl &P : getPartialSpecializations()) {
+  for (ClassTemplatePartialSpecializationDecl &P :
+       getPartialSpecializations()) {
     if (P.getInstantiatedFromMember()->getCanonicalDecl() == DCanon)
       return P.getMostRecentDecl();
   }
@@ -587,8 +583,7 @@
   return nullptr;
 }
 
-QualType
-ClassTemplateDecl::getInjectedClassNameSpecialization() {
+QualType ClassTemplateDecl::getInjectedClassNameSpecialization() {
   Common *CommonPtr = getCommonPtr();
   if (!CommonPtr->InjectedClassNameType.isNull())
     return CommonPtr->InjectedClassNameType;
@@ -604,9 +599,8 @@
   TemplateParameterList *Params = getTemplateParameters();
   SmallVector<TemplateArgument, 16> TemplateArgs;
   Context.getInjectedTemplateArgs(Params, TemplateArgs);
-  CommonPtr->InjectedClassNameType
-    = Context.getTemplateSpecializationType(TemplateName(this),
-                                            TemplateArgs);
+  CommonPtr->InjectedClassNameType =
+      Context.getTemplateSpecializationType(TemplateName(this), TemplateArgs);
   return CommonPtr->InjectedClassNameType;
 }
 
@@ -614,37 +608,33 @@
 // TemplateTypeParm Allocation/Deallocation Method Implementations
 //===----------------------------------------------------------------------===//
 
-TemplateTypeParmDecl *
-TemplateTypeParmDecl::Create(const ASTContext &C, DeclContext *DC,
-                             SourceLocation KeyLoc, SourceLocation NameLoc,
-                             unsigned D, unsigned P, IdentifierInfo *Id,
-                             bool Typename, bool ParameterPack,
-                             bool HasTypeConstraint,
-                             Optional<unsigned> NumExpanded) {
-  auto *TTPDecl =
-      new (C, DC,
-           additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
-      TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename,
-                           HasTypeConstraint, NumExpanded);
+TemplateTypeParmDecl *TemplateTypeParmDecl::Create(
+    ASTContext const &C, DeclContext *DC, SourceLocation KeyLoc,
+    SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id,
+    bool Typename, bool ParameterPack, bool HasTypeConstraint,
+    Optional<unsigned> NumExpanded) {
+  auto *TTPDecl = new (
+      C, DC, additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
+      TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename, HasTypeConstraint,
+                           NumExpanded);
   QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
   TTPDecl->setTypeForDecl(TTPType.getTypePtr());
   return TTPDecl;
 }
 
 TemplateTypeParmDecl *
-TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
-  return new (C, ID) TemplateTypeParmDecl(nullptr, SourceLocation(),
-                                          SourceLocation(), nullptr, false,
-                                          false, None);
+TemplateTypeParmDecl::CreateDeserialized(ASTContext const &C, unsigned ID) {
+  return new (C, ID) TemplateTypeParmDecl(
+      nullptr, SourceLocation(), SourceLocation(), nullptr, false, false, None);
 }
 
 TemplateTypeParmDecl *
-TemplateTypeParmDecl::CreateDeserialized(const ASTContext &C, unsigned ID,
+TemplateTypeParmDecl::CreateDeserialized(ASTContext const &C, unsigned ID,
                                          bool HasTypeConstraint) {
   return new (C, ID,
               additionalSizeToAlloc<TypeConstraint>(HasTypeConstraint ? 1 : 0))
-         TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(),
-                              nullptr, false, HasTypeConstraint, None);
+      TemplateTypeParmDecl(nullptr, SourceLocation(), SourceLocation(), nullptr,
+                           false, HasTypeConstraint, None);
 }
 
 SourceLocation TemplateTypeParmDecl::getDefaultArgumentLoc() const {
@@ -677,17 +667,19 @@
   return getTypeForDecl()->castAs<TemplateTypeParmType>()->isParameterPack();
 }
 
-void TemplateTypeParmDecl::setTypeConstraint(NestedNameSpecifierLoc NNS,
-    DeclarationNameInfo NameInfo, NamedDecl *FoundDecl, ConceptDecl *CD,
-    const ASTTemplateArgumentListInfo *ArgsAsWritten,
+void TemplateTypeParmDecl::setTypeConstraint(
+    NestedNameSpecifierLoc NNS, DeclarationNameInfo NameInfo,
+    NamedDecl *FoundDecl, ConceptDecl *CD,
+    ASTTemplateArgumentListInfo const *ArgsAsWritten,
     Expr *ImmediatelyDeclaredConstraint) {
   assert(HasTypeConstraint &&
          "HasTypeConstraint=true must be passed at construction in order to "
          "call setTypeConstraint");
   assert(!TypeConstraintInitialized &&
          "TypeConstraint was already initialized!");
-  new (getTrailingObjects<TypeConstraint>()) TypeConstraint(NNS, NameInfo,
-      FoundDecl, CD, ArgsAsWritten, ImmediatelyDeclaredConstraint);
+  new (getTrailingObjects<TypeConstraint>())
+      TypeConstraint(NNS, NameInfo, FoundDecl, CD, ArgsAsWritten,
+                     ImmediatelyDeclaredConstraint);
   TypeConstraintInitialized = true;
 }
 
@@ -712,32 +704,30 @@
   }
 }
 
-NonTypeTemplateParmDecl *
-NonTypeTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
-                                SourceLocation StartLoc, SourceLocation IdLoc,
-                                unsigned D, unsigned P, IdentifierInfo *Id,
-                                QualType T, bool ParameterPack,
-                                TypeSourceInfo *TInfo) {
+NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
+    ASTContext const &C, DeclContext *DC, SourceLocation StartLoc,
+    SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
+    QualType T, bool ParameterPack, TypeSourceInfo *TInfo) {
   AutoType *AT =
       C.getLangOpts().CPlusPlus20 ? T->getContainedAutoType() : nullptr;
-  return new (C, DC,
-              additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
-                                    Expr *>(0,
-                                            AT && AT->isConstrained() ? 1 : 0))
+  return new (
+      C, DC,
+      additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>(
+          0, AT && AT->isConstrained() ? 1 : 0))
       NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, ParameterPack,
                               TInfo);
 }
 
 NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
-    const ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+    ASTContext const &C, DeclContext *DC, SourceLocation StartLoc,
     SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
     QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
     ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
   AutoType *AT = TInfo->getType()->getContainedAutoType();
-  return new (C, DC,
-              additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
-                                    Expr *>(
-                  ExpandedTypes.size(), AT && AT->isConstrained() ? 1 : 0))
+  return new (
+      C, DC,
+      additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>(
+          ExpandedTypes.size(), AT && AT->isConstrained() ? 1 : 0))
       NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
                               ExpandedTypes, ExpandedTInfos);
 }
@@ -745,12 +735,12 @@
 NonTypeTemplateParmDecl *
 NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
                                             bool HasTypeConstraint) {
-  return new (C, ID, additionalSizeToAlloc<std::pair<QualType,
-                                                     TypeSourceInfo *>,
-                                           Expr *>(0,
-                                                   HasTypeConstraint ? 1 : 0))
-          NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
-                                  0, 0, nullptr, QualType(), false, nullptr);
+  return new (
+      C, ID,
+      additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>(
+          0, HasTypeConstraint ? 1 : 0))
+      NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(), 0, 0,
+                              nullptr, QualType(), false, nullptr);
 }
 
 NonTypeTemplateParmDecl *
@@ -758,9 +748,9 @@
                                             unsigned NumExpandedTypes,
                                             bool HasTypeConstraint) {
   auto *NTTP =
-      new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
-                                        Expr *>(
-                      NumExpandedTypes, HasTypeConstraint ? 1 : 0))
+      new (C, ID,
+           additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>, Expr *>(
+               NumExpandedTypes, HasTypeConstraint ? 1 : 0))
           NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
                                   0, 0, nullptr, QualType(), nullptr, None,
                                   None);
@@ -777,8 +767,8 @@
 
 SourceLocation NonTypeTemplateParmDecl::getDefaultArgumentLoc() const {
   return hasDefaultArgument()
-    ? getDefaultArgument()->getSourceRange().getBegin()
-    : SourceLocation();
+             ? getDefaultArgument()->getSourceRange().getBegin()
+             : SourceLocation();
 }
 
 //===----------------------------------------------------------------------===//
@@ -800,20 +790,18 @@
 }
 
 TemplateTemplateParmDecl *
-TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
+TemplateTemplateParmDecl::Create(ASTContext const &C, DeclContext *DC,
                                  SourceLocation L, unsigned D, unsigned P,
                                  bool ParameterPack, IdentifierInfo *Id,
                                  TemplateParameterList *Params) {
-  return new (C, DC) TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id,
-                                              Params);
+  return new (C, DC)
+      TemplateTemplateParmDecl(DC, L, D, P, ParameterPack, Id, Params);
 }
 
-TemplateTemplateParmDecl *
-TemplateTemplateParmDecl::Create(const ASTContext &C, DeclContext *DC,
-                                 SourceLocation L, unsigned D, unsigned P,
-                                 IdentifierInfo *Id,
-                                 TemplateParameterList *Params,
-                                 ArrayRef<TemplateParameterList *> Expansions) {
+TemplateTemplateParmDecl *TemplateTemplateParmDecl::Create(
+    ASTContext const &C, DeclContext *DC, SourceLocation L, unsigned D,
+    unsigned P, IdentifierInfo *Id, TemplateParameterList *Params,
+    ArrayRef<TemplateParameterList *> Expansions) {
   return new (C, DC,
               additionalSizeToAlloc<TemplateParameterList *>(Expansions.size()))
       TemplateTemplateParmDecl(DC, L, D, P, Id, Params, Expansions);
@@ -842,7 +830,7 @@
 }
 
 void TemplateTemplateParmDecl::setDefaultArgument(
-    const ASTContext &C, const TemplateArgumentLoc &DefArg) {
+    ASTContext const &C, TemplateArgumentLoc const &DefArg) {
   if (DefArg.getArgument().isNull())
     DefaultArgument.set(nullptr);
   else
@@ -868,13 +856,13 @@
 
 FunctionTemplateSpecializationInfo *FunctionTemplateSpecializationInfo::Create(
     ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template,
-    TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs,
-    const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI,
+    TemplateSpecializationKind TSK, TemplateArgumentList const *TemplateArgs,
+    TemplateArgumentListInfo const *TemplateArgsAsWritten, SourceLocation POI,
     MemberSpecializationInfo *MSInfo) {
-  const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
+  ASTTemplateArgumentListInfo const *ArgsAsWritten = nullptr;
   if (TemplateArgsAsWritten)
-    ArgsAsWritten = ASTTemplateArgumentListInfo::Create(C,
-                                                        *TemplateArgsAsWritten);
+    ArgsAsWritten =
+        ASTTemplateArgumentListInfo::Create(C, *TemplateArgsAsWritten);
 
   void *Mem =
       C.Allocate(totalSizeToAlloc<MemberSpecializationInfo *>(MSInfo ? 1 : 0));
@@ -886,19 +874,16 @@
 // ClassTemplateSpecializationDecl Implementation
 //===----------------------------------------------------------------------===//
 
-ClassTemplateSpecializationDecl::
-ClassTemplateSpecializationDecl(ASTContext &Context, Kind DK, TagKind TK,
-                                DeclContext *DC, SourceLocation StartLoc,
-                                SourceLocation IdLoc,
-                                ClassTemplateDecl *SpecializedTemplate,
-                                ArrayRef<TemplateArgument> Args,
-                                ClassTemplateSpecializationDecl *PrevDecl)
+ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(
+    ASTContext &Context, Kind DK, TagKind TK, DeclContext *DC,
+    SourceLocation StartLoc, SourceLocation IdLoc,
+    ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args,
+    ClassTemplateSpecializationDecl *PrevDecl)
     : CXXRecordDecl(DK, TK, Context, DC, StartLoc, IdLoc,
                     SpecializedTemplate->getIdentifier(), PrevDecl),
-    SpecializedTemplate(SpecializedTemplate),
-    TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
-    SpecializationKind(TSK_Undeclared) {
-}
+      SpecializedTemplate(SpecializedTemplate),
+      TemplateArgs(TemplateArgumentList::CreateCopy(Context, Args)),
+      SpecializationKind(TSK_Undeclared) {}
 
 ClassTemplateSpecializationDecl::ClassTemplateSpecializationDecl(ASTContext &C,
                                                                  Kind DK)
@@ -906,18 +891,14 @@
                     SourceLocation(), nullptr, nullptr),
       SpecializationKind(TSK_Undeclared) {}
 
-ClassTemplateSpecializationDecl *
-ClassTemplateSpecializationDecl::Create(ASTContext &Context, TagKind TK,
-                                        DeclContext *DC,
-                                        SourceLocation StartLoc,
-                                        SourceLocation IdLoc,
-                                        ClassTemplateDecl *SpecializedTemplate,
-                                        ArrayRef<TemplateArgument> Args,
-                                   ClassTemplateSpecializationDecl *PrevDecl) {
-  auto *Result =
-      new (Context, DC) ClassTemplateSpecializationDecl(
-          Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
-          SpecializedTemplate, Args, PrevDecl);
+ClassTemplateSpecializationDecl *ClassTemplateSpecializationDecl::Create(
+    ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc,
+    SourceLocation IdLoc, ClassTemplateDecl *SpecializedTemplate,
+    ArrayRef<TemplateArgument> Args,
+    ClassTemplateSpecializationDecl *PrevDecl) {
+  auto *Result = new (Context, DC) ClassTemplateSpecializationDecl(
+      Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
+      SpecializedTemplate, Args, PrevDecl);
   Result->setMayHaveOutOfDateDef(false);
 
   Context.getTypeDeclType(Result, PrevDecl);
@@ -927,24 +908,24 @@
 ClassTemplateSpecializationDecl *
 ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
                                                     unsigned ID) {
-  auto *Result =
-    new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
+  auto *Result = new (C, ID)
+      ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
   Result->setMayHaveOutOfDateDef(false);
   return Result;
 }
 
 void ClassTemplateSpecializationDecl::getNameForDiagnostic(
-    raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
+    raw_ostream &OS, PrintingPolicy const &Policy, bool Qualified) const {
   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
 
-  const auto *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
-  if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
+  auto const *PS = dyn_cast<ClassTemplatePartialSpecializationDecl>(this);
+  if (ASTTemplateArgumentListInfo const *ArgsAsWritten =
           PS ? PS->getTemplateArgsAsWritten() : nullptr) {
     printTemplateArgumentList(
         OS, ArgsAsWritten->arguments(), Policy,
         getSpecializedTemplate()->getTemplateParameters());
   } else {
-    const TemplateArgumentList &TemplateArgs = getTemplateArgs();
+    TemplateArgumentList const &TemplateArgs = getTemplateArgs();
     printTemplateArgumentList(
         OS, TemplateArgs.asArray(), Policy,
         getSpecializedTemplate()->getTemplateParameters());
@@ -953,14 +934,13 @@
 
 ClassTemplateDecl *
 ClassTemplateSpecializationDecl::getSpecializedTemplate() const {
-  if (const auto *PartialSpec =
-          SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization*>())
+  if (auto const *PartialSpec =
+          SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
-  return SpecializedTemplate.get<ClassTemplateDecl*>();
+  return SpecializedTemplate.get<ClassTemplateDecl *>();
 }
 
-SourceRange
-ClassTemplateSpecializationDecl::getSourceRange() const {
+SourceRange ClassTemplateSpecializationDecl::getSourceRange() const {
   if (ExplicitInfo) {
     SourceLocation Begin = getTemplateKeywordLoc();
     if (Begin.isValid()) {
@@ -983,18 +963,17 @@
     CTPSDecl *inst_from = ctpsd->getInstantiatedFromMember();
     assert(inst_from != nullptr);
     return inst_from->getSourceRange();
-  }
-  else {
+  } else {
     // No explicit info available.
     llvm::PointerUnion<ClassTemplateDecl *,
                        ClassTemplatePartialSpecializationDecl *>
-      inst_from = getInstantiatedFrom();
+        inst_from = getInstantiatedFrom();
     if (inst_from.isNull())
       return getSpecializedTemplate()->getSourceRange();
-    if (const auto *ctd = inst_from.dyn_cast<ClassTemplateDecl *>())
+    if (auto const *ctd = inst_from.dyn_cast<ClassTemplateDecl *>())
       return ctd->getSourceRange();
     return inst_from.get<ClassTemplatePartialSpecializationDecl *>()
-      ->getSourceRange();
+        ->getSourceRange();
   }
 }
 
@@ -1009,11 +988,9 @@
   return new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr);
 }
 
-ConceptDecl *ConceptDecl::CreateDeserialized(ASTContext &C,
-                                             unsigned ID) {
-  ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(),
-                                                DeclarationName(),
-                                                nullptr, nullptr);
+ConceptDecl *ConceptDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
+  ConceptDecl *Result = new (C, ID) ConceptDecl(
+      nullptr, SourceLocation(), DeclarationName(), nullptr, nullptr);
 
   return Result;
 }
@@ -1023,42 +1000,33 @@
 //===----------------------------------------------------------------------===//
 void ClassTemplatePartialSpecializationDecl::anchor() {}
 
-ClassTemplatePartialSpecializationDecl::
-ClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
-                                       DeclContext *DC,
-                                       SourceLocation StartLoc,
-                                       SourceLocation IdLoc,
-                                       TemplateParameterList *Params,
-                                       ClassTemplateDecl *SpecializedTemplate,
-                                       ArrayRef<TemplateArgument> Args,
-                               const ASTTemplateArgumentListInfo *ArgInfos,
-                               ClassTemplatePartialSpecializationDecl *PrevDecl)
-    : ClassTemplateSpecializationDecl(Context,
-                                      ClassTemplatePartialSpecialization,
-                                      TK, DC, StartLoc, IdLoc,
-                                      SpecializedTemplate, Args, PrevDecl),
+ClassTemplatePartialSpecializationDecl::ClassTemplatePartialSpecializationDecl(
+    ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc,
+    SourceLocation IdLoc, TemplateParameterList *Params,
+    ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args,
+    ASTTemplateArgumentListInfo const *ArgInfos,
+    ClassTemplatePartialSpecializationDecl *PrevDecl)
+    : ClassTemplateSpecializationDecl(
+          Context, ClassTemplatePartialSpecialization, TK, DC, StartLoc, IdLoc,
+          SpecializedTemplate, Args, PrevDecl),
       TemplateParams(Params), ArgsAsWritten(ArgInfos),
       InstantiatedFromMember(nullptr, false) {
   AdoptTemplateParameterList(Params, this);
 }
 
 ClassTemplatePartialSpecializationDecl *
-ClassTemplatePartialSpecializationDecl::
-Create(ASTContext &Context, TagKind TK,DeclContext *DC,
-       SourceLocation StartLoc, SourceLocation IdLoc,
-       TemplateParameterList *Params,
-       ClassTemplateDecl *SpecializedTemplate,
-       ArrayRef<TemplateArgument> Args,
-       const TemplateArgumentListInfo &ArgInfos,
-       QualType CanonInjectedType,
-       ClassTemplatePartialSpecializationDecl *PrevDecl) {
-  const ASTTemplateArgumentListInfo *ASTArgInfos =
-    ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
-
-  auto *Result = new (Context, DC)
-      ClassTemplatePartialSpecializationDecl(Context, TK, DC, StartLoc, IdLoc,
-                                             Params, SpecializedTemplate, Args,
-                                             ASTArgInfos, PrevDecl);
+ClassTemplatePartialSpecializationDecl::Create(
+    ASTContext &Context, TagKind TK, DeclContext *DC, SourceLocation StartLoc,
+    SourceLocation IdLoc, TemplateParameterList *Params,
+    ClassTemplateDecl *SpecializedTemplate, ArrayRef<TemplateArgument> Args,
+    TemplateArgumentListInfo const &ArgInfos, QualType CanonInjectedType,
+    ClassTemplatePartialSpecializationDecl *PrevDecl) {
+  ASTTemplateArgumentListInfo const *ASTArgInfos =
+      ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
+
+  auto *Result = new (Context, DC) ClassTemplatePartialSpecializationDecl(
+      Context, TK, DC, StartLoc, IdLoc, Params, SpecializedTemplate, Args,
+      ASTArgInfos, PrevDecl);
   Result->setSpecializationKind(TSK_ExplicitSpecialization);
   Result->setMayHaveOutOfDateDef(false);
 
@@ -1097,12 +1065,10 @@
 // TypeAliasTemplateDecl Implementation
 //===----------------------------------------------------------------------===//
 
-TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C,
-                                                     DeclContext *DC,
-                                                     SourceLocation L,
-                                                     DeclarationName Name,
-                                                  TemplateParameterList *Params,
-                                                     NamedDecl *Decl) {
+TypeAliasTemplateDecl *
+TypeAliasTemplateDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
+                              DeclarationName Name,
+                              TemplateParameterList *Params, NamedDecl *Decl) {
   AdoptTemplateParameterList(Params, DC);
   return new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
 }
@@ -1197,17 +1163,17 @@
 
 VarTemplatePartialSpecializationDecl *
 VarTemplateDecl::findPartialSpecialization(ArrayRef<TemplateArgument> Args,
-     TemplateParameterList *TPL, void *&InsertPos) {
+                                           TemplateParameterList *TPL,
+                                           void *&InsertPos) {
   return findSpecializationImpl(getPartialSpecializations(), InsertPos, Args,
                                 TPL);
 }
 
-void
-VarTemplatePartialSpecializationDecl::Profile(llvm::FoldingSetNodeID &ID,
-    ArrayRef<TemplateArgument> TemplateArgs, TemplateParameterList *TPL,
-    ASTContext &Context) {
+void VarTemplatePartialSpecializationDecl::Profile(
+    llvm::FoldingSetNodeID &ID, ArrayRef<TemplateArgument> TemplateArgs,
+    TemplateParameterList *TPL, ASTContext &Context) {
   ID.AddInteger(TemplateArgs.size());
-  for (const TemplateArgument &TemplateArg : TemplateArgs)
+  for (TemplateArgument const &TemplateArg : TemplateArgs)
     TemplateArg.Profile(ID, Context);
   ProfileTemplateParameterList(Context, ID, TPL);
 }
@@ -1285,17 +1251,17 @@
 }
 
 void VarTemplateSpecializationDecl::getNameForDiagnostic(
-    raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
+    raw_ostream &OS, PrintingPolicy const &Policy, bool Qualified) const {
   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
 
-  const auto *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
-  if (const ASTTemplateArgumentListInfo *ArgsAsWritten =
+  auto const *PS = dyn_cast<VarTemplatePartialSpecializationDecl>(this);
+  if (ASTTemplateArgumentListInfo const *ArgsAsWritten =
           PS ? PS->getTemplateArgsAsWritten() : nullptr) {
     printTemplateArgumentList(
         OS, ArgsAsWritten->arguments(), Policy,
         getSpecializedTemplate()->getTemplateParameters());
   } else {
-    const TemplateArgumentList &TemplateArgs = getTemplateArgs();
+    TemplateArgumentList const &TemplateArgs = getTemplateArgs();
     printTemplateArgumentList(
         OS, TemplateArgs.asArray(), Policy,
         getSpecializedTemplate()->getTemplateParameters());
@@ -1303,17 +1269,17 @@
 }
 
 VarTemplateDecl *VarTemplateSpecializationDecl::getSpecializedTemplate() const {
-  if (const auto *PartialSpec =
+  if (auto const *PartialSpec =
           SpecializedTemplate.dyn_cast<SpecializedPartialSpecialization *>())
     return PartialSpec->PartialSpecialization->getSpecializedTemplate();
   return SpecializedTemplate.get<VarTemplateDecl *>();
 }
 
 void VarTemplateSpecializationDecl::setTemplateArgsInfo(
-    const TemplateArgumentListInfo &ArgsInfo) {
+    TemplateArgumentListInfo const &ArgsInfo) {
   TemplateArgsInfo.setLAngleLoc(ArgsInfo.getLAngleLoc());
   TemplateArgsInfo.setRAngleLoc(ArgsInfo.getRAngleLoc());
-  for (const TemplateArgumentLoc &Loc : ArgsInfo.arguments())
+  for (TemplateArgumentLoc const &Loc : ArgsInfo.arguments())
     TemplateArgsInfo.addArgument(Loc);
 }
 
@@ -1328,7 +1294,7 @@
     SourceLocation IdLoc, TemplateParameterList *Params,
     VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
     StorageClass S, ArrayRef<TemplateArgument> Args,
-    const ASTTemplateArgumentListInfo *ArgInfos)
+    ASTTemplateArgumentListInfo const *ArgInfos)
     : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
                                     DC, StartLoc, IdLoc, SpecializedTemplate, T,
                                     TInfo, S, Args),
@@ -1344,14 +1310,13 @@
     SourceLocation IdLoc, TemplateParameterList *Params,
     VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
     StorageClass S, ArrayRef<TemplateArgument> Args,
-    const TemplateArgumentListInfo &ArgInfos) {
-  const ASTTemplateArgumentListInfo *ASTArgInfos
-    = ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
-
-  auto *Result =
-      new (Context, DC) VarTemplatePartialSpecializationDecl(
-          Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
-          S, Args, ASTArgInfos);
+    TemplateArgumentListInfo const &ArgInfos) {
+  ASTTemplateArgumentListInfo const *ASTArgInfos =
+      ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
+
+  auto *Result = new (Context, DC) VarTemplatePartialSpecializationDecl(
+      Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo, S,
+      Args, ASTArgInfos);
   Result->setSpecializationKind(TSK_ExplicitSpecialization);
   return Result;
 }
@@ -1363,7 +1328,7 @@
 }
 
 static TemplateParameterList *
-createMakeIntegerSeqParameterList(const ASTContext &C, DeclContext *DC) {
+createMakeIntegerSeqParameterList(ASTContext const &C, DeclContext *DC) {
   // typename T
   auto *T = TemplateTypeParmDecl::Create(
       C, DC, SourceLocation(), SourceLocation(), /*Depth=*/1, /*Position=*/0,
@@ -1412,7 +1377,7 @@
 }
 
 static TemplateParameterList *
-createTypePackElementParameterList(const ASTContext &C, DeclContext *DC) {
+createTypePackElementParameterList(ASTContext const &C, DeclContext *DC) {
   // std::size_t Index
   TypeSourceInfo *TInfo = C.getTrivialTypeSourceInfo(C.getSizeType());
   auto *Index = NonTypeTemplateParmDecl::Create(
@@ -1433,8 +1398,9 @@
                                        SourceLocation(), nullptr);
 }
 
-static TemplateParameterList *createBuiltinTemplateParameterList(
-    const ASTContext &C, DeclContext *DC, BuiltinTemplateKind BTK) {
+static TemplateParameterList *
+createBuiltinTemplateParameterList(ASTContext const &C, DeclContext *DC,
+                                   BuiltinTemplateKind BTK) {
   switch (BTK) {
   case BTK__make_integer_seq:
     return createMakeIntegerSeqParameterList(C, DC);
@@ -1447,7 +1413,7 @@
 
 void BuiltinTemplateDecl::anchor() {}
 
-BuiltinTemplateDecl::BuiltinTemplateDecl(const ASTContext &C, DeclContext *DC,
+BuiltinTemplateDecl::BuiltinTemplateDecl(ASTContext const &C, DeclContext *DC,
                                          DeclarationName Name,
                                          BuiltinTemplateKind BTK)
     : TemplateDecl(BuiltinTemplate, DC, SourceLocation(), Name,
@@ -1467,9 +1433,9 @@
   }
 }
 
-TemplateParamObjectDecl *TemplateParamObjectDecl::Create(const ASTContext &C,
+TemplateParamObjectDecl *TemplateParamObjectDecl::Create(ASTContext const &C,
                                                          QualType T,
-                                                         const APValue &V) {
+                                                         APValue const &V) {
   DeclContext *DC = C.getTranslationUnitDecl();
   auto *TPOD = new (C, DC) TemplateParamObjectDecl(DC, T, V);
   C.addDestruction(&TPOD->Value);
@@ -1478,7 +1444,8 @@
 
 TemplateParamObjectDecl *
 TemplateParamObjectDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  auto *TPOD = new (C, ID) TemplateParamObjectDecl(nullptr, QualType(), APValue());
+  auto *TPOD =
+      new (C, ID) TemplateParamObjectDecl(nullptr, QualType(), APValue());
   C.addDestruction(&TPOD->Value);
   return TPOD;
 }
@@ -1490,12 +1457,12 @@
 }
 
 void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS) const {
-  const ASTContext &Ctx = getASTContext();
+  ASTContext const &Ctx = getASTContext();
   getType().getUnqualifiedType().print(OS, Ctx.getPrintingPolicy());
   printAsInit(OS);
 }
 
 void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS) const {
-  const ASTContext &Ctx = getASTContext();
+  ASTContext const &Ctx = getASTContext();
   getValue().printPretty(OS, Ctx, getType());
 }
Index: clang/lib/AST/DeclarationName.cpp
===================================================================
--- clang/lib/AST/DeclarationName.cpp
+++ clang/lib/AST/DeclarationName.cpp
@@ -122,7 +122,7 @@
   // We know we're printing C++ here. Ensure we print types properly.
   Policy.adjustForCPlusPlus();
 
-  if (const RecordType *ClassRec = ClassType->getAs<RecordType>()) {
+  if (RecordType const *ClassRec = ClassType->getAs<RecordType>()) {
     OS << *ClassRec->getDecl();
     return;
   }
@@ -136,10 +136,10 @@
 }
 
 void DeclarationName::print(raw_ostream &OS,
-                            const PrintingPolicy &Policy) const {
+                            PrintingPolicy const &Policy) const {
   switch (getNameKind()) {
   case DeclarationName::Identifier:
-    if (const IdentifierInfo *II = getAsIdentifierInfo()) {
+    if (IdentifierInfo const *II = getAsIdentifierInfo()) {
       StringRef Name = II->getName();
       // If this is a mangled OpenMP variant name we strip off the mangling for
       // printing. It should not be visible to the user at all.
@@ -174,7 +174,7 @@
     return;
 
   case DeclarationName::CXXOperatorName: {
-    const char *OpName = getOperatorSpelling(getCXXOverloadedOperator());
+    char const *OpName = getOperatorSpelling(getCXXOverloadedOperator());
     assert(OpName && "not an overloaded operator");
 
     OS << "operator";
@@ -191,7 +191,7 @@
   case DeclarationName::CXXConversionFunctionName: {
     OS << "operator ";
     QualType Type = getCXXNameType();
-    if (const RecordType *Rec = Type->getAs<RecordType>()) {
+    if (RecordType const *Rec = Type->getAs<RecordType>()) {
       OS << *Rec->getDecl();
       return;
     }
@@ -285,7 +285,7 @@
   llvm::errs() << *this << '\n';
 }
 
-DeclarationNameTable::DeclarationNameTable(const ASTContext &C) : Ctx(C) {
+DeclarationNameTable::DeclarationNameTable(ASTContext const &C) : Ctx(C) {
   // Initialize the overloaded operator names.
   for (unsigned Op = 0; Op < NUM_OVERLOADED_OPERATORS; ++Op)
     CXXOperatorNames[Op].Kind = static_cast<OverloadedOperatorKind>(Op);
@@ -469,7 +469,8 @@
   return OS;
 }
 
-void DeclarationNameInfo::printName(raw_ostream &OS, PrintingPolicy Policy) const {
+void DeclarationNameInfo::printName(raw_ostream &OS,
+                                    PrintingPolicy Policy) const {
   switch (Name.getNameKind()) {
   case DeclarationName::Identifier:
   case DeclarationName::ObjCZeroArgSelector:
Index: clang/lib/AST/Expr.cpp
===================================================================
--- clang/lib/AST/Expr.cpp
+++ clang/lib/AST/Expr.cpp
@@ -38,8 +38,8 @@
 #include <cstring>
 using namespace clang;
 
-const Expr *Expr::getBestDynamicClassTypeExpr() const {
-  const Expr *E = this;
+Expr const *Expr::getBestDynamicClassTypeExpr() const {
+  Expr const *E = this;
   while (true) {
     E = E->IgnoreParenBaseCasts();
 
@@ -63,28 +63,28 @@
   return E;
 }
 
-const CXXRecordDecl *Expr::getBestDynamicClassType() const {
-  const Expr *E = getBestDynamicClassTypeExpr();
+CXXRecordDecl const *Expr::getBestDynamicClassType() const {
+  Expr const *E = getBestDynamicClassTypeExpr();
   QualType DerivedType = E->getType();
-  if (const PointerType *PTy = DerivedType->getAs<PointerType>())
+  if (PointerType const *PTy = DerivedType->getAs<PointerType>())
     DerivedType = PTy->getPointeeType();
 
   if (DerivedType->isDependentType())
     return nullptr;
 
-  const RecordType *Ty = DerivedType->castAs<RecordType>();
+  RecordType const *Ty = DerivedType->castAs<RecordType>();
   Decl *D = Ty->getDecl();
   return cast<CXXRecordDecl>(D);
 }
 
-const Expr *Expr::skipRValueSubobjectAdjustments(
-    SmallVectorImpl<const Expr *> &CommaLHSs,
+Expr const *Expr::skipRValueSubobjectAdjustments(
+    SmallVectorImpl<Expr const *> &CommaLHSs,
     SmallVectorImpl<SubobjectAdjustment> &Adjustments) const {
-  const Expr *E = this;
+  Expr const *E = this;
   while (true) {
     E = E->IgnoreParens();
 
-    if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
+    if (CastExpr const *CE = dyn_cast<CastExpr>(E)) {
       if ((CE->getCastKind() == CK_DerivedToBase ||
            CE->getCastKind() == CK_UncheckedDerivedToBase) &&
           E->getType()->isRecordType()) {
@@ -99,7 +99,7 @@
         E = CE->getSubExpr();
         continue;
       }
-    } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
+    } else if (MemberExpr const *ME = dyn_cast<MemberExpr>(E)) {
       if (!ME->isArrow()) {
         assert(ME->getBase()->getType()->isRecordType());
         if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
@@ -110,12 +110,12 @@
           }
         }
       }
-    } else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
+    } else if (BinaryOperator const *BO = dyn_cast<BinaryOperator>(E)) {
       if (BO->getOpcode() == BO_PtrMemD) {
         assert(BO->getRHS()->isPRValue());
         E = BO->getLHS();
-        const MemberPointerType *MPT =
-          BO->getRHS()->getType()->getAs<MemberPointerType>();
+        MemberPointerType const *MPT =
+            BO->getRHS()->getType()->getAs<MemberPointerType>();
         Adjustments.push_back(SubobjectAdjustment(MPT, BO->getRHS()));
         continue;
       }
@@ -133,14 +133,16 @@
 }
 
 bool Expr::isKnownToHaveBooleanValue(bool Semantic) const {
-  const Expr *E = IgnoreParens();
+  Expr const *E = IgnoreParens();
 
   // If this value has _Bool type, it is obvious 0/1.
-  if (E->getType()->isBooleanType()) return true;
+  if (E->getType()->isBooleanType())
+    return true;
   // If this is a non-scalar-integer type, we don't care enough to try.
-  if (!E->getType()->isIntegralOrEnumerationType()) return false;
+  if (!E->getType()->isIntegralOrEnumerationType())
+    return false;
 
-  if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
+  if (UnaryOperator const *UO = dyn_cast<UnaryOperator>(E)) {
     switch (UO->getOpcode()) {
     case UO_Plus:
       return UO->getSubExpr()->isKnownToHaveBooleanValue(Semantic);
@@ -154,25 +156,26 @@
   // Only look through implicit casts.  If the user writes
   // '(int) (a && b)' treat it as an arbitrary int.
   // FIXME: Should we look through any cast expression in !Semantic mode?
-  if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
+  if (ImplicitCastExpr const *CE = dyn_cast<ImplicitCastExpr>(E))
     return CE->getSubExpr()->isKnownToHaveBooleanValue(Semantic);
 
-  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
+  if (BinaryOperator const *BO = dyn_cast<BinaryOperator>(E)) {
     switch (BO->getOpcode()) {
-    default: return false;
-    case BO_LT:   // Relational operators.
+    default:
+      return false;
+    case BO_LT: // Relational operators.
     case BO_GT:
     case BO_LE:
     case BO_GE:
-    case BO_EQ:   // Equality operators.
+    case BO_EQ: // Equality operators.
     case BO_NE:
     case BO_LAnd: // AND operator.
     case BO_LOr:  // Logical OR operator.
       return true;
 
-    case BO_And:  // Bitwise AND operator.
-    case BO_Xor:  // Bitwise XOR operator.
-    case BO_Or:   // Bitwise OR operator.
+    case BO_And: // Bitwise AND operator.
+    case BO_Xor: // Bitwise XOR operator.
+    case BO_Or:  // Bitwise OR operator.
       // Handle things like (x==2)|(y==12).
       return BO->getLHS()->isKnownToHaveBooleanValue(Semantic) &&
              BO->getRHS()->isKnownToHaveBooleanValue(Semantic);
@@ -183,17 +186,17 @@
     }
   }
 
-  if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
+  if (ConditionalOperator const *CO = dyn_cast<ConditionalOperator>(E))
     return CO->getTrueExpr()->isKnownToHaveBooleanValue(Semantic) &&
            CO->getFalseExpr()->isKnownToHaveBooleanValue(Semantic);
 
   if (isa<ObjCBoolLiteralExpr>(E))
     return true;
 
-  if (const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
+  if (auto const *OVE = dyn_cast<OpaqueValueExpr>(E))
     return OVE->getSourceExpr()->isKnownToHaveBooleanValue(Semantic);
 
-  if (const FieldDecl *FD = E->getSourceBitField())
+  if (FieldDecl const *FD = E->getSourceBitField())
     if (!Semantic && FD->getType()->isUnsignedIntegerType() &&
         !FD->getBitWidth()->isValueDependent() &&
         FD->getBitWidthValue(FD->getASTContext()) == 1)
@@ -207,33 +210,36 @@
 //
 // See also Stmt.cpp:{getBeginLoc(),getEndLoc()}.
 namespace {
-  /// This implementation is used when a class provides a custom
-  /// implementation of getExprLoc.
-  template <class E, class T>
-  SourceLocation getExprLocImpl(const Expr *expr,
-                                SourceLocation (T::*v)() const) {
-    return static_cast<const E*>(expr)->getExprLoc();
-  }
+/// This implementation is used when a class provides a custom
+/// implementation of getExprLoc.
+template <class E, class T>
+SourceLocation getExprLocImpl(Expr const *expr,
+                              SourceLocation (T::*v)() const) {
+  return static_cast<const E *>(expr)->getExprLoc();
+}
 
-  /// This implementation is used when a class doesn't provide
-  /// a custom implementation of getExprLoc.  Overload resolution
-  /// should pick it over the implementation above because it's
-  /// more specialized according to function template partial ordering.
-  template <class E>
-  SourceLocation getExprLocImpl(const Expr *expr,
-                                SourceLocation (Expr::*v)() const) {
-    return static_cast<const E *>(expr)->getBeginLoc();
-  }
+/// This implementation is used when a class doesn't provide
+/// a custom implementation of getExprLoc.  Overload resolution
+/// should pick it over the implementation above because it's
+/// more specialized according to function template partial ordering.
+template <class E>
+SourceLocation getExprLocImpl(Expr const *expr,
+                              SourceLocation (Expr::*v)() const) {
+  return static_cast<const E *>(expr)->getBeginLoc();
 }
+} // namespace
 
 SourceLocation Expr::getExprLoc() const {
   switch (getStmtClass()) {
-  case Stmt::NoStmtClass: llvm_unreachable("statement without class");
+  case Stmt::NoStmtClass:
+    llvm_unreachable("statement without class");
 #define ABSTRACT_STMT(type)
-#define STMT(type, base) \
-  case Stmt::type##Class: break;
-#define EXPR(type, base) \
-  case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc);
+#define STMT(type, base)                                                       \
+  case Stmt::type##Class:                                                      \
+    break;
+#define EXPR(type, base)                                                       \
+  case Stmt::type##Class:                                                      \
+    return getExprLocImpl<type>(this, &type::getExprLoc);
 #include "clang/AST/StmtNodes.inc"
   }
   llvm_unreachable("unknown expression kind");
@@ -251,7 +257,7 @@
 }
 
 ConstantExpr::ResultStorageKind
-ConstantExpr::getStorageKind(const APValue &Value) {
+ConstantExpr::getStorageKind(APValue const &Value) {
   switch (Value.getKind()) {
   case APValue::None:
   case APValue::Indeterminate:
@@ -266,7 +272,7 @@
 }
 
 ConstantExpr::ResultStorageKind
-ConstantExpr::getStorageKind(const Type *T, const ASTContext &Context) {
+ConstantExpr::getStorageKind(Type const *T, ASTContext const &Context) {
   if (T->isIntegralOrEnumerationType() && Context.getTypeInfo(T).Width <= 64)
     return ConstantExpr::RSK_Int64;
   return ConstantExpr::RSK_APValue;
@@ -286,7 +292,7 @@
     ::new (getTrailingObjects<APValue>()) APValue();
 }
 
-ConstantExpr *ConstantExpr::Create(const ASTContext &Context, Expr *E,
+ConstantExpr *ConstantExpr::Create(ASTContext const &Context, Expr *E,
                                    ResultStorageKind StorageKind,
                                    bool IsImmediateInvocation) {
   assert(!isa<ConstantExpr>(E));
@@ -299,8 +305,8 @@
   return new (Mem) ConstantExpr(E, StorageKind, IsImmediateInvocation);
 }
 
-ConstantExpr *ConstantExpr::Create(const ASTContext &Context, Expr *E,
-                                   const APValue &Result) {
+ConstantExpr *ConstantExpr::Create(ASTContext const &Context, Expr *E,
+                                   APValue const &Result) {
   ResultStorageKind StorageKind = getStorageKind(Result);
   ConstantExpr *Self = Create(Context, E, StorageKind);
   Self->SetResult(Result, Context);
@@ -315,7 +321,7 @@
     ::new (getTrailingObjects<APValue>()) APValue();
 }
 
-ConstantExpr *ConstantExpr::CreateEmpty(const ASTContext &Context,
+ConstantExpr *ConstantExpr::CreateEmpty(ASTContext const &Context,
                                         ResultStorageKind StorageKind) {
   AssertResultStorageKind(StorageKind);
 
@@ -326,7 +332,7 @@
   return new (Mem) ConstantExpr(EmptyShell(), StorageKind);
 }
 
-void ConstantExpr::MoveIntoResult(APValue &Value, const ASTContext &Context) {
+void ConstantExpr::MoveIntoResult(APValue &Value, ASTContext const &Context) {
   assert((unsigned)getStorageKind(Value) <= ConstantExprBits.ResultKind &&
          "Invalid storage for this value kind");
   ConstantExprBits.APValueKind = Value.getKind();
@@ -378,10 +384,10 @@
   llvm_unreachable("invalid ResultKind");
 }
 
-DeclRefExpr::DeclRefExpr(const ASTContext &Ctx, ValueDecl *D,
+DeclRefExpr::DeclRefExpr(ASTContext const &Ctx, ValueDecl *D,
                          bool RefersToEnclosingVariableOrCapture, QualType T,
                          ExprValueKind VK, SourceLocation L,
-                         const DeclarationNameLoc &LocInfo,
+                         DeclarationNameLoc const &LocInfo,
                          NonOdrUseReason NOUR)
     : Expr(DeclRefExprClass, T, VK, OK_Ordinary), D(D), DNLoc(LocInfo) {
   DeclRefExprBits.HasQualifier = false;
@@ -395,12 +401,12 @@
   setDependence(computeDependence(this, Ctx));
 }
 
-DeclRefExpr::DeclRefExpr(const ASTContext &Ctx,
+DeclRefExpr::DeclRefExpr(ASTContext const &Ctx,
                          NestedNameSpecifierLoc QualifierLoc,
                          SourceLocation TemplateKWLoc, ValueDecl *D,
                          bool RefersToEnclosingVariableOrCapture,
-                         const DeclarationNameInfo &NameInfo, NamedDecl *FoundD,
-                         const TemplateArgumentListInfo *TemplateArgs,
+                         DeclarationNameInfo const &NameInfo, NamedDecl *FoundD,
+                         TemplateArgumentListInfo const *TemplateArgs,
                          QualType T, ExprValueKind VK, NonOdrUseReason NOUR)
     : Expr(DeclRefExprClass, T, VK, OK_Ordinary), D(D),
       DNLoc(NameInfo.getInfo()) {
@@ -412,8 +418,8 @@
   DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0;
   if (FoundD)
     *getTrailingObjects<NamedDecl *>() = FoundD;
-  DeclRefExprBits.HasTemplateKWAndArgsInfo
-    = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0;
+  DeclRefExprBits.HasTemplateKWAndArgsInfo =
+      (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0;
   DeclRefExprBits.RefersToEnclosingVariableOrCapture =
       RefersToEnclosingVariableOrCapture;
   DeclRefExprBits.NonOdrUseReason = NOUR;
@@ -432,28 +438,28 @@
   setDependence(computeDependence(this, Ctx));
 }
 
-DeclRefExpr *DeclRefExpr::Create(const ASTContext &Context,
+DeclRefExpr *DeclRefExpr::Create(ASTContext const &Context,
                                  NestedNameSpecifierLoc QualifierLoc,
                                  SourceLocation TemplateKWLoc, ValueDecl *D,
                                  bool RefersToEnclosingVariableOrCapture,
                                  SourceLocation NameLoc, QualType T,
                                  ExprValueKind VK, NamedDecl *FoundD,
-                                 const TemplateArgumentListInfo *TemplateArgs,
+                                 TemplateArgumentListInfo const *TemplateArgs,
                                  NonOdrUseReason NOUR) {
   return Create(Context, QualifierLoc, TemplateKWLoc, D,
                 RefersToEnclosingVariableOrCapture,
-                DeclarationNameInfo(D->getDeclName(), NameLoc),
-                T, VK, FoundD, TemplateArgs, NOUR);
+                DeclarationNameInfo(D->getDeclName(), NameLoc), T, VK, FoundD,
+                TemplateArgs, NOUR);
 }
 
-DeclRefExpr *DeclRefExpr::Create(const ASTContext &Context,
+DeclRefExpr *DeclRefExpr::Create(ASTContext const &Context,
                                  NestedNameSpecifierLoc QualifierLoc,
                                  SourceLocation TemplateKWLoc, ValueDecl *D,
                                  bool RefersToEnclosingVariableOrCapture,
-                                 const DeclarationNameInfo &NameInfo,
+                                 DeclarationNameInfo const &NameInfo,
                                  QualType T, ExprValueKind VK,
                                  NamedDecl *FoundD,
-                                 const TemplateArgumentListInfo *TemplateArgs,
+                                 TemplateArgumentListInfo const *TemplateArgs,
                                  NonOdrUseReason NOUR) {
   // Filter out cases where the found Decl is the same as the value refenenced.
   if (D == FoundD)
@@ -473,9 +479,8 @@
                                FoundD, TemplateArgs, T, VK, NOUR);
 }
 
-DeclRefExpr *DeclRefExpr::CreateEmpty(const ASTContext &Context,
-                                      bool HasQualifier,
-                                      bool HasFoundDecl,
+DeclRefExpr *DeclRefExpr::CreateEmpty(ASTContext const &Context,
+                                      bool HasQualifier, bool HasFoundDecl,
                                       bool HasTemplateKWAndArgsInfo,
                                       unsigned NumTemplateArgs) {
   assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
@@ -522,7 +527,7 @@
     : Expr(SYCLUniqueStableNameExprClass, ResultTy, VK_PRValue, OK_Ordinary) {}
 
 SYCLUniqueStableNameExpr *
-SYCLUniqueStableNameExpr::Create(const ASTContext &Ctx, SourceLocation OpLoc,
+SYCLUniqueStableNameExpr::Create(ASTContext const &Ctx, SourceLocation OpLoc,
                                  SourceLocation LParen, SourceLocation RParen,
                                  TypeSourceInfo *TSI) {
   QualType ResultTy = Ctx.getPointerType(Ctx.CharTy.withConst());
@@ -531,7 +536,7 @@
 }
 
 SYCLUniqueStableNameExpr *
-SYCLUniqueStableNameExpr::CreateEmpty(const ASTContext &Ctx) {
+SYCLUniqueStableNameExpr::CreateEmpty(ASTContext const &Ctx) {
   QualType ResultTy = Ctx.getPointerType(Ctx.CharTy.withConst());
   return new (Ctx) SYCLUniqueStableNameExpr(EmptyShell(), ResultTy);
 }
@@ -544,7 +549,7 @@
 std::string SYCLUniqueStableNameExpr::ComputeName(ASTContext &Context,
                                                   QualType Ty) {
   auto MangleCallback = [](ASTContext &Ctx,
-                           const NamedDecl *ND) -> llvm::Optional<unsigned> {
+                           NamedDecl const *ND) -> llvm::Optional<unsigned> {
     // This replaces the 'lambda number' in the mangling with a unique number
     // based on its order in the declaration.  To provide some level of visual
     // notability (actual uniqueness from normal lambdas isn't necessary, as
@@ -589,7 +594,7 @@
   PredefinedExprBits.HasFunctionName = HasFunctionName;
 }
 
-PredefinedExpr *PredefinedExpr::Create(const ASTContext &Ctx, SourceLocation L,
+PredefinedExpr *PredefinedExpr::Create(ASTContext const &Ctx, SourceLocation L,
                                        QualType FNTy, IdentKind IK,
                                        StringLiteral *SL) {
   bool HasFunctionName = SL != nullptr;
@@ -598,7 +603,7 @@
   return new (Mem) PredefinedExpr(L, FNTy, IK, SL);
 }
 
-PredefinedExpr *PredefinedExpr::CreateEmpty(const ASTContext &Ctx,
+PredefinedExpr *PredefinedExpr::CreateEmpty(ASTContext const &Ctx,
                                             bool HasFunctionName) {
   void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
                            alignof(PredefinedExpr));
@@ -629,11 +634,11 @@
 
 // FIXME: Maybe this should use DeclPrinter with a special "print predefined
 // expr" policy instead.
-std::string PredefinedExpr::ComputeName(IdentKind IK, const Decl *CurrentDecl) {
+std::string PredefinedExpr::ComputeName(IdentKind IK, Decl const *CurrentDecl) {
   ASTContext &Context = CurrentDecl->getASTContext();
 
   if (IK == PredefinedExpr::FuncDName) {
-    if (const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
+    if (NamedDecl const *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
       std::unique_ptr<MangleContext> MC;
       MC.reset(Context.createMangleContext());
 
@@ -641,9 +646,9 @@
         SmallString<256> Buffer;
         llvm::raw_svector_ostream Out(Buffer);
         GlobalDecl GD;
-        if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(ND))
+        if (CXXConstructorDecl const *CD = dyn_cast<CXXConstructorDecl>(ND))
           GD = GlobalDecl(CD, Ctor_Base);
-        else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(ND))
+        else if (CXXDestructorDecl const *DD = dyn_cast<CXXDestructorDecl>(ND))
           GD = GlobalDecl(DD, Dtor_Base);
         else if (ND->hasAttr<CUDAGlobalAttr>())
           GD = GlobalDecl(cast<FunctionDecl>(ND));
@@ -676,7 +681,7 @@
       Out << ComputeName(IK, DCDecl) << "_block_invoke";
     return std::string(Out.str());
   }
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
+  if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
     if (IK != PrettyFunction && IK != PrettyFunctionNoVirtual &&
         IK != FuncSig && IK != LFuncSig)
       return FD->getNameAsString();
@@ -684,7 +689,7 @@
     SmallString<256> Name;
     llvm::raw_svector_ostream Out(Name);
 
-    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
+    if (CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(FD)) {
       if (MD->isVirtual() && IK != PrettyFunctionNoVirtual)
         Out << "virtual ";
       if (MD->isStatic())
@@ -695,24 +700,37 @@
     std::string Proto;
     llvm::raw_string_ostream POut(Proto);
 
-    const FunctionDecl *Decl = FD;
-    if (const FunctionDecl* Pattern = FD->getTemplateInstantiationPattern())
+    FunctionDecl const *Decl = FD;
+    if (FunctionDecl const *Pattern = FD->getTemplateInstantiationPattern())
       Decl = Pattern;
-    const FunctionType *AFT = Decl->getType()->getAs<FunctionType>();
-    const FunctionProtoType *FT = nullptr;
+    FunctionType const *AFT = Decl->getType()->getAs<FunctionType>();
+    FunctionProtoType const *FT = nullptr;
     if (FD->hasWrittenPrototype())
       FT = dyn_cast<FunctionProtoType>(AFT);
 
     if (IK == FuncSig || IK == LFuncSig) {
       switch (AFT->getCallConv()) {
-      case CC_C: POut << "__cdecl "; break;
-      case CC_X86StdCall: POut << "__stdcall "; break;
-      case CC_X86FastCall: POut << "__fastcall "; break;
-      case CC_X86ThisCall: POut << "__thiscall "; break;
-      case CC_X86VectorCall: POut << "__vectorcall "; break;
-      case CC_X86RegCall: POut << "__regcall "; break;
+      case CC_C:
+        POut << "__cdecl ";
+        break;
+      case CC_X86StdCall:
+        POut << "__stdcall ";
+        break;
+      case CC_X86FastCall:
+        POut << "__fastcall ";
+        break;
+      case CC_X86ThisCall:
+        POut << "__thiscall ";
+        break;
+      case CC_X86VectorCall:
+        POut << "__vectorcall ";
+        break;
+      case CC_X86RegCall:
+        POut << "__regcall ";
+        break;
       // Only bother printing the conventions that MSVC knows about.
-      default: break;
+      default:
+        break;
       }
     }
 
@@ -721,12 +739,14 @@
     POut << "(";
     if (FT) {
       for (unsigned i = 0, e = Decl->getNumParams(); i != e; ++i) {
-        if (i) POut << ", ";
+        if (i)
+          POut << ", ";
         POut << Decl->getParamDecl(i)->getType().stream(Policy);
       }
 
       if (FT->isVariadic()) {
-        if (FD->getNumParams()) POut << ", ";
+        if (FD->getNumParams())
+          POut << ", ";
         POut << "...";
       } else if ((IK == FuncSig || IK == LFuncSig ||
                   !Context.getLangOpts().CPlusPlus) &&
@@ -736,7 +756,7 @@
     }
     POut << ")";
 
-    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
+    if (CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(FD)) {
       assert(FT && "We must have a written prototype in this case.");
       if (FT->isConst())
         POut << " const";
@@ -749,12 +769,12 @@
         POut << " &&";
     }
 
-    typedef SmallVector<const ClassTemplateSpecializationDecl *, 8> SpecsTy;
+    typedef SmallVector<ClassTemplateSpecializationDecl const *, 8> SpecsTy;
     SpecsTy Specs;
-    const DeclContext *Ctx = FD->getDeclContext();
+    DeclContext const *Ctx = FD->getDeclContext();
     while (Ctx && isa<NamedDecl>(Ctx)) {
-      const ClassTemplateSpecializationDecl *Spec
-                               = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
+      ClassTemplateSpecializationDecl const *Spec =
+          dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
       if (Spec && !Spec->isExplicitSpecialization())
         Specs.push_back(Spec);
       Ctx = Ctx->getParent();
@@ -762,15 +782,16 @@
 
     std::string TemplateParams;
     llvm::raw_string_ostream TOut(TemplateParams);
-    for (SpecsTy::reverse_iterator I = Specs.rbegin(), E = Specs.rend();
-         I != E; ++I) {
-      const TemplateParameterList *Params
-                  = (*I)->getSpecializedTemplate()->getTemplateParameters();
-      const TemplateArgumentList &Args = (*I)->getTemplateArgs();
+    for (SpecsTy::reverse_iterator I = Specs.rbegin(), E = Specs.rend(); I != E;
+         ++I) {
+      TemplateParameterList const *Params =
+          (*I)->getSpecializedTemplate()->getTemplateParameters();
+      TemplateArgumentList const &Args = (*I)->getTemplateArgs();
       assert(Params->size() == Args.size());
       for (unsigned i = 0, numParams = Params->size(); i != numParams; ++i) {
         StringRef Param = Params->getParam(i)->getName();
-        if (Param.empty()) continue;
+        if (Param.empty())
+          continue;
         TOut << Param << " = ";
         Args.get(i).print(
             Policy, TOut,
@@ -779,16 +800,17 @@
       }
     }
 
-    FunctionTemplateSpecializationInfo *FSI
-                                          = FD->getTemplateSpecializationInfo();
+    FunctionTemplateSpecializationInfo *FSI =
+        FD->getTemplateSpecializationInfo();
     if (FSI && !FSI->isExplicitSpecialization()) {
-      const TemplateParameterList* Params
-                                  = FSI->getTemplate()->getTemplateParameters();
-      const TemplateArgumentList* Args = FSI->TemplateArguments;
+      TemplateParameterList const *Params =
+          FSI->getTemplate()->getTemplateParameters();
+      TemplateArgumentList const *Args = FSI->TemplateArguments;
       assert(Params->size() == Args->size());
       for (unsigned i = 0, e = Params->size(); i != e; ++i) {
         StringRef Param = Params->getParam(i)->getName();
-        if (Param.empty()) continue;
+        if (Param.empty())
+          continue;
         TOut << Param << " = ";
         Args->get(i).print(Policy, TOut, /*IncludeType*/ true);
         TOut << ", ";
@@ -809,7 +831,7 @@
     // decltype expression. Otherwise print the real type when this is
     // not a constructor or destructor.
     if (isa<CXXMethodDecl>(FD) &&
-         cast<CXXMethodDecl>(FD)->getParent()->isLambda())
+        cast<CXXMethodDecl>(FD)->getParent()->isLambda())
       Proto = "auto " + Proto;
     else if (FT && FT->getReturnType()->getAs<DecltypeType>())
       FT->getReturnType()
@@ -823,17 +845,17 @@
 
     return std::string(Name);
   }
-  if (const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
-    for (const DeclContext *DC = CD->getParent(); DC; DC = DC->getParent())
+  if (CapturedDecl const *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
+    for (DeclContext const *DC = CD->getParent(); DC; DC = DC->getParent())
       // Skip to its enclosing function or method, but not its enclosing
       // CapturedDecl.
       if (DC->isFunctionOrMethod() && (DC->getDeclKind() != Decl::Captured)) {
-        const Decl *D = Decl::castFromDeclContext(DC);
+        Decl const *D = Decl::castFromDeclContext(DC);
         return ComputeName(IK, D);
       }
     llvm_unreachable("CapturedDecl not inside a function or method");
   }
-  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
+  if (ObjCMethodDecl const *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
     SmallString<256> Name;
     llvm::raw_svector_ostream Out(Name);
     Out << (MD->isInstanceMethod() ? '-' : '+');
@@ -841,16 +863,16 @@
 
     // For incorrect code, there might not be an ObjCInterfaceDecl.  Do
     // a null check to avoid a crash.
-    if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
+    if (ObjCInterfaceDecl const *ID = MD->getClassInterface())
       Out << *ID;
 
-    if (const ObjCCategoryImplDecl *CID =
-        dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
+    if (ObjCCategoryImplDecl const *CID =
+            dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
       Out << '(' << *CID << ')';
 
-    Out <<  ' ';
+    Out << ' ';
     MD->getSelector().print(Out);
-    Out <<  ']';
+    Out << ']';
 
     return std::string(Name);
   }
@@ -861,14 +883,14 @@
   return "";
 }
 
-void APNumericStorage::setIntValue(const ASTContext &C,
-                                   const llvm::APInt &Val) {
+void APNumericStorage::setIntValue(ASTContext const &C,
+                                   llvm::APInt const &Val) {
   if (hasAllocation())
     C.Deallocate(pVal);
 
   BitWidth = Val.getBitWidth();
   unsigned NumWords = Val.getNumWords();
-  const uint64_t* Words = Val.getRawData();
+  uint64_t const *Words = Val.getRawData();
   if (NumWords > 1) {
     pVal = new (C) uint64_t[NumWords];
     std::copy(Words, Words + NumWords, pVal);
@@ -878,7 +900,7 @@
     VAL = 0;
 }
 
-IntegerLiteral::IntegerLiteral(const ASTContext &C, const llvm::APInt &V,
+IntegerLiteral::IntegerLiteral(ASTContext const &C, llvm::APInt const &V,
                                QualType type, SourceLocation l)
     : Expr(IntegerLiteralClass, type, VK_PRValue, OK_Ordinary), Loc(l) {
   assert(type->isIntegerType() && "Illegal type in IntegerLiteral");
@@ -888,18 +910,17 @@
   setDependence(ExprDependence::None);
 }
 
-IntegerLiteral *
-IntegerLiteral::Create(const ASTContext &C, const llvm::APInt &V,
-                       QualType type, SourceLocation l) {
+IntegerLiteral *IntegerLiteral::Create(ASTContext const &C,
+                                       llvm::APInt const &V, QualType type,
+                                       SourceLocation l) {
   return new (C) IntegerLiteral(C, V, type, l);
 }
 
-IntegerLiteral *
-IntegerLiteral::Create(const ASTContext &C, EmptyShell Empty) {
+IntegerLiteral *IntegerLiteral::Create(ASTContext const &C, EmptyShell Empty) {
   return new (C) IntegerLiteral(Empty);
 }
 
-FixedPointLiteral::FixedPointLiteral(const ASTContext &C, const llvm::APInt &V,
+FixedPointLiteral::FixedPointLiteral(ASTContext const &C, llvm::APInt const &V,
                                      QualType type, SourceLocation l,
                                      unsigned Scale)
     : Expr(FixedPointLiteralClass, type, VK_PRValue, OK_Ordinary), Loc(l),
@@ -911,15 +932,15 @@
   setDependence(ExprDependence::None);
 }
 
-FixedPointLiteral *FixedPointLiteral::CreateFromRawInt(const ASTContext &C,
-                                                       const llvm::APInt &V,
+FixedPointLiteral *FixedPointLiteral::CreateFromRawInt(ASTContext const &C,
+                                                       llvm::APInt const &V,
                                                        QualType type,
                                                        SourceLocation l,
                                                        unsigned Scale) {
   return new (C) FixedPointLiteral(C, V, type, l, Scale);
 }
 
-FixedPointLiteral *FixedPointLiteral::Create(const ASTContext &C,
+FixedPointLiteral *FixedPointLiteral::Create(ASTContext const &C,
                                              EmptyShell Empty) {
   return new (C) FixedPointLiteral(Empty);
 }
@@ -1004,7 +1025,7 @@
   }
 }
 
-FloatingLiteral::FloatingLiteral(const ASTContext &C, const llvm::APFloat &V,
+FloatingLiteral::FloatingLiteral(ASTContext const &C, llvm::APFloat const &V,
                                  bool isexact, QualType Type, SourceLocation L)
     : Expr(FloatingLiteralClass, Type, VK_PRValue, OK_Ordinary), Loc(L) {
   setSemantics(V.getSemantics());
@@ -1013,20 +1034,20 @@
   setDependence(ExprDependence::None);
 }
 
-FloatingLiteral::FloatingLiteral(const ASTContext &C, EmptyShell Empty)
-  : Expr(FloatingLiteralClass, Empty) {
+FloatingLiteral::FloatingLiteral(ASTContext const &C, EmptyShell Empty)
+    : Expr(FloatingLiteralClass, Empty) {
   setRawSemantics(llvm::APFloatBase::S_IEEEhalf);
   FloatingLiteralBits.IsExact = false;
 }
 
-FloatingLiteral *
-FloatingLiteral::Create(const ASTContext &C, const llvm::APFloat &V,
-                        bool isexact, QualType Type, SourceLocation L) {
+FloatingLiteral *FloatingLiteral::Create(ASTContext const &C,
+                                         llvm::APFloat const &V, bool isexact,
+                                         QualType Type, SourceLocation L) {
   return new (C) FloatingLiteral(C, V, isexact, Type, L);
 }
 
-FloatingLiteral *
-FloatingLiteral::Create(const ASTContext &C, EmptyShell Empty) {
+FloatingLiteral *FloatingLiteral::Create(ASTContext const &C,
+                                         EmptyShell Empty) {
   return new (C) FloatingLiteral(C, Empty);
 }
 
@@ -1066,9 +1087,9 @@
   return CharByteWidth;
 }
 
-StringLiteral::StringLiteral(const ASTContext &Ctx, StringRef Str,
+StringLiteral::StringLiteral(ASTContext const &Ctx, StringRef Str,
                              StringKind Kind, bool Pascal, QualType Ty,
-                             const SourceLocation *Loc,
+                             SourceLocation const *Loc,
                              unsigned NumConcatenated)
     : Expr(StringLiteralClass, Ty, VK_LValue, OK_Ordinary) {
   assert(Ctx.getAsConstantArrayType(Ty) &&
@@ -1121,9 +1142,9 @@
   *getTrailingObjects<unsigned>() = Length;
 }
 
-StringLiteral *StringLiteral::Create(const ASTContext &Ctx, StringRef Str,
+StringLiteral *StringLiteral::Create(ASTContext const &Ctx, StringRef Str,
                                      StringKind Kind, bool Pascal, QualType Ty,
-                                     const SourceLocation *Loc,
+                                     SourceLocation const *Loc,
                                      unsigned NumConcatenated) {
   void *Mem = Ctx.Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(
                                1, NumConcatenated, Str.size()),
@@ -1132,7 +1153,7 @@
       StringLiteral(Ctx, Str, Kind, Pascal, Ty, Loc, NumConcatenated);
 }
 
-StringLiteral *StringLiteral::CreateEmpty(const ASTContext &Ctx,
+StringLiteral *StringLiteral::CreateEmpty(ASTContext const &Ctx,
                                           unsigned NumConcatenated,
                                           unsigned Length,
                                           unsigned CharByteWidth) {
@@ -1145,14 +1166,23 @@
 
 void StringLiteral::outputString(raw_ostream &OS) const {
   switch (getKind()) {
-  case Ascii: break; // no prefix.
-  case Wide:  OS << 'L'; break;
-  case UTF8:  OS << "u8"; break;
-  case UTF16: OS << 'u'; break;
-  case UTF32: OS << 'U'; break;
+  case Ascii:
+    break; // no prefix.
+  case Wide:
+    OS << 'L';
+    break;
+  case UTF8:
+    OS << "u8";
+    break;
+  case UTF16:
+    OS << 'u';
+    break;
+  case UTF32:
+    OS << 'U';
+    break;
   }
   OS << '"';
-  static const char Hex[] = "0123456789ABCDEF";
+  static char const Hex[] = "0123456789ABCDEF";
 
   unsigned LastSlashX = getLength();
   for (unsigned I = 0, N = getLength(); I != N; ++I) {
@@ -1175,8 +1205,8 @@
         // If this is a wide string, output characters over 0xff using \x
         // escapes. Otherwise, this is a UTF-16 or UTF-32 string, and Char is a
         // codepoint: use \x escapes for invalid codepoints.
-        if (getKind() == Wide ||
-            (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {
+        if (getKind() == Wide || (Char >= 0xd800 && Char <= 0xdfff) ||
+            Char >= 0x110000) {
           // FIXME: Is this the best way to print wchar_t?
           OS << "\\x";
           int Shift = 28;
@@ -1189,15 +1219,11 @@
         }
 
         if (Char > 0xffff)
-          OS << "\\U00"
-             << Hex[(Char >> 20) & 15]
-             << Hex[(Char >> 16) & 15];
+          OS << "\\U00" << Hex[(Char >> 20) & 15] << Hex[(Char >> 16) & 15];
         else
           OS << "\\u";
-        OS << Hex[(Char >> 12) & 15]
-           << Hex[(Char >>  8) & 15]
-           << Hex[(Char >>  4) & 15]
-           << Hex[(Char >>  0) & 15];
+        OS << Hex[(Char >> 12) & 15] << Hex[(Char >> 8) & 15]
+           << Hex[(Char >> 4) & 15] << Hex[(Char >> 0) & 15];
         break;
       }
 
@@ -1205,11 +1231,29 @@
       // hexadecimal digit, prevent it being slurped as part of the \x.
       if (LastSlashX + 1 == I) {
         switch (Char) {
-          case '0': case '1': case '2': case '3': case '4':
-          case '5': case '6': case '7': case '8': case '9':
-          case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
-          case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
-            OS << "\"\"";
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+        case 'a':
+        case 'b':
+        case 'c':
+        case 'd':
+        case 'e':
+        case 'f':
+        case 'A':
+        case 'B':
+        case 'C':
+        case 'D':
+        case 'E':
+        case 'F':
+          OS << "\"\"";
         }
       }
 
@@ -1218,22 +1262,39 @@
 
       if (isPrintable(Char))
         OS << (char)Char;
-      else  // Output anything hard as an octal escape.
-        OS << '\\'
-           << (char)('0' + ((Char >> 6) & 7))
+      else // Output anything hard as an octal escape.
+        OS << '\\' << (char)('0' + ((Char >> 6) & 7))
            << (char)('0' + ((Char >> 3) & 7))
            << (char)('0' + ((Char >> 0) & 7));
       break;
     // Handle some common non-printable cases to make dumps prettier.
-    case '\\': OS << "\\\\"; break;
-    case '"': OS << "\\\""; break;
-    case '\a': OS << "\\a"; break;
-    case '\b': OS << "\\b"; break;
-    case '\f': OS << "\\f"; break;
-    case '\n': OS << "\\n"; break;
-    case '\r': OS << "\\r"; break;
-    case '\t': OS << "\\t"; break;
-    case '\v': OS << "\\v"; break;
+    case '\\':
+      OS << "\\\\";
+      break;
+    case '"':
+      OS << "\\\"";
+      break;
+    case '\a':
+      OS << "\\a";
+      break;
+    case '\b':
+      OS << "\\b";
+      break;
+    case '\f':
+      OS << "\\f";
+      break;
+    case '\n':
+      OS << "\\n";
+      break;
+    case '\r':
+      OS << "\\r";
+      break;
+    case '\t':
+      OS << "\\t";
+      break;
+    case '\v':
+      OS << "\\v";
+      break;
     }
   }
   OS << '"';
@@ -1256,13 +1317,13 @@
 /// string.
 ///
 SourceLocation
-StringLiteral::getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
-                                 const LangOptions &Features,
-                                 const TargetInfo &Target, unsigned *StartToken,
+StringLiteral::getLocationOfByte(unsigned ByteNo, SourceManager const &SM,
+                                 LangOptions const &Features,
+                                 TargetInfo const &Target, unsigned *StartToken,
                                  unsigned *StartTokenByteOffset) const {
-  assert((getKind() == StringLiteral::Ascii ||
-          getKind() == StringLiteral::UTF8) &&
-         "Only narrow string literals are currently supported");
+  assert(
+      (getKind() == StringLiteral::Ascii || getKind() == StringLiteral::UTF8) &&
+      "Only narrow string literals are currently supported");
 
   // Loop over all of the tokens in this string until we find the one that
   // contains the byte we're looking for.
@@ -1296,7 +1357,7 @@
       return StrTokSpellingLoc;
     }
 
-    const char *StrData = Buffer.data()+LocInfo.second;
+    char const *StrData = Buffer.data() + LocInfo.second;
 
     // Create a lexer starting at the beginning of this token.
     Lexer TheLexer(SM.getLocForStartOfFile(LocInfo.first), Features,
@@ -1333,44 +1394,67 @@
 /// corresponds to, e.g. "sizeof" or "[pre]++".
 StringRef UnaryOperator::getOpcodeStr(Opcode Op) {
   switch (Op) {
-#define UNARY_OPERATION(Name, Spelling) case UO_##Name: return Spelling;
+#define UNARY_OPERATION(Name, Spelling)                                        \
+  case UO_##Name:                                                              \
+    return Spelling;
 #include "clang/AST/OperationKinds.def"
   }
   llvm_unreachable("Unknown unary operator");
 }
 
-UnaryOperatorKind
-UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
+UnaryOperatorKind UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO,
+                                                     bool Postfix) {
   switch (OO) {
-  default: llvm_unreachable("No unary operator for overloaded function");
-  case OO_PlusPlus:   return Postfix ? UO_PostInc : UO_PreInc;
-  case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec;
-  case OO_Amp:        return UO_AddrOf;
-  case OO_Star:       return UO_Deref;
-  case OO_Plus:       return UO_Plus;
-  case OO_Minus:      return UO_Minus;
-  case OO_Tilde:      return UO_Not;
-  case OO_Exclaim:    return UO_LNot;
-  case OO_Coawait:    return UO_Coawait;
+  default:
+    llvm_unreachable("No unary operator for overloaded function");
+  case OO_PlusPlus:
+    return Postfix ? UO_PostInc : UO_PreInc;
+  case OO_MinusMinus:
+    return Postfix ? UO_PostDec : UO_PreDec;
+  case OO_Amp:
+    return UO_AddrOf;
+  case OO_Star:
+    return UO_Deref;
+  case OO_Plus:
+    return UO_Plus;
+  case OO_Minus:
+    return UO_Minus;
+  case OO_Tilde:
+    return UO_Not;
+  case OO_Exclaim:
+    return UO_LNot;
+  case OO_Coawait:
+    return UO_Coawait;
   }
 }
 
 OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
   switch (Opc) {
-  case UO_PostInc: case UO_PreInc: return OO_PlusPlus;
-  case UO_PostDec: case UO_PreDec: return OO_MinusMinus;
-  case UO_AddrOf: return OO_Amp;
-  case UO_Deref: return OO_Star;
-  case UO_Plus: return OO_Plus;
-  case UO_Minus: return OO_Minus;
-  case UO_Not: return OO_Tilde;
-  case UO_LNot: return OO_Exclaim;
-  case UO_Coawait: return OO_Coawait;
-  default: return OO_None;
+  case UO_PostInc:
+  case UO_PreInc:
+    return OO_PlusPlus;
+  case UO_PostDec:
+  case UO_PreDec:
+    return OO_MinusMinus;
+  case UO_AddrOf:
+    return OO_Amp;
+  case UO_Deref:
+    return OO_Star;
+  case UO_Plus:
+    return OO_Plus;
+  case UO_Minus:
+    return OO_Minus;
+  case UO_Not:
+    return OO_Tilde;
+  case UO_LNot:
+    return OO_Exclaim;
+  case UO_Coawait:
+    return OO_Coawait;
+  default:
+    return OO_None;
   }
 }
 
-
 //===----------------------------------------------------------------------===//
 // Postfix Operators.
 //===----------------------------------------------------------------------===//
@@ -1420,7 +1504,7 @@
   CallExprBits.HasFPFeatures = HasFPFeatures;
 }
 
-CallExpr *CallExpr::Create(const ASTContext &Ctx, Expr *Fn,
+CallExpr *CallExpr::Create(ASTContext const &Ctx, Expr *Fn,
                            ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
                            SourceLocation RParenLoc,
                            FPOptionsOverride FPFeatures, unsigned MinNumArgs,
@@ -1444,7 +1528,7 @@
                             /*MinNumArgs=*/0, UsesADL);
 }
 
-CallExpr *CallExpr::CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
+CallExpr *CallExpr::CreateEmpty(ASTContext const &Ctx, unsigned NumArgs,
                                 bool HasFPFeatures, EmptyShell Empty) {
   unsigned SizeOfTrailingObjects =
       CallExpr::sizeOfTrailingObjects(/*NumPreArgs=*/0, NumArgs, HasFPFeatures);
@@ -1513,18 +1597,18 @@
   return FDecl ? FDecl->getBuiltinID() : 0;
 }
 
-bool CallExpr::isUnevaluatedBuiltinCall(const ASTContext &Ctx) const {
+bool CallExpr::isUnevaluatedBuiltinCall(ASTContext const &Ctx) const {
   if (unsigned BI = getBuiltinCallee())
     return Ctx.BuiltinInfo.isUnevaluated(BI);
   return false;
 }
 
-QualType CallExpr::getCallReturnType(const ASTContext &Ctx) const {
-  const Expr *Callee = getCallee();
+QualType CallExpr::getCallReturnType(ASTContext const &Ctx) const {
+  Expr const *Callee = getCallee();
   QualType CalleeType = Callee->getType();
-  if (const auto *FnTypePtr = CalleeType->getAs<PointerType>()) {
+  if (auto const *FnTypePtr = CalleeType->getAs<PointerType>()) {
     CalleeType = FnTypePtr->getPointeeType();
-  } else if (const auto *BPT = CalleeType->getAs<BlockPointerType>()) {
+  } else if (auto const *BPT = CalleeType->getAs<BlockPointerType>()) {
     CalleeType = BPT->getPointeeType();
   } else if (CalleeType->isSpecificPlaceholderType(BuiltinType::BoundMember)) {
     if (isa<CXXPseudoDestructorExpr>(Callee->IgnoreParens()))
@@ -1541,20 +1625,20 @@
     return Ctx.DependentTy;
   }
 
-  const FunctionType *FnType = CalleeType->castAs<FunctionType>();
+  FunctionType const *FnType = CalleeType->castAs<FunctionType>();
   return FnType->getReturnType();
 }
 
-const Attr *CallExpr::getUnusedResultAttr(const ASTContext &Ctx) const {
+Attr const *CallExpr::getUnusedResultAttr(ASTContext const &Ctx) const {
   // If the return type is a struct, union, or enum that is marked nodiscard,
   // then return the return type attribute.
-  if (const TagDecl *TD = getCallReturnType(Ctx)->getAsTagDecl())
-    if (const auto *A = TD->getAttr<WarnUnusedResultAttr>())
+  if (TagDecl const *TD = getCallReturnType(Ctx)->getAsTagDecl())
+    if (auto const *A = TD->getAttr<WarnUnusedResultAttr>())
       return A;
 
   // Otherwise, see if the callee is marked nodiscard and return that attribute
   // instead.
-  const Decl *D = getCalleeDecl();
+  Decl const *D = getCalleeDecl();
   return D ? D->getAttr<WarnUnusedResultAttr>() : nullptr;
 }
 
@@ -1577,27 +1661,27 @@
   return end;
 }
 
-OffsetOfExpr *OffsetOfExpr::Create(const ASTContext &C, QualType type,
+OffsetOfExpr *OffsetOfExpr::Create(ASTContext const &C, QualType type,
                                    SourceLocation OperatorLoc,
                                    TypeSourceInfo *tsi,
                                    ArrayRef<OffsetOfNode> comps,
-                                   ArrayRef<Expr*> exprs,
+                                   ArrayRef<Expr *> exprs,
                                    SourceLocation RParenLoc) {
   void *Mem = C.Allocate(
       totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));
 
-  return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, comps, exprs,
-                                RParenLoc);
+  return new (Mem)
+      OffsetOfExpr(C, type, OperatorLoc, tsi, comps, exprs, RParenLoc);
 }
 
-OffsetOfExpr *OffsetOfExpr::CreateEmpty(const ASTContext &C,
-                                        unsigned numComps, unsigned numExprs) {
+OffsetOfExpr *OffsetOfExpr::CreateEmpty(ASTContext const &C, unsigned numComps,
+                                        unsigned numExprs) {
   void *Mem =
       C.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs));
   return new (Mem) OffsetOfExpr(numComps, numExprs);
 }
 
-OffsetOfExpr::OffsetOfExpr(const ASTContext &C, QualType type,
+OffsetOfExpr::OffsetOfExpr(ASTContext const &C, QualType type,
                            SourceLocation OperatorLoc, TypeSourceInfo *tsi,
                            ArrayRef<OffsetOfNode> comps, ArrayRef<Expr *> exprs,
                            SourceLocation RParenLoc)
@@ -1617,7 +1701,7 @@
   if (getKind() == Field)
     return getField()->getIdentifier();
 
-  return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask);
+  return reinterpret_cast<IdentifierInfo *>(Data & ~(uintptr_t)Mask);
 }
 
 UnaryExprOrTypeTraitExpr::UnaryExprOrTypeTraitExpr(
@@ -1636,7 +1720,7 @@
 
 MemberExpr::MemberExpr(Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
                        ValueDecl *MemberDecl,
-                       const DeclarationNameInfo &NameInfo, QualType T,
+                       DeclarationNameInfo const &NameInfo, QualType T,
                        ExprValueKind VK, ExprObjectKind OK,
                        NonOdrUseReason NOUR)
     : Expr(MemberExprClass, T, VK, OK), Base(Base), MemberDecl(MemberDecl),
@@ -1653,10 +1737,10 @@
 }
 
 MemberExpr *MemberExpr::Create(
-    const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
+    ASTContext const &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc,
     NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
     ValueDecl *MemberDecl, DeclAccessPair FoundDecl,
-    DeclarationNameInfo NameInfo, const TemplateArgumentListInfo *TemplateArgs,
+    DeclarationNameInfo NameInfo, TemplateArgumentListInfo const *TemplateArgs,
     QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR) {
   bool HasQualOrFound = QualifierLoc || FoundDecl.getDecl() != MemberDecl ||
                         FoundDecl.getAccess() != MemberDecl->getAccess();
@@ -1708,7 +1792,7 @@
   return E;
 }
 
-MemberExpr *MemberExpr::CreateEmpty(const ASTContext &Context,
+MemberExpr *MemberExpr::CreateEmpty(ASTContext const &Context,
                                     bool HasQualifier, bool HasFoundDecl,
                                     bool HasTemplateKWAndArgsInfo,
                                     unsigned NumTemplateArgs) {
@@ -1871,9 +1955,9 @@
   case CK_MemberPointerToBoolean:
   case CK_FloatingComplexToBoolean:
   case CK_IntegralComplexToBoolean:
-  case CK_LValueBitCast:            // -> bool&
+  case CK_LValueBitCast: // -> bool&
   case CK_LValueToRValueBitCast:
-  case CK_UserDefinedConversion:    // operator bool()
+  case CK_UserDefinedConversion: // operator bool()
   case CK_BuiltinFnToFnPtr:
   case CK_FixedPointToBoolean:
   CheckNoBasePath:
@@ -1883,43 +1967,44 @@
   return true;
 }
 
-const char *CastExpr::getCastKindName(CastKind CK) {
+char const *CastExpr::getCastKindName(CastKind CK) {
   switch (CK) {
-#define CAST_OPERATION(Name) case CK_##Name: return #Name;
+#define CAST_OPERATION(Name)                                                   \
+  case CK_##Name:                                                              \
+    return #Name;
 #include "clang/AST/OperationKinds.def"
   }
   llvm_unreachable("Unhandled cast kind!");
 }
 
 namespace {
-  const Expr *skipImplicitTemporary(const Expr *E) {
-    // Skip through reference binding to temporary.
-    if (auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E))
-      E = Materialize->getSubExpr();
+Expr const *skipImplicitTemporary(Expr const *E) {
+  // Skip through reference binding to temporary.
+  if (auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E))
+    E = Materialize->getSubExpr();
 
-    // Skip any temporary bindings; they're implicit.
-    if (auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
-      E = Binder->getSubExpr();
+  // Skip any temporary bindings; they're implicit.
+  if (auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
+    E = Binder->getSubExpr();
 
-    return E;
-  }
+  return E;
 }
+} // namespace
 
 Expr *CastExpr::getSubExprAsWritten() {
-  const Expr *SubExpr = nullptr;
-  const CastExpr *E = this;
+  Expr const *SubExpr = nullptr;
+  CastExpr const *E = this;
   do {
     SubExpr = skipImplicitTemporary(E->getSubExpr());
 
     // Conversions by constructor and conversion functions have a
     // subexpression describing the call; strip it off.
     if (E->getCastKind() == CK_ConstructorConversion)
-      SubExpr =
-        skipImplicitTemporary(cast<CXXConstructExpr>(SubExpr->IgnoreImplicit())->getArg(0));
+      SubExpr = skipImplicitTemporary(
+          cast<CXXConstructExpr>(SubExpr->IgnoreImplicit())->getArg(0));
     else if (E->getCastKind() == CK_UserDefinedConversion) {
       SubExpr = SubExpr->IgnoreImplicit();
-      assert((isa<CXXMemberCallExpr>(SubExpr) ||
-              isa<BlockExpr>(SubExpr)) &&
+      assert((isa<CXXMemberCallExpr>(SubExpr) || isa<BlockExpr>(SubExpr)) &&
              "Unexpected SubExpr for CK_UserDefinedConversion.");
       if (auto *MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))
         SubExpr = MCE->getImplicitObjectArgument();
@@ -1929,13 +2014,13 @@
     // through that, too.
   } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
 
-  return const_cast<Expr*>(SubExpr);
+  return const_cast<Expr *>(SubExpr);
 }
 
 NamedDecl *CastExpr::getConversionFunction() const {
-  const Expr *SubExpr = nullptr;
+  Expr const *SubExpr = nullptr;
 
-  for (const CastExpr *E = this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
+  for (CastExpr const *E = this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
     SubExpr = skipImplicitTemporary(E->getSubExpr());
 
     if (E->getCastKind() == CK_ConstructorConversion)
@@ -1963,18 +2048,18 @@
   }
 }
 
-const FieldDecl *CastExpr::getTargetFieldForToUnionCast(QualType unionType,
+FieldDecl const *CastExpr::getTargetFieldForToUnionCast(QualType unionType,
                                                         QualType opType) {
   auto RD = unionType->castAs<RecordType>()->getDecl();
   return getTargetFieldForToUnionCast(RD, opType);
 }
 
-const FieldDecl *CastExpr::getTargetFieldForToUnionCast(const RecordDecl *RD,
+FieldDecl const *CastExpr::getTargetFieldForToUnionCast(RecordDecl const *RD,
                                                         QualType OpType) {
   auto &Ctx = RD->getASTContext();
   RecordDecl::field_iterator Field, FieldEnd;
-  for (Field = RD->field_begin(), FieldEnd = RD->field_end();
-       Field != FieldEnd; ++Field) {
+  for (Field = RD->field_begin(), FieldEnd = RD->field_end(); Field != FieldEnd;
+       ++Field) {
     if (Ctx.hasSameUnqualifiedType(Field->getType(), OpType) &&
         !Field->isUnnamedBitfield()) {
       return *Field;
@@ -2003,9 +2088,9 @@
   }
 }
 
-ImplicitCastExpr *ImplicitCastExpr::Create(const ASTContext &C, QualType T,
+ImplicitCastExpr *ImplicitCastExpr::Create(ASTContext const &C, QualType T,
                                            CastKind Kind, Expr *Operand,
-                                           const CXXCastPath *BasePath,
+                                           CXXCastPath const *BasePath,
                                            ExprValueKind VK,
                                            FPOptionsOverride FPO) {
   unsigned PathSize = (BasePath ? BasePath->size() : 0);
@@ -2025,7 +2110,7 @@
   return E;
 }
 
-ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(const ASTContext &C,
+ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(ASTContext const &C,
                                                 unsigned PathSize,
                                                 bool HasFPFeatures) {
   void *Buffer =
@@ -2034,9 +2119,9 @@
   return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize, HasFPFeatures);
 }
 
-CStyleCastExpr *CStyleCastExpr::Create(const ASTContext &C, QualType T,
+CStyleCastExpr *CStyleCastExpr::Create(ASTContext const &C, QualType T,
                                        ExprValueKind VK, CastKind K, Expr *Op,
-                                       const CXXCastPath *BasePath,
+                                       CXXCastPath const *BasePath,
                                        FPOptionsOverride FPO,
                                        TypeSourceInfo *WrittenTy,
                                        SourceLocation L, SourceLocation R) {
@@ -2052,7 +2137,7 @@
   return E;
 }
 
-CStyleCastExpr *CStyleCastExpr::CreateEmpty(const ASTContext &C,
+CStyleCastExpr *CStyleCastExpr::CreateEmpty(ASTContext const &C,
                                             unsigned PathSize,
                                             bool HasFPFeatures) {
   void *Buffer =
@@ -2065,7 +2150,9 @@
 /// corresponds to, e.g. "<<=".
 StringRef BinaryOperator::getOpcodeStr(Opcode Op) {
   switch (Op) {
-#define BINARY_OPERATION(Name, Spelling) case BO_##Name: return Spelling;
+#define BINARY_OPERATION(Name, Spelling)                                       \
+  case BO_##Name:                                                              \
+    return Spelling;
 #include "clang/AST/OperationKinds.def"
   }
   llvm_unreachable("Invalid OpCode!");
@@ -2074,70 +2161,116 @@
 BinaryOperatorKind
 BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
   switch (OO) {
-  default: llvm_unreachable("Not an overloadable binary operator");
-  case OO_Plus: return BO_Add;
-  case OO_Minus: return BO_Sub;
-  case OO_Star: return BO_Mul;
-  case OO_Slash: return BO_Div;
-  case OO_Percent: return BO_Rem;
-  case OO_Caret: return BO_Xor;
-  case OO_Amp: return BO_And;
-  case OO_Pipe: return BO_Or;
-  case OO_Equal: return BO_Assign;
-  case OO_Spaceship: return BO_Cmp;
-  case OO_Less: return BO_LT;
-  case OO_Greater: return BO_GT;
-  case OO_PlusEqual: return BO_AddAssign;
-  case OO_MinusEqual: return BO_SubAssign;
-  case OO_StarEqual: return BO_MulAssign;
-  case OO_SlashEqual: return BO_DivAssign;
-  case OO_PercentEqual: return BO_RemAssign;
-  case OO_CaretEqual: return BO_XorAssign;
-  case OO_AmpEqual: return BO_AndAssign;
-  case OO_PipeEqual: return BO_OrAssign;
-  case OO_LessLess: return BO_Shl;
-  case OO_GreaterGreater: return BO_Shr;
-  case OO_LessLessEqual: return BO_ShlAssign;
-  case OO_GreaterGreaterEqual: return BO_ShrAssign;
-  case OO_EqualEqual: return BO_EQ;
-  case OO_ExclaimEqual: return BO_NE;
-  case OO_LessEqual: return BO_LE;
-  case OO_GreaterEqual: return BO_GE;
-  case OO_AmpAmp: return BO_LAnd;
-  case OO_PipePipe: return BO_LOr;
-  case OO_Comma: return BO_Comma;
-  case OO_ArrowStar: return BO_PtrMemI;
+  default:
+    llvm_unreachable("Not an overloadable binary operator");
+  case OO_Plus:
+    return BO_Add;
+  case OO_Minus:
+    return BO_Sub;
+  case OO_Star:
+    return BO_Mul;
+  case OO_Slash:
+    return BO_Div;
+  case OO_Percent:
+    return BO_Rem;
+  case OO_Caret:
+    return BO_Xor;
+  case OO_Amp:
+    return BO_And;
+  case OO_Pipe:
+    return BO_Or;
+  case OO_Equal:
+    return BO_Assign;
+  case OO_Spaceship:
+    return BO_Cmp;
+  case OO_Less:
+    return BO_LT;
+  case OO_Greater:
+    return BO_GT;
+  case OO_PlusEqual:
+    return BO_AddAssign;
+  case OO_MinusEqual:
+    return BO_SubAssign;
+  case OO_StarEqual:
+    return BO_MulAssign;
+  case OO_SlashEqual:
+    return BO_DivAssign;
+  case OO_PercentEqual:
+    return BO_RemAssign;
+  case OO_CaretEqual:
+    return BO_XorAssign;
+  case OO_AmpEqual:
+    return BO_AndAssign;
+  case OO_PipeEqual:
+    return BO_OrAssign;
+  case OO_LessLess:
+    return BO_Shl;
+  case OO_GreaterGreater:
+    return BO_Shr;
+  case OO_LessLessEqual:
+    return BO_ShlAssign;
+  case OO_GreaterGreaterEqual:
+    return BO_ShrAssign;
+  case OO_EqualEqual:
+    return BO_EQ;
+  case OO_ExclaimEqual:
+    return BO_NE;
+  case OO_LessEqual:
+    return BO_LE;
+  case OO_GreaterEqual:
+    return BO_GE;
+  case OO_AmpAmp:
+    return BO_LAnd;
+  case OO_PipePipe:
+    return BO_LOr;
+  case OO_Comma:
+    return BO_Comma;
+  case OO_ArrowStar:
+    return BO_PtrMemI;
   }
 }
 
 OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
   static const OverloadedOperatorKind OverOps[] = {
-    /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
-    OO_Star, OO_Slash, OO_Percent,
-    OO_Plus, OO_Minus,
-    OO_LessLess, OO_GreaterGreater,
-    OO_Spaceship,
-    OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
-    OO_EqualEqual, OO_ExclaimEqual,
-    OO_Amp,
-    OO_Caret,
-    OO_Pipe,
-    OO_AmpAmp,
-    OO_PipePipe,
-    OO_Equal, OO_StarEqual,
-    OO_SlashEqual, OO_PercentEqual,
-    OO_PlusEqual, OO_MinusEqual,
-    OO_LessLessEqual, OO_GreaterGreaterEqual,
-    OO_AmpEqual, OO_CaretEqual,
-    OO_PipeEqual,
-    OO_Comma
-  };
+      /* .* Cannot be overloaded */ OO_None,
+      OO_ArrowStar,
+      OO_Star,
+      OO_Slash,
+      OO_Percent,
+      OO_Plus,
+      OO_Minus,
+      OO_LessLess,
+      OO_GreaterGreater,
+      OO_Spaceship,
+      OO_Less,
+      OO_Greater,
+      OO_LessEqual,
+      OO_GreaterEqual,
+      OO_EqualEqual,
+      OO_ExclaimEqual,
+      OO_Amp,
+      OO_Caret,
+      OO_Pipe,
+      OO_AmpAmp,
+      OO_PipePipe,
+      OO_Equal,
+      OO_StarEqual,
+      OO_SlashEqual,
+      OO_PercentEqual,
+      OO_PlusEqual,
+      OO_MinusEqual,
+      OO_LessLessEqual,
+      OO_GreaterGreaterEqual,
+      OO_AmpEqual,
+      OO_CaretEqual,
+      OO_PipeEqual,
+      OO_Comma};
   return OverOps[Opc];
 }
 
 bool BinaryOperator::isNullPointerArithmeticExtension(ASTContext &Ctx,
-                                                      Opcode Opc,
-                                                      Expr *LHS, Expr *RHS) {
+                                                      Opcode Opc, Expr *LHS,
+                                                      Expr *RHS) {
   if (Opc != BO_Add)
     return false;
 
@@ -2156,19 +2289,19 @@
   }
 
   // Check that the pointer is a nullptr.
-  if (!PExp->IgnoreParenCasts()
-          ->isNullPointerConstant(Ctx, Expr::NPC_ValueDependentIsNotNull))
+  if (!PExp->IgnoreParenCasts()->isNullPointerConstant(
+          Ctx, Expr::NPC_ValueDependentIsNotNull))
     return false;
 
   // Check that the pointee type is char-sized.
-  const PointerType *PTy = PExp->getType()->getAs<PointerType>();
+  PointerType const *PTy = PExp->getType()->getAs<PointerType>();
   if (!PTy || !PTy->getPointeeType()->isCharType())
     return false;
 
   return true;
 }
 
-static QualType getDecayedSourceLocExprType(const ASTContext &Ctx,
+static QualType getDecayedSourceLocExprType(ASTContext const &Ctx,
                                             SourceLocExpr::IdentKind Kind) {
   switch (Kind) {
   case SourceLocExpr::File:
@@ -2183,7 +2316,7 @@
   llvm_unreachable("unhandled case");
 }
 
-SourceLocExpr::SourceLocExpr(const ASTContext &Ctx, IdentKind Kind,
+SourceLocExpr::SourceLocExpr(ASTContext const &Ctx, IdentKind Kind,
                              SourceLocation BLoc, SourceLocation RParenLoc,
                              DeclContext *ParentContext)
     : Expr(SourceLocExprClass, getDecayedSourceLocExprType(Ctx, Kind),
@@ -2207,13 +2340,13 @@
   llvm_unreachable("unexpected IdentKind!");
 }
 
-APValue SourceLocExpr::EvaluateInContext(const ASTContext &Ctx,
-                                         const Expr *DefaultExpr) const {
+APValue SourceLocExpr::EvaluateInContext(ASTContext const &Ctx,
+                                         Expr const *DefaultExpr) const {
   SourceLocation Loc;
-  const DeclContext *Context;
+  DeclContext const *Context;
 
   std::tie(Loc,
-           Context) = [&]() -> std::pair<SourceLocation, const DeclContext *> {
+           Context) = [&]() -> std::pair<SourceLocation, DeclContext const *> {
     if (auto *DIE = dyn_cast_or_null<CXXDefaultInitExpr>(DefaultExpr))
       return {DIE->getUsedLocation(), DIE->getUsedContext()};
     if (auto *DAE = dyn_cast_or_null<CXXDefaultArgExpr>(DefaultExpr))
@@ -2239,7 +2372,7 @@
     return MakeStringLiteral(Path);
   }
   case SourceLocExpr::Function: {
-    const Decl *CurDecl = dyn_cast_or_null<Decl>(Context);
+    Decl const *CurDecl = dyn_cast_or_null<Decl>(Context);
     return MakeStringLiteral(
         CurDecl ? PredefinedExpr::ComputeName(PredefinedExpr::Function, CurDecl)
                 : std::string(""));
@@ -2256,7 +2389,7 @@
   llvm_unreachable("unhandled case");
 }
 
-InitListExpr::InitListExpr(const ASTContext &C, SourceLocation lbraceloc,
+InitListExpr::InitListExpr(ASTContext const &C, SourceLocation lbraceloc,
                            ArrayRef<Expr *> initExprs, SourceLocation rbraceloc)
     : Expr(InitListExprClass, QualType(), VK_PRValue, OK_Ordinary),
       InitExprs(C, initExprs.size()), LBraceLoc(lbraceloc),
@@ -2267,16 +2400,16 @@
   setDependence(computeDependence(this));
 }
 
-void InitListExpr::reserveInits(const ASTContext &C, unsigned NumInits) {
+void InitListExpr::reserveInits(ASTContext const &C, unsigned NumInits) {
   if (NumInits > InitExprs.size())
     InitExprs.reserve(C, NumInits);
 }
 
-void InitListExpr::resizeInits(const ASTContext &C, unsigned NumInits) {
+void InitListExpr::resizeInits(ASTContext const &C, unsigned NumInits) {
   InitExprs.resize(C, NumInits, nullptr);
 }
 
-Expr *InitListExpr::updateInit(const ASTContext &C, unsigned Init, Expr *expr) {
+Expr *InitListExpr::updateInit(ASTContext const &C, unsigned Init, Expr *expr) {
   if (Init >= InitExprs.size()) {
     InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, nullptr);
     setInit(Init, expr);
@@ -2301,11 +2434,11 @@
 bool InitListExpr::isStringLiteralInit() const {
   if (getNumInits() != 1)
     return false;
-  const ArrayType *AT = getType()->getAsArrayTypeUnsafe();
+  ArrayType const *AT = getType()->getAsArrayTypeUnsafe();
   if (!AT || !AT->getElementType()->isIntegerType())
     return false;
   // It is possible for getInit() to return null.
-  const Expr *Init = getInit(0);
+  Expr const *Init = getInit(0);
   if (!Init)
     return false;
   Init = Init->IgnoreParenImpCasts();
@@ -2335,14 +2468,16 @@
          getInit(0)->getType().getCanonicalType();
 }
 
-bool InitListExpr::isIdiomaticZeroInitializer(const LangOptions &LangOpts) const {
+bool InitListExpr::isIdiomaticZeroInitializer(
+    LangOptions const &LangOpts) const {
   assert(isSyntacticForm() && "only test syntactic form as zero initializer");
 
   if (LangOpts.CPlusPlus || getNumInits() != 1 || !getInit(0)) {
     return false;
   }
 
-  const IntegerLiteral *Lit = dyn_cast<IntegerLiteral>(getInit(0)->IgnoreImplicit());
+  IntegerLiteral const *Lit =
+      dyn_cast<IntegerLiteral>(getInit(0)->IgnoreImplicit());
   return Lit && Lit->getValue() == 0;
 }
 
@@ -2352,9 +2487,8 @@
   SourceLocation Beg = LBraceLoc;
   if (Beg.isInvalid()) {
     // Find the first non-null initializer.
-    for (InitExprsTy::const_iterator I = InitExprs.begin(),
-                                     E = InitExprs.end();
-      I != E; ++I) {
+    for (InitExprsTy::const_iterator I = InitExprs.begin(), E = InitExprs.end();
+         I != E; ++I) {
       if (Stmt *S = *I) {
         Beg = S->getBeginLoc();
         break;
@@ -2371,7 +2505,7 @@
   if (End.isInvalid()) {
     // Find the first non-null initializer from the end.
     for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(),
-         E = InitExprs.rend();
+                                             E = InitExprs.rend();
          I != E; ++I) {
       if (Stmt *S = *I) {
         End = S->getEndLoc();
@@ -2384,22 +2518,18 @@
 
 /// getFunctionType - Return the underlying function type for this block.
 ///
-const FunctionProtoType *BlockExpr::getFunctionType() const {
+FunctionProtoType const *BlockExpr::getFunctionType() const {
   // The block pointer is never sugared, but the function type might be.
   return cast<BlockPointerType>(getType())
-           ->getPointeeType()->castAs<FunctionProtoType>();
+      ->getPointeeType()
+      ->castAs<FunctionProtoType>();
 }
 
 SourceLocation BlockExpr::getCaretLocation() const {
   return TheBlock->getCaretLocation();
 }
-const Stmt *BlockExpr::getBody() const {
-  return TheBlock->getBody();
-}
-Stmt *BlockExpr::getBody() {
-  return TheBlock->getBody();
-}
-
+Stmt const *BlockExpr::getBody() const { return TheBlock->getBody(); }
+Stmt *BlockExpr::getBody() { return TheBlock->getBody(); }
 
 //===----------------------------------------------------------------------===//
 // Generic Expression Routines
@@ -2414,7 +2544,7 @@
   if (!isGLValue() || !getType().isVolatileQualified())
     return false;
 
-  const Expr *E = IgnoreParens();
+  Expr const *E = IgnoreParens();
 
   //   - id-expression (5.1.1),
   if (isa<DeclRefExpr>(E))
@@ -2449,8 +2579,7 @@
     return CO->getTrueExpr()->isReadIfDiscardedInCPlusPlus11() &&
            CO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
   // The related edge case of "*x ?: *x".
-  if (auto *BCO =
-          dyn_cast<BinaryConditionalOperator>(E)) {
+  if (auto *BCO = dyn_cast<BinaryConditionalOperator>(E)) {
     if (auto *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
       return OVE->getSourceExpr()->isReadIfDiscardedInCPlusPlus11() &&
              BCO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
@@ -2467,7 +2596,7 @@
 /// be warned about if the result is unused.  If so, fill in Loc and Ranges
 /// with location to warn on and the source range[s] to report with the
 /// warning.
-bool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc,
+bool Expr::isUnusedResultAWarning(Expr const *&WarnE, SourceLocation &Loc,
                                   SourceRange &R1, SourceRange &R2,
                                   ASTContext &Ctx) const {
   // Don't warn if the expr is type dependent. The type could end up
@@ -2484,20 +2613,22 @@
     R1 = getSourceRange();
     return true;
   case ParenExprClass:
-    return cast<ParenExpr>(this)->getSubExpr()->
-      isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
+    return cast<ParenExpr>(this)->getSubExpr()->isUnusedResultAWarning(
+        WarnE, Loc, R1, R2, Ctx);
   case GenericSelectionExprClass:
-    return cast<GenericSelectionExpr>(this)->getResultExpr()->
-      isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
+    return cast<GenericSelectionExpr>(this)
+        ->getResultExpr()
+        ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
   case CoawaitExprClass:
   case CoyieldExprClass:
-    return cast<CoroutineSuspendExpr>(this)->getResumeExpr()->
-      isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
+    return cast<CoroutineSuspendExpr>(this)
+        ->getResumeExpr()
+        ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
   case ChooseExprClass:
-    return cast<ChooseExpr>(this)->getChosenSubExpr()->
-      isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
+    return cast<ChooseExpr>(this)->getChosenSubExpr()->isUnusedResultAWarning(
+        WarnE, Loc, R1, R2, Ctx);
   case UnaryOperatorClass: {
-    const UnaryOperator *UO = cast<UnaryOperator>(this);
+    UnaryOperator const *UO = cast<UnaryOperator>(this);
 
     switch (UO->getOpcode()) {
     case UO_Plus:
@@ -2513,13 +2644,13 @@
     case UO_PostInc:
     case UO_PostDec:
     case UO_PreInc:
-    case UO_PreDec:                 // ++/--
-      return false;  // Not a warning.
+    case UO_PreDec: // ++/--
+      return false; // Not a warning.
     case UO_Real:
     case UO_Imag:
       // accessing a piece of a volatile complex is a side-effect.
       if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
-          .isVolatileQualified())
+              .isVolatileQualified())
         return false;
       break;
     case UO_Extension:
@@ -2531,27 +2662,27 @@
     return true;
   }
   case BinaryOperatorClass: {
-    const BinaryOperator *BO = cast<BinaryOperator>(this);
+    BinaryOperator const *BO = cast<BinaryOperator>(this);
     switch (BO->getOpcode()) {
-      default:
-        break;
-      // Consider the RHS of comma for side effects. LHS was checked by
-      // Sema::CheckCommaOperands.
-      case BO_Comma:
-        // ((foo = <blah>), 0) is an idiom for hiding the result (and
-        // lvalue-ness) of an assignment written in a macro.
-        if (IntegerLiteral *IE =
+    default:
+      break;
+    // Consider the RHS of comma for side effects. LHS was checked by
+    // Sema::CheckCommaOperands.
+    case BO_Comma:
+      // ((foo = <blah>), 0) is an idiom for hiding the result (and
+      // lvalue-ness) of an assignment written in a macro.
+      if (IntegerLiteral *IE =
               dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
-          if (IE->getValue() == 0)
-            return false;
-        return BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
-      // Consider '||', '&&' to have side effects if the LHS or RHS does.
-      case BO_LAnd:
-      case BO_LOr:
-        if (!BO->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) ||
-            !BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx))
+        if (IE->getValue() == 0)
           return false;
-        break;
+      return BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
+    // Consider '||', '&&' to have side effects if the LHS or RHS does.
+    case BO_LAnd:
+    case BO_LOr:
+      if (!BO->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) ||
+          !BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx))
+        return false;
+      break;
     }
     if (BO->isAssignmentOp())
       return false;
@@ -2570,12 +2701,12 @@
     // If only one of the LHS or RHS is a warning, the operator might
     // be being used for control flow. Only warn if both the LHS and
     // RHS are warnings.
-    const auto *Exp = cast<ConditionalOperator>(this);
+    auto const *Exp = cast<ConditionalOperator>(this);
     return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) &&
            Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
   }
   case BinaryConditionalOperatorClass: {
-    const auto *Exp = cast<BinaryConditionalOperator>(this);
+    auto const *Exp = cast<BinaryConditionalOperator>(this);
     return Exp->getFalseExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
   }
 
@@ -2600,7 +2731,7 @@
     // warning: operators == and != are commonly typo'ed, and so warning on them
     // provides additional value as well. If this list is updated,
     // DiagnoseUnusedComparison should be as well.
-    const CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(this);
+    CXXOperatorCallExpr const *Op = cast<CXXOperatorCallExpr>(this);
     switch (Op->getOperator()) {
     default:
       break;
@@ -2626,15 +2757,15 @@
   case CXXMemberCallExprClass:
   case UserDefinedLiteralClass: {
     // If this is a direct call, get the callee.
-    const CallExpr *CE = cast<CallExpr>(this);
-    if (const Decl *FD = CE->getCalleeDecl()) {
+    CallExpr const *CE = cast<CallExpr>(this);
+    if (Decl const *FD = CE->getCalleeDecl()) {
       // If the callee has attribute pure, const, or warn_unused_result, warn
       // about it. void foo() { strlen("bar"); } should warn.
       //
       // Note: If new cases are added here, DiagnoseUnusedExprResult should be
       // updated to match for QoI.
-      if (CE->hasUnusedResultAttr(Ctx) ||
-          FD->hasAttr<PureAttr>() || FD->hasAttr<ConstAttr>()) {
+      if (CE->hasUnusedResultAttr(Ctx) || FD->hasAttr<PureAttr>() ||
+          FD->hasAttr<ConstAttr>()) {
         WarnE = this;
         Loc = CE->getCallee()->getBeginLoc();
         R1 = CE->getCallee()->getSourceRange();
@@ -2656,8 +2787,8 @@
 
   case CXXTemporaryObjectExprClass:
   case CXXConstructExprClass: {
-    if (const CXXRecordDecl *Type = getType()->getAsCXXRecordDecl()) {
-      const auto *WarnURAttr = Type->getAttr<WarnUnusedResultAttr>();
+    if (CXXRecordDecl const *Type = getType()->getAsCXXRecordDecl()) {
+      auto const *WarnURAttr = Type->getAttr<WarnUnusedResultAttr>();
       if (Type->hasAttr<WarnUnusedAttr>() ||
           (WarnURAttr && WarnURAttr->IsCXX11NoDiscard())) {
         WarnE = this;
@@ -2667,9 +2798,9 @@
       }
     }
 
-    const auto *CE = cast<CXXConstructExpr>(this);
-    if (const CXXConstructorDecl *Ctor = CE->getConstructor()) {
-      const auto *WarnURAttr = Ctor->getAttr<WarnUnusedResultAttr>();
+    auto const *CE = cast<CXXConstructExpr>(this);
+    if (CXXConstructorDecl const *Ctor = CE->getConstructor()) {
+      auto const *WarnURAttr = Ctor->getAttr<WarnUnusedResultAttr>();
       if (WarnURAttr && WarnURAttr->IsCXX11NoDiscard()) {
         WarnE = this;
         Loc = getBeginLoc();
@@ -2686,18 +2817,16 @@
   }
 
   case ObjCMessageExprClass: {
-    const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
-    if (Ctx.getLangOpts().ObjCAutoRefCount &&
-        ME->isInstanceMessage() &&
-        !ME->getType()->isVoidType() &&
-        ME->getMethodFamily() == OMF_init) {
+    ObjCMessageExpr const *ME = cast<ObjCMessageExpr>(this);
+    if (Ctx.getLangOpts().ObjCAutoRefCount && ME->isInstanceMessage() &&
+        !ME->getType()->isVoidType() && ME->getMethodFamily() == OMF_init) {
       WarnE = this;
       Loc = getExprLoc();
       R1 = ME->getSourceRange();
       return true;
     }
 
-    if (const ObjCMethodDecl *MD = ME->getMethodDecl())
+    if (ObjCMethodDecl const *MD = ME->getMethodDecl())
       if (MD->hasAttr<WarnUnusedResultAttr>()) {
         WarnE = this;
         Loc = getExprLoc();
@@ -2714,7 +2843,7 @@
     return true;
 
   case PseudoObjectExprClass: {
-    const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this);
+    PseudoObjectExpr const *PO = cast<PseudoObjectExpr>(this);
 
     // Only complain about things that have the form of a getter.
     if (isa<UnaryOperator>(PO->getSyntacticForm()) ||
@@ -2733,12 +2862,12 @@
     // For example ({ blah; foo(); }) will end up with a type if foo has a type.
     // however, if the result of the stmt expr is dead, we don't want to emit a
     // warning.
-    const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
+    CompoundStmt const *CS = cast<StmtExpr>(this)->getSubStmt();
     if (!CS->body_empty()) {
-      if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
+      if (Expr const *E = dyn_cast<Expr>(CS->body_back()))
         return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
-      if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back()))
-        if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt()))
+      if (LabelStmt const *Label = dyn_cast<LabelStmt>(CS->body_back()))
+        if (Expr const *E = dyn_cast<Expr>(Label->getSubStmt()))
           return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
     }
 
@@ -2757,8 +2886,8 @@
     // the lvalue conversion in C, and happens in C++ for expressions of all
     // forms where it seems likely the user intended to trigger a volatile
     // load.)
-    const CastExpr *CE = cast<CastExpr>(this);
-    const Expr *SubE = CE->getSubExpr()->IgnoreParens();
+    CastExpr const *CE = cast<CastExpr>(this);
+    Expr const *SubE = CE->getSubExpr()->IgnoreParens();
     if (CE->getCastKind() == CK_ToVoid) {
       if (Ctx.getLangOpts().CPlusPlus && !Ctx.getLangOpts().CPlusPlus11 &&
           SubE->isReadIfDiscardedInCPlusPlus11()) {
@@ -2788,19 +2917,19 @@
       return false;
 
     WarnE = this;
-    if (const CXXFunctionalCastExpr *CXXCE =
+    if (CXXFunctionalCastExpr const *CXXCE =
             dyn_cast<CXXFunctionalCastExpr>(this)) {
       Loc = CXXCE->getBeginLoc();
       R1 = CXXCE->getSubExpr()->getSourceRange();
     } else {
-      const CStyleCastExpr *CStyleCE = cast<CStyleCastExpr>(this);
+      CStyleCastExpr const *CStyleCE = cast<CStyleCastExpr>(this);
       Loc = CStyleCE->getLParenLoc();
       R1 = CStyleCE->getSubExpr()->getSourceRange();
     }
     return true;
   }
   case ImplicitCastExprClass: {
-    const CastExpr *ICE = cast<ImplicitCastExpr>(this);
+    CastExpr const *ICE = cast<ImplicitCastExpr>(this);
 
     // lvalue-to-rvalue conversion on a volatile lvalue is a side-effect.
     if (ICE->getCastKind() == CK_LValueToRValue &&
@@ -2810,11 +2939,11 @@
     return ICE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
   }
   case CXXDefaultArgExprClass:
-    return (cast<CXXDefaultArgExpr>(this)
-            ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
+    return (cast<CXXDefaultArgExpr>(this)->getExpr()->isUnusedResultAWarning(
+        WarnE, Loc, R1, R2, Ctx));
   case CXXDefaultInitExprClass:
-    return (cast<CXXDefaultInitExpr>(this)
-            ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
+    return (cast<CXXDefaultInitExpr>(this)->getExpr()->isUnusedResultAWarning(
+        WarnE, Loc, R1, R2, Ctx));
 
   case CXXNewExprClass:
     // FIXME: In theory, there might be new expressions that don't have side
@@ -2826,18 +2955,19 @@
         ->getSubExpr()
         ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
   case CXXBindTemporaryExprClass:
-    return cast<CXXBindTemporaryExpr>(this)->getSubExpr()
-               ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
+    return cast<CXXBindTemporaryExpr>(this)
+        ->getSubExpr()
+        ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
   case ExprWithCleanupsClass:
-    return cast<ExprWithCleanups>(this)->getSubExpr()
-               ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
+    return cast<ExprWithCleanups>(this)->getSubExpr()->isUnusedResultAWarning(
+        WarnE, Loc, R1, R2, Ctx);
   }
 }
 
 /// isOBJCGCCandidate - Check if an expression is objc gc'able.
 /// returns true, if it is; false otherwise.
 bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
-  const Expr *E = IgnoreParens();
+  Expr const *E = IgnoreParens();
   switch (E->getStmtClass()) {
   default:
     return false;
@@ -2853,9 +2983,9 @@
   case CStyleCastExprClass:
     return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
   case DeclRefExprClass: {
-    const Decl *D = cast<DeclRefExpr>(E)->getDecl();
+    Decl const *D = cast<DeclRefExpr>(E)->getDecl();
 
-    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
+    if (VarDecl const *VD = dyn_cast<VarDecl>(D)) {
       if (VD->hasGlobalStorage())
         return true;
       QualType T = VD->getType();
@@ -2867,7 +2997,7 @@
     return false;
   }
   case MemberExprClass: {
-    const MemberExpr *M = cast<MemberExpr>(E);
+    MemberExpr const *M = cast<MemberExpr>(E);
     return M->getBase()->isOBJCGCCandidate(Ctx);
   }
   case ArraySubscriptExprClass:
@@ -2881,7 +3011,7 @@
   return ClassifyLValue(Ctx) == Expr::LV_MemberFunction;
 }
 
-QualType Expr::findBoundMemberType(const Expr *expr) {
+QualType Expr::findBoundMemberType(Expr const *expr) {
   assert(expr->hasPlaceholderType(BuiltinType::BoundMember));
 
   // Bound member expressions are always one of these possibilities:
@@ -2889,14 +3019,14 @@
   // (possibly parenthesized)
 
   expr = expr->IgnoreParens();
-  if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) {
+  if (MemberExpr const *mem = dyn_cast<MemberExpr>(expr)) {
     assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
     return mem->getMemberDecl()->getType();
   }
 
-  if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) {
-    QualType type = op->getRHS()->getType()->castAs<MemberPointerType>()
-                      ->getPointeeType();
+  if (BinaryOperator const *op = dyn_cast<BinaryOperator>(expr)) {
+    QualType type =
+        op->getRHS()->getType()->castAs<MemberPointerType>()->getPointeeType();
     assert(type->isFunctionType());
     return type;
   }
@@ -2952,7 +3082,7 @@
                          IgnoreBaseCastsSingleStep);
 }
 
-Expr *Expr::IgnoreParenNoopCasts(const ASTContext &Ctx) {
+Expr *Expr::IgnoreParenNoopCasts(ASTContext const &Ctx) {
   auto IgnoreNoopCastsSingleStep = [&Ctx](Expr *E) {
     if (auto *CE = dyn_cast<CastExpr>(E)) {
       // We ignore integer <-> casts that are of the same width, ptr<->ptr and
@@ -3021,11 +3151,11 @@
 }
 
 bool Expr::isDefaultArgument() const {
-  const Expr *E = this;
-  if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
+  Expr const *E = this;
+  if (MaterializeTemporaryExpr const *M = dyn_cast<MaterializeTemporaryExpr>(E))
     E = M->getSubExpr();
 
-  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
+  while (ImplicitCastExpr const *ICE = dyn_cast<ImplicitCastExpr>(E))
     E = ICE->getSubExprAsWritten();
 
   return isa<CXXDefaultArgExpr>(E);
@@ -3033,21 +3163,21 @@
 
 /// Skip over any no-op casts and any temporary-binding
 /// expressions.
-static const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) {
-  if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
+static Expr const *skipTemporaryBindingsNoOpCastsAndParens(Expr const *E) {
+  if (MaterializeTemporaryExpr const *M = dyn_cast<MaterializeTemporaryExpr>(E))
     E = M->getSubExpr();
 
-  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+  while (ImplicitCastExpr const *ICE = dyn_cast<ImplicitCastExpr>(E)) {
     if (ICE->getCastKind() == CK_NoOp)
       E = ICE->getSubExpr();
     else
       break;
   }
 
-  while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
+  while (CXXBindTemporaryExpr const *BE = dyn_cast<CXXBindTemporaryExpr>(E))
     E = BE->getSubExpr();
 
-  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+  while (ImplicitCastExpr const *ICE = dyn_cast<ImplicitCastExpr>(E)) {
     if (ICE->getCastKind() == CK_NoOp)
       E = ICE->getSubExpr();
     else
@@ -3059,11 +3189,11 @@
 
 /// isTemporaryObject - Determines if this expression produces a
 /// temporary of the given class type.
-bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const {
+bool Expr::isTemporaryObject(ASTContext &C, CXXRecordDecl const *TempTy) const {
   if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy)))
     return false;
 
-  const Expr *E = skipTemporaryBindingsNoOpCastsAndParens(this);
+  Expr const *E = skipTemporaryBindingsNoOpCastsAndParens(this);
 
   // Temporaries are by definition pr-values of class type.
   if (!E->Classify(C).isPRValue()) {
@@ -3090,7 +3220,7 @@
   if (isa<MemberExpr>(E))
     return false;
 
-  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
+  if (BinaryOperator const *BO = dyn_cast<BinaryOperator>(E))
     if (BO->isPtrMemOp())
       return false;
 
@@ -3102,16 +3232,16 @@
 }
 
 bool Expr::isImplicitCXXThis() const {
-  const Expr *E = this;
+  Expr const *E = this;
 
   // Strip away parentheses and casts we don't care about.
   while (true) {
-    if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) {
+    if (ParenExpr const *Paren = dyn_cast<ParenExpr>(E)) {
       E = Paren->getSubExpr();
       continue;
     }
 
-    if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+    if (ImplicitCastExpr const *ICE = dyn_cast<ImplicitCastExpr>(E)) {
       if (ICE->getCastKind() == CK_NoOp ||
           ICE->getCastKind() == CK_LValueToRValue ||
           ICE->getCastKind() == CK_DerivedToBase ||
@@ -3121,15 +3251,15 @@
       }
     }
 
-    if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
+    if (UnaryOperator const *UnOp = dyn_cast<UnaryOperator>(E)) {
       if (UnOp->getOpcode() == UO_Extension) {
         E = UnOp->getSubExpr();
         continue;
       }
     }
 
-    if (const MaterializeTemporaryExpr *M
-                                      = dyn_cast<MaterializeTemporaryExpr>(E)) {
+    if (MaterializeTemporaryExpr const *M =
+            dyn_cast<MaterializeTemporaryExpr>(E)) {
       E = M->getSubExpr();
       continue;
     }
@@ -3137,7 +3267,7 @@
     break;
   }
 
-  if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
+  if (CXXThisExpr const *This = dyn_cast<CXXThisExpr>(E))
     return This->isImplicit();
 
   return false;
@@ -3154,7 +3284,7 @@
 }
 
 bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef,
-                                 const Expr **Culprit) const {
+                                 Expr const **Culprit) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
@@ -3177,7 +3307,8 @@
   }
 
   switch (getStmtClass()) {
-  default: break;
+  default:
+    break;
   case Stmt::ExprWithCleanupsClass:
     return cast<ExprWithCleanups>(this)->getSubExpr()->isConstantInitializer(
         Ctx, IsForRef, Culprit);
@@ -3186,12 +3317,13 @@
     return true;
   case CXXTemporaryObjectExprClass:
   case CXXConstructExprClass: {
-    const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
+    CXXConstructExpr const *CE = cast<CXXConstructExpr>(this);
 
     if (CE->getConstructor()->isTrivial() &&
         CE->getConstructor()->getParent()->hasTrivialDestructor()) {
       // Trivial default constructor
-      if (!CE->getNumArgs()) return true;
+      if (!CE->getNumArgs())
+        return true;
 
       // Trivial copy constructor
       assert(CE->getNumArgs() == 1 && "trivial ctor with > 1 argument");
@@ -3203,23 +3335,23 @@
   case ConstantExprClass: {
     // FIXME: We should be able to return "true" here, but it can lead to extra
     // error messages. E.g. in Sema/array-init.c.
-    const Expr *Exp = cast<ConstantExpr>(this)->getSubExpr();
+    Expr const *Exp = cast<ConstantExpr>(this)->getSubExpr();
     return Exp->isConstantInitializer(Ctx, false, Culprit);
   }
   case CompoundLiteralExprClass: {
     // This handles gcc's extension that allows global initializers like
     // "struct x {int x;} x = (struct x) {};".
     // FIXME: This accepts other cases it shouldn't!
-    const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
+    Expr const *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
     return Exp->isConstantInitializer(Ctx, false, Culprit);
   }
   case DesignatedInitUpdateExprClass: {
-    const DesignatedInitUpdateExpr *DIUE = cast<DesignatedInitUpdateExpr>(this);
+    DesignatedInitUpdateExpr const *DIUE = cast<DesignatedInitUpdateExpr>(this);
     return DIUE->getBase()->isConstantInitializer(Ctx, false, Culprit) &&
            DIUE->getUpdater()->isConstantInitializer(Ctx, false, Culprit);
   }
   case InitListExprClass: {
-    const InitListExpr *ILE = cast<InitListExpr>(this);
+    InitListExpr const *ILE = cast<InitListExpr>(this);
     assert(ILE->isSemanticForm() && "InitListExpr must be in semantic form");
     if (ILE->getType()->isArrayType()) {
       unsigned numInits = ILE->getNumInits();
@@ -3233,8 +3365,9 @@
     if (ILE->getType()->isRecordType()) {
       unsigned ElementNo = 0;
       RecordDecl *RD = ILE->getType()->castAs<RecordType>()->getDecl();
-      for (const auto *Field : RD->fields()) {
-        // If this is a union, skip all the fields that aren't being initialized.
+      for (auto const *Field : RD->fields()) {
+        // If this is a union, skip all the fields that aren't being
+        // initialized.
         if (RD->isUnion() && ILE->getInitializedFieldInUnion() != Field)
           continue;
 
@@ -3243,7 +3376,7 @@
           continue;
 
         if (ElementNo < ILE->getNumInits()) {
-          const Expr *Elt = ILE->getInit(ElementNo++);
+          Expr const *Elt = ILE->getInit(ElementNo++);
           if (Field->isBitField()) {
             // Bitfields have to evaluate to an integer.
             EvalResult Result;
@@ -3268,21 +3401,22 @@
   case NoInitExprClass:
     return true;
   case ParenExprClass:
-    return cast<ParenExpr>(this)->getSubExpr()
-      ->isConstantInitializer(Ctx, IsForRef, Culprit);
+    return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(
+        Ctx, IsForRef, Culprit);
   case GenericSelectionExprClass:
-    return cast<GenericSelectionExpr>(this)->getResultExpr()
-      ->isConstantInitializer(Ctx, IsForRef, Culprit);
+    return cast<GenericSelectionExpr>(this)
+        ->getResultExpr()
+        ->isConstantInitializer(Ctx, IsForRef, Culprit);
   case ChooseExprClass:
     if (cast<ChooseExpr>(this)->isConditionDependent()) {
       if (Culprit)
         *Culprit = this;
       return false;
     }
-    return cast<ChooseExpr>(this)->getChosenSubExpr()
-      ->isConstantInitializer(Ctx, IsForRef, Culprit);
+    return cast<ChooseExpr>(this)->getChosenSubExpr()->isConstantInitializer(
+        Ctx, IsForRef, Culprit);
   case UnaryOperatorClass: {
-    const UnaryOperator* Exp = cast<UnaryOperator>(this);
+    UnaryOperator const *Exp = cast<UnaryOperator>(this);
     if (Exp->getOpcode() == UO_Extension)
       return Exp->getSubExpr()->isConstantInitializer(Ctx, false, Culprit);
     break;
@@ -3296,7 +3430,7 @@
   case CXXReinterpretCastExprClass:
   case CXXAddrspaceCastExprClass:
   case CXXConstCastExprClass: {
-    const CastExpr *CE = cast<CastExpr>(this);
+    CastExpr const *CE = cast<CastExpr>(this);
 
     // Handle misc casts we want to ignore.
     if (CE->getCastKind() == CK_NoOp ||
@@ -3316,14 +3450,15 @@
         ->isConstantInitializer(Ctx, false, Culprit);
 
   case SubstNonTypeTemplateParmExprClass:
-    return cast<SubstNonTypeTemplateParmExpr>(this)->getReplacement()
-      ->isConstantInitializer(Ctx, false, Culprit);
+    return cast<SubstNonTypeTemplateParmExpr>(this)
+        ->getReplacement()
+        ->isConstantInitializer(Ctx, false, Culprit);
   case CXXDefaultArgExprClass:
-    return cast<CXXDefaultArgExpr>(this)->getExpr()
-      ->isConstantInitializer(Ctx, false, Culprit);
+    return cast<CXXDefaultArgExpr>(this)->getExpr()->isConstantInitializer(
+        Ctx, false, Culprit);
   case CXXDefaultInitExprClass:
-    return cast<CXXDefaultInitExpr>(this)->getExpr()
-      ->isConstantInitializer(Ctx, false, Culprit);
+    return cast<CXXDefaultInitExpr>(this)->getExpr()->isConstantInitializer(
+        Ctx, false, Culprit);
   }
   // Allow certain forms of UB in constant initializers: signed integer
   // overflow and floating-point division by zero. We'll give a warning on
@@ -3335,61 +3470,60 @@
   return false;
 }
 
-bool CallExpr::isBuiltinAssumeFalse(const ASTContext &Ctx) const {
-  const FunctionDecl* FD = getDirectCallee();
+bool CallExpr::isBuiltinAssumeFalse(ASTContext const &Ctx) const {
+  FunctionDecl const *FD = getDirectCallee();
   if (!FD || (FD->getBuiltinID() != Builtin::BI__assume &&
               FD->getBuiltinID() != Builtin::BI__builtin_assume))
     return false;
 
-  const Expr* Arg = getArg(0);
+  Expr const *Arg = getArg(0);
   bool ArgVal;
   return !Arg->isValueDependent() &&
          Arg->EvaluateAsBooleanCondition(ArgVal, Ctx) && !ArgVal;
 }
 
 namespace {
-  /// Look for any side effects within a Stmt.
-  class SideEffectFinder : public ConstEvaluatedExprVisitor<SideEffectFinder> {
-    typedef ConstEvaluatedExprVisitor<SideEffectFinder> Inherited;
-    const bool IncludePossibleEffects;
-    bool HasSideEffects;
-
-  public:
-    explicit SideEffectFinder(const ASTContext &Context, bool IncludePossible)
-      : Inherited(Context),
-        IncludePossibleEffects(IncludePossible), HasSideEffects(false) { }
-
-    bool hasSideEffects() const { return HasSideEffects; }
-
-    void VisitDecl(const Decl *D) {
-      if (!D)
-        return;
-
-      // We assume the caller checks subexpressions (eg, the initializer, VLA
-      // bounds) for side-effects on our behalf.
-      if (auto *VD = dyn_cast<VarDecl>(D)) {
-        // Registering a destructor is a side-effect.
-        if (IncludePossibleEffects && VD->isThisDeclarationADefinition() &&
-            VD->needsDestruction(Context))
-          HasSideEffects = true;
-      }
+/// Look for any side effects within a Stmt.
+class SideEffectFinder : public ConstEvaluatedExprVisitor<SideEffectFinder> {
+  typedef ConstEvaluatedExprVisitor<SideEffectFinder> Inherited;
+  bool const IncludePossibleEffects;
+  bool HasSideEffects;
+
+public:
+  explicit SideEffectFinder(ASTContext const &Context, bool IncludePossible)
+      : Inherited(Context), IncludePossibleEffects(IncludePossible),
+        HasSideEffects(false) {}
+
+  bool hasSideEffects() const { return HasSideEffects; }
+
+  void VisitDecl(Decl const *D) {
+    if (!D)
+      return;
+
+    // We assume the caller checks subexpressions (eg, the initializer, VLA
+    // bounds) for side-effects on our behalf.
+    if (auto *VD = dyn_cast<VarDecl>(D)) {
+      // Registering a destructor is a side-effect.
+      if (IncludePossibleEffects && VD->isThisDeclarationADefinition() &&
+          VD->needsDestruction(Context))
+        HasSideEffects = true;
     }
+  }
 
-    void VisitDeclStmt(const DeclStmt *DS) {
-      for (auto *D : DS->decls())
-        VisitDecl(D);
-      Inherited::VisitDeclStmt(DS);
-    }
+  void VisitDeclStmt(DeclStmt const *DS) {
+    for (auto *D : DS->decls())
+      VisitDecl(D);
+    Inherited::VisitDeclStmt(DS);
+  }
 
-    void VisitExpr(const Expr *E) {
-      if (!HasSideEffects &&
-          E->HasSideEffects(Context, IncludePossibleEffects))
-        HasSideEffects = true;
-    }
-  };
-}
+  void VisitExpr(Expr const *E) {
+    if (!HasSideEffects && E->HasSideEffects(Context, IncludePossibleEffects))
+      HasSideEffects = true;
+  }
+};
+} // namespace
 
-bool Expr::HasSideEffects(const ASTContext &Ctx,
+bool Expr::HasSideEffects(ASTContext const &Ctx,
                           bool IncludePossibleEffects) const {
   // In circumstances where we care about definite side effects instead of
   // potential side effects, we want to ignore expressions that are part of a
@@ -3399,10 +3533,10 @@
 
   switch (getStmtClass()) {
   case NoStmtClass:
-  #define ABSTRACT_STMT(Type)
-  #define STMT(Type, Base) case Type##Class:
-  #define EXPR(Type, Base)
-  #include "clang/AST/StmtNodes.inc"
+#define ABSTRACT_STMT(Type)
+#define STMT(Type, Base) case Type##Class:
+#define EXPR(Type, Base)
+#include "clang/AST/StmtNodes.inc"
     llvm_unreachable("unexpected Expr kind");
 
   case DependentScopeDeclRefExprClass:
@@ -3470,7 +3604,7 @@
     // We don't know a call definitely has side effects, except for calls
     // to pure/const functions that definitely don't.
     // If the call itself is considered side-effect free, check the operands.
-    const Decl *FD = cast<CallExpr>(this)->getCalleeDecl();
+    Decl const *FD = cast<CallExpr>(this)->getCalleeDecl();
     bool IsPure = FD && (FD->hasAttr<ConstAttr>() || FD->hasAttr<PureAttr>());
     if (IsPure || !IncludePossibleEffects)
       break;
@@ -3548,14 +3682,14 @@
 
   case InitListExprClass:
     // FIXME: The children for an InitListExpr doesn't include the array filler.
-    if (const Expr *E = cast<InitListExpr>(this)->getArrayFiller())
+    if (Expr const *E = cast<InitListExpr>(this)->getArrayFiller())
       if (E->HasSideEffects(Ctx, IncludePossibleEffects))
         return true;
     break;
 
   case GenericSelectionExprClass:
-    return cast<GenericSelectionExpr>(this)->getResultExpr()->
-        HasSideEffects(Ctx, IncludePossibleEffects);
+    return cast<GenericSelectionExpr>(this)->getResultExpr()->HasSideEffects(
+        Ctx, IncludePossibleEffects);
 
   case ChooseExprClass:
     return cast<ChooseExpr>(this)->getChosenSubExpr()->HasSideEffects(
@@ -3566,8 +3700,8 @@
         Ctx, IncludePossibleEffects);
 
   case CXXDefaultInitExprClass: {
-    const FieldDecl *FD = cast<CXXDefaultInitExpr>(this)->getField();
-    if (const Expr *E = FD->getInClassInitializer())
+    FieldDecl const *FD = cast<CXXDefaultInitExpr>(this)->getField();
+    if (Expr const *E = FD->getInClassInitializer())
       return E->HasSideEffects(Ctx, IncludePossibleEffects);
     // If we've not yet parsed the initializer, assume it has side-effects.
     return true;
@@ -3575,11 +3709,11 @@
 
   case CXXDynamicCastExprClass: {
     // A dynamic_cast expression has side-effects if it can throw.
-    const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(this);
+    CXXDynamicCastExpr const *DCE = cast<CXXDynamicCastExpr>(this);
     if (DCE->getTypeAsWritten()->isReferenceType() &&
         DCE->getCastKind() == CK_Dynamic)
       return true;
-    }
+  }
     LLVM_FALLTHROUGH;
   case ImplicitCastExprClass:
   case CStyleCastExprClass:
@@ -3596,7 +3730,7 @@
     if (!IncludePossibleEffects)
       break;
 
-    const CastExpr *CE = cast<CastExpr>(this);
+    CastExpr const *CE = cast<CastExpr>(this);
     if (CE->getCastKind() == CK_LValueToRValue &&
         CE->getSubExpr()->getType().isVolatileQualified())
       return true;
@@ -3610,7 +3744,7 @@
 
   case CXXConstructExprClass:
   case CXXTemporaryObjectExprClass: {
-    const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
+    CXXConstructExpr const *CE = cast<CXXConstructExpr>(this);
     if (!CE->getConstructor()->isTrivial() && IncludePossibleEffects)
       return true;
     // A trivial constructor does not add any side-effects of its own. Just look
@@ -3619,14 +3753,14 @@
   }
 
   case CXXInheritedCtorInitExprClass: {
-    const auto *ICIE = cast<CXXInheritedCtorInitExpr>(this);
+    auto const *ICIE = cast<CXXInheritedCtorInitExpr>(this);
     if (!ICIE->getConstructor()->isTrivial() && IncludePossibleEffects)
       return true;
     break;
   }
 
   case LambdaExprClass: {
-    const LambdaExpr *LE = cast<LambdaExpr>(this);
+    LambdaExpr const *LE = cast<LambdaExpr>(this);
     for (Expr *E : LE->capture_inits())
       if (E && E->HasSideEffects(Ctx, IncludePossibleEffects))
         return true;
@@ -3636,12 +3770,12 @@
   case PseudoObjectExprClass: {
     // Only look for side-effects in the semantic form, and look past
     // OpaqueValueExpr bindings in that form.
-    const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this);
+    PseudoObjectExpr const *PO = cast<PseudoObjectExpr>(this);
     for (PseudoObjectExpr::const_semantics_iterator I = PO->semantics_begin(),
                                                     E = PO->semantics_end();
          I != E; ++I) {
-      const Expr *Subexpr = *I;
-      if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Subexpr))
+      Expr const *Subexpr = *I;
+      if (OpaqueValueExpr const *OVE = dyn_cast<OpaqueValueExpr>(Subexpr))
         Subexpr = OVE->getSourceExpr();
       if (Subexpr->HasSideEffects(Ctx, IncludePossibleEffects))
         return true;
@@ -3660,14 +3794,14 @@
   case ObjCBridgedCastExprClass:
   case ObjCMessageExprClass:
   case ObjCPropertyRefExprClass:
-  // FIXME: Classify these cases better.
+    // FIXME: Classify these cases better.
     if (IncludePossibleEffects)
       return true;
     break;
   }
 
   // Recurse to children.
-  for (const Stmt *SubStmt : children())
+  for (Stmt const *SubStmt : children())
     if (SubStmt &&
         cast<Expr>(SubStmt)->HasSideEffects(Ctx, IncludePossibleEffects))
       return true;
@@ -3675,7 +3809,7 @@
   return false;
 }
 
-FPOptions Expr::getFPFeaturesInEffect(const LangOptions &LO) const {
+FPOptions Expr::getFPFeaturesInEffect(LangOptions const &LO) const {
   if (auto Call = dyn_cast<CallExpr>(this))
     return Call->getFPFeaturesInEffect(LO);
   if (auto UO = dyn_cast<UnaryOperator>(this))
@@ -3688,54 +3822,54 @@
 }
 
 namespace {
-  /// Look for a call to a non-trivial function within an expression.
-  class NonTrivialCallFinder : public ConstEvaluatedExprVisitor<NonTrivialCallFinder>
-  {
-    typedef ConstEvaluatedExprVisitor<NonTrivialCallFinder> Inherited;
-
-    bool NonTrivial;
-
-  public:
-    explicit NonTrivialCallFinder(const ASTContext &Context)
-      : Inherited(Context), NonTrivial(false) { }
-
-    bool hasNonTrivialCall() const { return NonTrivial; }
-
-    void VisitCallExpr(const CallExpr *E) {
-      if (const CXXMethodDecl *Method
-          = dyn_cast_or_null<const CXXMethodDecl>(E->getCalleeDecl())) {
-        if (Method->isTrivial()) {
-          // Recurse to children of the call.
-          Inherited::VisitStmt(E);
-          return;
-        }
-      }
+/// Look for a call to a non-trivial function within an expression.
+class NonTrivialCallFinder
+    : public ConstEvaluatedExprVisitor<NonTrivialCallFinder> {
+  typedef ConstEvaluatedExprVisitor<NonTrivialCallFinder> Inherited;
 
-      NonTrivial = true;
-    }
+  bool NonTrivial;
+
+public:
+  explicit NonTrivialCallFinder(ASTContext const &Context)
+      : Inherited(Context), NonTrivial(false) {}
+
+  bool hasNonTrivialCall() const { return NonTrivial; }
 
-    void VisitCXXConstructExpr(const CXXConstructExpr *E) {
-      if (E->getConstructor()->isTrivial()) {
+  void VisitCallExpr(CallExpr const *E) {
+    if (CXXMethodDecl const *Method =
+            dyn_cast_or_null<const CXXMethodDecl>(E->getCalleeDecl())) {
+      if (Method->isTrivial()) {
         // Recurse to children of the call.
         Inherited::VisitStmt(E);
         return;
       }
+    }
+
+    NonTrivial = true;
+  }
 
-      NonTrivial = true;
+  void VisitCXXConstructExpr(CXXConstructExpr const *E) {
+    if (E->getConstructor()->isTrivial()) {
+      // Recurse to children of the call.
+      Inherited::VisitStmt(E);
+      return;
     }
 
-    void VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E) {
-      if (E->getTemporary()->getDestructor()->isTrivial()) {
-        Inherited::VisitStmt(E);
-        return;
-      }
+    NonTrivial = true;
+  }
 
-      NonTrivial = true;
+  void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr const *E) {
+    if (E->getTemporary()->getDestructor()->isTrivial()) {
+      Inherited::VisitStmt(E);
+      return;
     }
-  };
-}
 
-bool Expr::hasNonTrivialCall(const ASTContext &Ctx) const {
+    NonTrivial = true;
+  }
+};
+} // namespace
+
+bool Expr::hasNonTrivialCall(ASTContext const &Ctx) const {
   NonTrivialCallFinder Finder(Ctx);
   Finder.Visit(this);
   return Finder.hasNonTrivialCall();
@@ -3769,10 +3903,10 @@
   }
 
   // Strip off a cast to void*, if it exists. Except in C++.
-  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
+  if (ExplicitCastExpr const *CE = dyn_cast<ExplicitCastExpr>(this)) {
     if (!Ctx.getLangOpts().CPlusPlus) {
       // Check that it is a cast to void*.
-      if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
+      if (PointerType const *PT = CE->getType()->getAs<PointerType>()) {
         QualType Pointee = PT->getPointeeType();
         Qualifiers Qs = Pointee.getQualifiers();
         // Only (void*)0 or equivalent are treated as nullptr. If pointee type
@@ -3786,43 +3920,43 @@
              Pointee.getAddressSpace() == LangAS::opencl_private))
           Qs.removeAddressSpace();
 
-        if (Pointee->isVoidType() && Qs.empty() && // to void*
+        if (Pointee->isVoidType() && Qs.empty() &&        // to void*
             CE->getSubExpr()->getType()->isIntegerType()) // from int
           return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
       }
     }
-  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
+  } else if (ImplicitCastExpr const *ICE = dyn_cast<ImplicitCastExpr>(this)) {
     // Ignore the ImplicitCastExpr type entirely.
     return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
-  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
+  } else if (ParenExpr const *PE = dyn_cast<ParenExpr>(this)) {
     // Accept ((void*)0) as a null pointer constant, as many other
     // implementations do.
     return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
-  } else if (const GenericSelectionExpr *GE =
-               dyn_cast<GenericSelectionExpr>(this)) {
+  } else if (GenericSelectionExpr const *GE =
+                 dyn_cast<GenericSelectionExpr>(this)) {
     if (GE->isResultDependent())
       return NPCK_NotNull;
     return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
-  } else if (const ChooseExpr *CE = dyn_cast<ChooseExpr>(this)) {
+  } else if (ChooseExpr const *CE = dyn_cast<ChooseExpr>(this)) {
     if (CE->isConditionDependent())
       return NPCK_NotNull;
     return CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC);
-  } else if (const CXXDefaultArgExpr *DefaultArg
-               = dyn_cast<CXXDefaultArgExpr>(this)) {
+  } else if (CXXDefaultArgExpr const *DefaultArg =
+                 dyn_cast<CXXDefaultArgExpr>(this)) {
     // See through default argument expressions.
     return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
-  } else if (const CXXDefaultInitExpr *DefaultInit
-               = dyn_cast<CXXDefaultInitExpr>(this)) {
+  } else if (CXXDefaultInitExpr const *DefaultInit =
+                 dyn_cast<CXXDefaultInitExpr>(this)) {
     // See through default initializer expressions.
     return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC);
   } else if (isa<GNUNullExpr>(this)) {
     // The GNU __null extension is always a null pointer constant.
     return NPCK_GNUNull;
-  } else if (const MaterializeTemporaryExpr *M
-                                   = dyn_cast<MaterializeTemporaryExpr>(this)) {
+  } else if (MaterializeTemporaryExpr const *M =
+                 dyn_cast<MaterializeTemporaryExpr>(this)) {
     return M->getSubExpr()->isNullPointerConstant(Ctx, NPC);
-  } else if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(this)) {
-    if (const Expr *Source = OVE->getSourceExpr())
+  } else if (OpaqueValueExpr const *OVE = dyn_cast<OpaqueValueExpr>(this)) {
+    if (Expr const *Source = OVE->getSourceExpr())
       return Source->isNullPointerConstant(Ctx, NPC);
   }
 
@@ -3835,12 +3969,13 @@
   if (getType()->isNullPtrType())
     return NPCK_CXX11_nullptr;
 
-  if (const RecordType *UT = getType()->getAsUnionType())
-    if (!Ctx.getLangOpts().CPlusPlus11 &&
-        UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
-      if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){
-        const Expr *InitExpr = CLE->getInitializer();
-        if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
+  if (RecordType const *UT = getType()->getAsUnionType())
+    if (!Ctx.getLangOpts().CPlusPlus11 && UT &&
+        UT->getDecl()->hasAttr<TransparentUnionAttr>())
+      if (CompoundLiteralExpr const *CLE =
+              dyn_cast<CompoundLiteralExpr>(this)) {
+        Expr const *InitExpr = CLE->getInitializer();
+        if (InitListExpr const *ILE = dyn_cast<InitListExpr>(InitExpr))
           return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC);
       }
   // This expression must be an integer type.
@@ -3852,7 +3987,7 @@
     // C++11 [conv.ptr]p1: A null pointer constant is an integer literal with
     // value zero or a prvalue of type std::nullptr_t.
     // Microsoft mode permits C++98 rules reflecting MSVC behavior.
-    const IntegerLiteral *Lit = dyn_cast<IntegerLiteral>(this);
+    IntegerLiteral const *Lit = dyn_cast<IntegerLiteral>(this);
     if (Lit && !Lit->getValue())
       return NPCK_ZeroLiteral;
     if (!Ctx.getLangOpts().MSVCCompat || !isCXX98IntegralConstantExpr(Ctx))
@@ -3874,13 +4009,13 @@
 
 /// If this expression is an l-value for an Objective C
 /// property, find the underlying property reference expression.
-const ObjCPropertyRefExpr *Expr::getObjCProperty() const {
-  const Expr *E = this;
+ObjCPropertyRefExpr const *Expr::getObjCProperty() const {
+  Expr const *E = this;
   while (true) {
     assert((E->isLValue() && E->getObjectKind() == OK_ObjCProperty) &&
            "expression is not a property reference");
     E = E->IgnoreParenCasts();
-    if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
+    if (BinaryOperator const *BO = dyn_cast<BinaryOperator>(E)) {
       if (BO->getOpcode() == BO_Comma) {
         E = BO->getRHS();
         continue;
@@ -3894,17 +4029,17 @@
 }
 
 bool Expr::isObjCSelfExpr() const {
-  const Expr *E = IgnoreParenImpCasts();
+  Expr const *E = IgnoreParenImpCasts();
 
-  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
+  DeclRefExpr const *DRE = dyn_cast<DeclRefExpr>(E);
   if (!DRE)
     return false;
 
-  const ImplicitParamDecl *Param = dyn_cast<ImplicitParamDecl>(DRE->getDecl());
+  ImplicitParamDecl const *Param = dyn_cast<ImplicitParamDecl>(DRE->getDecl());
   if (!Param)
     return false;
 
-  const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(Param->getDeclContext());
+  ObjCMethodDecl const *M = dyn_cast<ObjCMethodDecl>(Param->getDeclContext());
   if (!M)
     return false;
 
@@ -3960,16 +4095,16 @@
 
 bool Expr::refersToVectorElement() const {
   // FIXME: Why do we not just look at the ObjectKind here?
-  const Expr *E = this->IgnoreParens();
+  Expr const *E = this->IgnoreParens();
 
-  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+  while (ImplicitCastExpr const *ICE = dyn_cast<ImplicitCastExpr>(E)) {
     if (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp)
       E = ICE->getSubExpr()->IgnoreParens();
     else
       break;
   }
 
-  if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
+  if (ArraySubscriptExpr const *ASE = dyn_cast<ArraySubscriptExpr>(E))
     return ASE->getBase()->getType()->isVectorType();
 
   if (isa<ExtVectorElementExpr>(E))
@@ -3984,18 +4119,18 @@
 }
 
 bool Expr::refersToGlobalRegisterVar() const {
-  const Expr *E = this->IgnoreParenImpCasts();
+  Expr const *E = this->IgnoreParenImpCasts();
 
-  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
-    if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
-      if (VD->getStorageClass() == SC_Register &&
-          VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
+  if (DeclRefExpr const *DRE = dyn_cast<DeclRefExpr>(E))
+    if (auto const *VD = dyn_cast<VarDecl>(DRE->getDecl()))
+      if (VD->getStorageClass() == SC_Register && VD->hasAttr<AsmLabelAttr>() &&
+          !VD->isLocalVarDecl())
         return true;
 
   return false;
 }
 
-bool Expr::isSameComparisonOperand(const Expr* E1, const Expr* E2) {
+bool Expr::isSameComparisonOperand(Expr const *E1, Expr const *E2) {
   E1 = E1->IgnoreParens();
   E2 = E2->IgnoreParens();
 
@@ -4003,101 +4138,101 @@
     return false;
 
   switch (E1->getStmtClass()) {
-    default:
-      return false;
-    case CXXThisExprClass:
-      return true;
-    case DeclRefExprClass: {
-      // DeclRefExpr without an ImplicitCastExpr can happen for integral
-      // template parameters.
-      const auto *DRE1 = cast<DeclRefExpr>(E1);
-      const auto *DRE2 = cast<DeclRefExpr>(E2);
-      return DRE1->isPRValue() && DRE2->isPRValue() &&
-             DRE1->getDecl() == DRE2->getDecl();
-    }
-    case ImplicitCastExprClass: {
-      // Peel off implicit casts.
-      while (true) {
-        const auto *ICE1 = dyn_cast<ImplicitCastExpr>(E1);
-        const auto *ICE2 = dyn_cast<ImplicitCastExpr>(E2);
-        if (!ICE1 || !ICE2)
-          return false;
-        if (ICE1->getCastKind() != ICE2->getCastKind())
-          return false;
-        E1 = ICE1->getSubExpr()->IgnoreParens();
-        E2 = ICE2->getSubExpr()->IgnoreParens();
-        // The final cast must be one of these types.
-        if (ICE1->getCastKind() == CK_LValueToRValue ||
-            ICE1->getCastKind() == CK_ArrayToPointerDecay ||
-            ICE1->getCastKind() == CK_FunctionToPointerDecay) {
-          break;
-        }
-      }
-
-      const auto *DRE1 = dyn_cast<DeclRefExpr>(E1);
-      const auto *DRE2 = dyn_cast<DeclRefExpr>(E2);
-      if (DRE1 && DRE2)
-        return declaresSameEntity(DRE1->getDecl(), DRE2->getDecl());
-
-      const auto *Ivar1 = dyn_cast<ObjCIvarRefExpr>(E1);
-      const auto *Ivar2 = dyn_cast<ObjCIvarRefExpr>(E2);
-      if (Ivar1 && Ivar2) {
-        return Ivar1->isFreeIvar() && Ivar2->isFreeIvar() &&
-               declaresSameEntity(Ivar1->getDecl(), Ivar2->getDecl());
+  default:
+    return false;
+  case CXXThisExprClass:
+    return true;
+  case DeclRefExprClass: {
+    // DeclRefExpr without an ImplicitCastExpr can happen for integral
+    // template parameters.
+    auto const *DRE1 = cast<DeclRefExpr>(E1);
+    auto const *DRE2 = cast<DeclRefExpr>(E2);
+    return DRE1->isPRValue() && DRE2->isPRValue() &&
+           DRE1->getDecl() == DRE2->getDecl();
+  }
+  case ImplicitCastExprClass: {
+    // Peel off implicit casts.
+    while (true) {
+      auto const *ICE1 = dyn_cast<ImplicitCastExpr>(E1);
+      auto const *ICE2 = dyn_cast<ImplicitCastExpr>(E2);
+      if (!ICE1 || !ICE2)
+        return false;
+      if (ICE1->getCastKind() != ICE2->getCastKind())
+        return false;
+      E1 = ICE1->getSubExpr()->IgnoreParens();
+      E2 = ICE2->getSubExpr()->IgnoreParens();
+      // The final cast must be one of these types.
+      if (ICE1->getCastKind() == CK_LValueToRValue ||
+          ICE1->getCastKind() == CK_ArrayToPointerDecay ||
+          ICE1->getCastKind() == CK_FunctionToPointerDecay) {
+        break;
       }
+    }
 
-      const auto *Array1 = dyn_cast<ArraySubscriptExpr>(E1);
-      const auto *Array2 = dyn_cast<ArraySubscriptExpr>(E2);
-      if (Array1 && Array2) {
-        if (!isSameComparisonOperand(Array1->getBase(), Array2->getBase()))
-          return false;
+    auto const *DRE1 = dyn_cast<DeclRefExpr>(E1);
+    auto const *DRE2 = dyn_cast<DeclRefExpr>(E2);
+    if (DRE1 && DRE2)
+      return declaresSameEntity(DRE1->getDecl(), DRE2->getDecl());
 
-        auto Idx1 = Array1->getIdx();
-        auto Idx2 = Array2->getIdx();
-        const auto Integer1 = dyn_cast<IntegerLiteral>(Idx1);
-        const auto Integer2 = dyn_cast<IntegerLiteral>(Idx2);
-        if (Integer1 && Integer2) {
-          if (!llvm::APInt::isSameValue(Integer1->getValue(),
-                                        Integer2->getValue()))
-            return false;
-        } else {
-          if (!isSameComparisonOperand(Idx1, Idx2))
-            return false;
-        }
+    auto const *Ivar1 = dyn_cast<ObjCIvarRefExpr>(E1);
+    auto const *Ivar2 = dyn_cast<ObjCIvarRefExpr>(E2);
+    if (Ivar1 && Ivar2) {
+      return Ivar1->isFreeIvar() && Ivar2->isFreeIvar() &&
+             declaresSameEntity(Ivar1->getDecl(), Ivar2->getDecl());
+    }
 
-        return true;
-      }
+    auto const *Array1 = dyn_cast<ArraySubscriptExpr>(E1);
+    auto const *Array2 = dyn_cast<ArraySubscriptExpr>(E2);
+    if (Array1 && Array2) {
+      if (!isSameComparisonOperand(Array1->getBase(), Array2->getBase()))
+        return false;
 
-      // Walk the MemberExpr chain.
-      while (isa<MemberExpr>(E1) && isa<MemberExpr>(E2)) {
-        const auto *ME1 = cast<MemberExpr>(E1);
-        const auto *ME2 = cast<MemberExpr>(E2);
-        if (!declaresSameEntity(ME1->getMemberDecl(), ME2->getMemberDecl()))
+      auto Idx1 = Array1->getIdx();
+      auto Idx2 = Array2->getIdx();
+      auto const Integer1 = dyn_cast<IntegerLiteral>(Idx1);
+      auto const Integer2 = dyn_cast<IntegerLiteral>(Idx2);
+      if (Integer1 && Integer2) {
+        if (!llvm::APInt::isSameValue(Integer1->getValue(),
+                                      Integer2->getValue()))
+          return false;
+      } else {
+        if (!isSameComparisonOperand(Idx1, Idx2))
           return false;
-        if (const auto *D = dyn_cast<VarDecl>(ME1->getMemberDecl()))
-          if (D->isStaticDataMember())
-            return true;
-        E1 = ME1->getBase()->IgnoreParenImpCasts();
-        E2 = ME2->getBase()->IgnoreParenImpCasts();
       }
 
-      if (isa<CXXThisExpr>(E1) && isa<CXXThisExpr>(E2))
-        return true;
+      return true;
+    }
 
-      // A static member variable can end the MemberExpr chain with either
-      // a MemberExpr or a DeclRefExpr.
-      auto getAnyDecl = [](const Expr *E) -> const ValueDecl * {
-        if (const auto *DRE = dyn_cast<DeclRefExpr>(E))
-          return DRE->getDecl();
-        if (const auto *ME = dyn_cast<MemberExpr>(E))
-          return ME->getMemberDecl();
-        return nullptr;
-      };
-
-      const ValueDecl *VD1 = getAnyDecl(E1);
-      const ValueDecl *VD2 = getAnyDecl(E2);
-      return declaresSameEntity(VD1, VD2);
+    // Walk the MemberExpr chain.
+    while (isa<MemberExpr>(E1) && isa<MemberExpr>(E2)) {
+      auto const *ME1 = cast<MemberExpr>(E1);
+      auto const *ME2 = cast<MemberExpr>(E2);
+      if (!declaresSameEntity(ME1->getMemberDecl(), ME2->getMemberDecl()))
+        return false;
+      if (auto const *D = dyn_cast<VarDecl>(ME1->getMemberDecl()))
+        if (D->isStaticDataMember())
+          return true;
+      E1 = ME1->getBase()->IgnoreParenImpCasts();
+      E2 = ME2->getBase()->IgnoreParenImpCasts();
     }
+
+    if (isa<CXXThisExpr>(E1) && isa<CXXThisExpr>(E2))
+      return true;
+
+    // A static member variable can end the MemberExpr chain with either
+    // a MemberExpr or a DeclRefExpr.
+    auto getAnyDecl = [](Expr const *E) -> ValueDecl const * {
+      if (const auto *DRE = dyn_cast<DeclRefExpr>(E))
+        return DRE->getDecl();
+      if (const auto *ME = dyn_cast<MemberExpr>(E))
+        return ME->getMemberDecl();
+      return nullptr;
+    };
+
+    ValueDecl const *VD1 = getAnyDecl(E1);
+    ValueDecl const *VD2 = getAnyDecl(E2);
+    return declaresSameEntity(VD1, VD2);
+  }
   }
 }
 
@@ -4108,7 +4243,7 @@
 }
 
 unsigned ExtVectorElementExpr::getNumElements() const {
-  if (const VectorType *VT = getType()->getAs<VectorType>())
+  if (VectorType const *VT = getType()->getAs<VectorType>())
     return VT->getNumElements();
   return 1;
 }
@@ -4129,7 +4264,7 @@
 
   for (unsigned i = 0, e = Comp.size(); i != e; ++i)
     if (Comp.substr(i + 1).find(Comp[i]) != StringRef::npos)
-        return true;
+      return true;
 
   return false;
 }
@@ -4144,10 +4279,10 @@
     isNumericAccessor = true;
   }
 
-  bool isHi =   Comp == "hi";
-  bool isLo =   Comp == "lo";
+  bool isHi = Comp == "hi";
+  bool isLo = Comp == "lo";
   bool isEven = Comp == "even";
-  bool isOdd  = Comp == "odd";
+  bool isOdd = Comp == "odd";
 
   for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
     uint64_t Index;
@@ -4167,28 +4302,29 @@
   }
 }
 
-ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr *> args,
+ShuffleVectorExpr::ShuffleVectorExpr(ASTContext const &C, ArrayRef<Expr *> args,
                                      QualType Type, SourceLocation BLoc,
                                      SourceLocation RP)
     : Expr(ShuffleVectorExprClass, Type, VK_PRValue, OK_Ordinary),
       BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {
-  SubExprs = new (C) Stmt*[args.size()];
+  SubExprs = new (C) Stmt *[args.size()];
   for (unsigned i = 0; i != args.size(); i++)
     SubExprs[i] = args[i];
 
   setDependence(computeDependence(this));
 }
 
-void ShuffleVectorExpr::setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs) {
-  if (SubExprs) C.Deallocate(SubExprs);
+void ShuffleVectorExpr::setExprs(ASTContext const &C, ArrayRef<Expr *> Exprs) {
+  if (SubExprs)
+    C.Deallocate(SubExprs);
 
   this->NumExprs = Exprs.size();
-  SubExprs = new (C) Stmt*[NumExprs];
+  SubExprs = new (C) Stmt *[NumExprs];
   memcpy(SubExprs, Exprs.data(), sizeof(Expr *) * Exprs.size());
 }
 
 GenericSelectionExpr::GenericSelectionExpr(
-    const ASTContext &, SourceLocation GenericLoc, Expr *ControllingExpr,
+    ASTContext const &, SourceLocation GenericLoc, Expr *ControllingExpr,
     ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
     SourceLocation DefaultLoc, SourceLocation RParenLoc,
     bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
@@ -4213,7 +4349,7 @@
 }
 
 GenericSelectionExpr::GenericSelectionExpr(
-    const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
+    ASTContext const &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
     ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
     SourceLocation DefaultLoc, SourceLocation RParenLoc,
     bool ContainsUnexpandedParameterPack)
@@ -4239,7 +4375,7 @@
     : Expr(GenericSelectionExprClass, Empty), NumAssocs(NumAssocs) {}
 
 GenericSelectionExpr *GenericSelectionExpr::Create(
-    const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
+    ASTContext const &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
     ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
     SourceLocation DefaultLoc, SourceLocation RParenLoc,
     bool ContainsUnexpandedParameterPack, unsigned ResultIndex) {
@@ -4253,7 +4389,7 @@
 }
 
 GenericSelectionExpr *GenericSelectionExpr::Create(
-    const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
+    ASTContext const &Context, SourceLocation GenericLoc, Expr *ControllingExpr,
     ArrayRef<TypeSourceInfo *> AssocTypes, ArrayRef<Expr *> AssocExprs,
     SourceLocation DefaultLoc, SourceLocation RParenLoc,
     bool ContainsUnexpandedParameterPack) {
@@ -4267,7 +4403,7 @@
 }
 
 GenericSelectionExpr *
-GenericSelectionExpr::CreateEmpty(const ASTContext &Context,
+GenericSelectionExpr::CreateEmpty(ASTContext const &Context,
                                   unsigned NumAssocs) {
   void *Mem = Context.Allocate(
       totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
@@ -4286,7 +4422,7 @@
   return getField()->getIdentifier();
 }
 
-DesignatedInitExpr::DesignatedInitExpr(const ASTContext &C, QualType Ty,
+DesignatedInitExpr::DesignatedInitExpr(ASTContext const &C, QualType Ty,
                                        llvm::ArrayRef<Designator> Designators,
                                        SourceLocation EqualOrColonLoc,
                                        bool GNUSyntax,
@@ -4320,28 +4456,25 @@
   setDependence(computeDependence(this));
 }
 
-DesignatedInitExpr *
-DesignatedInitExpr::Create(const ASTContext &C,
-                           llvm::ArrayRef<Designator> Designators,
-                           ArrayRef<Expr*> IndexExprs,
-                           SourceLocation ColonOrEqualLoc,
-                           bool UsesColonSyntax, Expr *Init) {
+DesignatedInitExpr *DesignatedInitExpr::Create(
+    ASTContext const &C, llvm::ArrayRef<Designator> Designators,
+    ArrayRef<Expr *> IndexExprs, SourceLocation ColonOrEqualLoc,
+    bool UsesColonSyntax, Expr *Init) {
   void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),
                          alignof(DesignatedInitExpr));
-  return new (Mem) DesignatedInitExpr(C, C.VoidTy, Designators,
-                                      ColonOrEqualLoc, UsesColonSyntax,
-                                      IndexExprs, Init);
+  return new (Mem) DesignatedInitExpr(C, C.VoidTy, Designators, ColonOrEqualLoc,
+                                      UsesColonSyntax, IndexExprs, Init);
 }
 
-DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(const ASTContext &C,
+DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext const &C,
                                                     unsigned NumIndexExprs) {
   void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),
                          alignof(DesignatedInitExpr));
   return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
 }
 
-void DesignatedInitExpr::setDesignators(const ASTContext &C,
-                                        const Designator *Desigs,
+void DesignatedInitExpr::setDesignators(ASTContext const &C,
+                                        Designator const *Desigs,
                                         unsigned NumDesigs) {
   Designators = new (C) Designator[NumDesigs];
   NumDesignators = NumDesigs;
@@ -4350,7 +4483,7 @@
 }
 
 SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const {
-  DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);
+  DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr *>(this);
   if (size() == 1)
     return DIE->getDesignator(0)->getSourceRange();
   return SourceRange(DIE->getDesignator(0)->getBeginLoc(),
@@ -4372,18 +4505,18 @@
   return getInit()->getEndLoc();
 }
 
-Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) const {
+Expr *DesignatedInitExpr::getArrayIndex(Designator const &D) const {
   assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
   return getSubExpr(D.ArrayOrRange.Index + 1);
 }
 
-Expr *DesignatedInitExpr::getArrayRangeStart(const Designator &D) const {
+Expr *DesignatedInitExpr::getArrayRangeStart(Designator const &D) const {
   assert(D.Kind == Designator::ArrayRangeDesignator &&
          "Requires array range designator");
   return getSubExpr(D.ArrayOrRange.Index + 1);
 }
 
-Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator &D) const {
+Expr *DesignatedInitExpr::getArrayRangeEnd(Designator const &D) const {
   assert(D.Kind == Designator::ArrayRangeDesignator &&
          "Requires array range designator");
   return getSubExpr(D.ArrayOrRange.Index + 2);
@@ -4391,13 +4524,12 @@
 
 /// Replaces the designator at index @p Idx with the series
 /// of designators in [First, Last).
-void DesignatedInitExpr::ExpandDesignator(const ASTContext &C, unsigned Idx,
-                                          const Designator *First,
-                                          const Designator *Last) {
+void DesignatedInitExpr::ExpandDesignator(ASTContext const &C, unsigned Idx,
+                                          Designator const *First,
+                                          Designator const *Last) {
   unsigned NumNewDesignators = Last - First;
   if (NumNewDesignators == 0) {
-    std::copy_backward(Designators + Idx + 1,
-                       Designators + NumDesignators,
+    std::copy_backward(Designators + Idx + 1, Designators + NumDesignators,
                        Designators + Idx);
     --NumNewDesignators;
     return;
@@ -4407,8 +4539,8 @@
     return;
   }
 
-  Designator *NewDesignators
-    = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
+  Designator *NewDesignators =
+      new (C) Designator[NumDesignators - 1 + NumNewDesignators];
   std::copy(Designators, Designators + Idx, NewDesignators);
   std::copy(First, Last, NewDesignators + Idx);
   std::copy(Designators + Idx + 1, Designators + NumDesignators,
@@ -4417,7 +4549,7 @@
   NumDesignators = NumDesignators - 1 + NumNewDesignators;
 }
 
-DesignatedInitUpdateExpr::DesignatedInitUpdateExpr(const ASTContext &C,
+DesignatedInitUpdateExpr::DesignatedInitUpdateExpr(ASTContext const &C,
                                                    SourceLocation lBraceLoc,
                                                    Expr *baseExpr,
                                                    SourceLocation rBraceLoc)
@@ -4457,7 +4589,7 @@
   ParenListExprBits.NumExprs = NumExprs;
 }
 
-ParenListExpr *ParenListExpr::Create(const ASTContext &Ctx,
+ParenListExpr *ParenListExpr::Create(ASTContext const &Ctx,
                                      SourceLocation LParenLoc,
                                      ArrayRef<Expr *> Exprs,
                                      SourceLocation RParenLoc) {
@@ -4466,14 +4598,14 @@
   return new (Mem) ParenListExpr(LParenLoc, Exprs, RParenLoc);
 }
 
-ParenListExpr *ParenListExpr::CreateEmpty(const ASTContext &Ctx,
+ParenListExpr *ParenListExpr::CreateEmpty(ASTContext const &Ctx,
                                           unsigned NumExprs) {
   void *Mem =
       Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumExprs), alignof(ParenListExpr));
   return new (Mem) ParenListExpr(EmptyShell(), NumExprs);
 }
 
-BinaryOperator::BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
+BinaryOperator::BinaryOperator(ASTContext const &Ctx, Expr *lhs, Expr *rhs,
                                Opcode opc, QualType ResTy, ExprValueKind VK,
                                ExprObjectKind OK, SourceLocation opLoc,
                                FPOptionsOverride FPFeatures)
@@ -4490,7 +4622,7 @@
   setDependence(computeDependence(this));
 }
 
-BinaryOperator::BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
+BinaryOperator::BinaryOperator(ASTContext const &Ctx, Expr *lhs, Expr *rhs,
                                Opcode opc, QualType ResTy, ExprValueKind VK,
                                ExprObjectKind OK, SourceLocation opLoc,
                                FPOptionsOverride FPFeatures, bool dead2)
@@ -4507,7 +4639,7 @@
   setDependence(computeDependence(this));
 }
 
-BinaryOperator *BinaryOperator::CreateEmpty(const ASTContext &C,
+BinaryOperator *BinaryOperator::CreateEmpty(ASTContext const &C,
                                             bool HasFPFeatures) {
   unsigned Extra = sizeOfTrailingObjects(HasFPFeatures);
   void *Mem =
@@ -4515,7 +4647,7 @@
   return new (Mem) BinaryOperator(EmptyShell());
 }
 
-BinaryOperator *BinaryOperator::Create(const ASTContext &C, Expr *lhs,
+BinaryOperator *BinaryOperator::Create(ASTContext const &C, Expr *lhs,
                                        Expr *rhs, Opcode opc, QualType ResTy,
                                        ExprValueKind VK, ExprObjectKind OK,
                                        SourceLocation opLoc,
@@ -4529,7 +4661,7 @@
 }
 
 CompoundAssignOperator *
-CompoundAssignOperator::CreateEmpty(const ASTContext &C, bool HasFPFeatures) {
+CompoundAssignOperator::CreateEmpty(ASTContext const &C, bool HasFPFeatures) {
   unsigned Extra = sizeOfTrailingObjects(HasFPFeatures);
   void *Mem = C.Allocate(sizeof(CompoundAssignOperator) + Extra,
                          alignof(CompoundAssignOperator));
@@ -4537,7 +4669,7 @@
 }
 
 CompoundAssignOperator *
-CompoundAssignOperator::Create(const ASTContext &C, Expr *lhs, Expr *rhs,
+CompoundAssignOperator::Create(ASTContext const &C, Expr *lhs, Expr *rhs,
                                Opcode opc, QualType ResTy, ExprValueKind VK,
                                ExprObjectKind OK, SourceLocation opLoc,
                                FPOptionsOverride FPFeatures,
@@ -4551,14 +4683,14 @@
                              CompLHSType, CompResultType);
 }
 
-UnaryOperator *UnaryOperator::CreateEmpty(const ASTContext &C,
+UnaryOperator *UnaryOperator::CreateEmpty(ASTContext const &C,
                                           bool hasFPFeatures) {
   void *Mem = C.Allocate(totalSizeToAlloc<FPOptionsOverride>(hasFPFeatures),
                          alignof(UnaryOperator));
   return new (Mem) UnaryOperator(hasFPFeatures, EmptyShell());
 }
 
-UnaryOperator::UnaryOperator(const ASTContext &Ctx, Expr *input, Opcode opc,
+UnaryOperator::UnaryOperator(ASTContext const &Ctx, Expr *input, Opcode opc,
                              QualType type, ExprValueKind VK, ExprObjectKind OK,
                              SourceLocation l, bool CanOverflow,
                              FPOptionsOverride FPFeatures)
@@ -4572,7 +4704,7 @@
   setDependence(computeDependence(this, Ctx));
 }
 
-UnaryOperator *UnaryOperator::Create(const ASTContext &C, Expr *input,
+UnaryOperator *UnaryOperator::Create(ASTContext const &C, Expr *input,
                                      Opcode opc, QualType type,
                                      ExprValueKind VK, ExprObjectKind OK,
                                      SourceLocation l, bool CanOverflow,
@@ -4584,33 +4716,33 @@
       UnaryOperator(C, input, opc, type, VK, OK, l, CanOverflow, FPFeatures);
 }
 
-const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) {
-  if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e))
+OpaqueValueExpr const *OpaqueValueExpr::findInCopyConstruct(Expr const *e) {
+  if (ExprWithCleanups const *ewc = dyn_cast<ExprWithCleanups>(e))
     e = ewc->getSubExpr();
-  if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e))
+  if (MaterializeTemporaryExpr const *m = dyn_cast<MaterializeTemporaryExpr>(e))
     e = m->getSubExpr();
   e = cast<CXXConstructExpr>(e)->getArg(0);
-  while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
+  while (ImplicitCastExpr const *ice = dyn_cast<ImplicitCastExpr>(e))
     e = ice->getSubExpr();
   return cast<OpaqueValueExpr>(e);
 }
 
-PseudoObjectExpr *PseudoObjectExpr::Create(const ASTContext &Context,
+PseudoObjectExpr *PseudoObjectExpr::Create(ASTContext const &Context,
                                            EmptyShell sh,
                                            unsigned numSemanticExprs) {
   void *buffer =
       Context.Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),
                        alignof(PseudoObjectExpr));
-  return new(buffer) PseudoObjectExpr(sh, numSemanticExprs);
+  return new (buffer) PseudoObjectExpr(sh, numSemanticExprs);
 }
 
 PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs)
-  : Expr(PseudoObjectExprClass, shell) {
+    : Expr(PseudoObjectExprClass, shell) {
   PseudoObjectExprBits.NumSubExprs = numSemanticExprs + 1;
 }
 
-PseudoObjectExpr *PseudoObjectExpr::Create(const ASTContext &C, Expr *syntax,
-                                           ArrayRef<Expr*> semantics,
+PseudoObjectExpr *PseudoObjectExpr::Create(ASTContext const &C, Expr *syntax,
+                                           ArrayRef<Expr *> semantics,
                                            unsigned resultIndex) {
   assert(syntax && "no syntactic expression!");
   assert(semantics.size() && "no semantic expressions!");
@@ -4629,8 +4761,8 @@
 
   void *buffer = C.Allocate(totalSizeToAlloc<Expr *>(semantics.size() + 1),
                             alignof(PseudoObjectExpr));
-  return new(buffer) PseudoObjectExpr(type, VK, syntax, semantics,
-                                      resultIndex);
+  return new (buffer)
+      PseudoObjectExpr(type, VK, syntax, semantics, resultIndex);
 }
 
 PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK,
@@ -4641,7 +4773,7 @@
   PseudoObjectExprBits.ResultIndex = resultIndex + 1;
 
   for (unsigned i = 0, e = semantics.size() + 1; i != e; ++i) {
-    Expr *E = (i == 0 ? syntax : semantics[i-1]);
+    Expr *E = (i == 0 ? syntax : semantics[i - 1]);
     getSubExprsBuffer()[i] = E;
 
     if (isa<OpaqueValueExpr>(E))
@@ -4660,7 +4792,7 @@
 // UnaryExprOrTypeTraitExpr
 Stmt::child_range UnaryExprOrTypeTraitExpr::children() {
   const_child_range CCR =
-      const_cast<const UnaryExprOrTypeTraitExpr *>(this)->children();
+      const_cast<UnaryExprOrTypeTraitExpr const *>(this)->children();
   return child_range(cast_away_const(CCR.begin()), cast_away_const(CCR.end()));
 }
 
@@ -4669,7 +4801,7 @@
   // size expression of the VLA needs to be treated as an executable expression.
   // Why isn't this weirdness documented better in StmtIterator?
   if (isArgumentType()) {
-    if (const VariableArrayType *T =
+    if (VariableArrayType const *T =
             dyn_cast<VariableArrayType>(getArgumentType().getTypePtr()))
       return const_child_range(const_child_iterator(T), const_child_iterator());
     return const_child_range(const_child_iterator(), const_child_iterator());
@@ -4759,7 +4891,7 @@
   return T;
 }
 
-QualType OMPArraySectionExpr::getBaseOriginalType(const Expr *Base) {
+QualType OMPArraySectionExpr::getBaseOriginalType(Expr const *Base) {
   unsigned ArraySectionCount = 0;
   while (auto *OASE = dyn_cast<OMPArraySectionExpr>(Base->IgnoreParens())) {
     Base = OASE->getBase();
@@ -4780,7 +4912,7 @@
     if (OriginalTy->isAnyPointerType())
       OriginalTy = OriginalTy->getPointeeType();
     else {
-      assert (OriginalTy->isArrayType());
+      assert(OriginalTy->isArrayType());
       OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
     }
   }
@@ -4794,7 +4926,7 @@
            OK_Ordinary),
       BeginLoc(BeginLoc), EndLoc(EndLoc), NumExprs(SubExprs.size()) {
   assert(!T.isNull());
-  assert(llvm::all_of(SubExprs, [](Expr* E) { return E != nullptr; }));
+  assert(llvm::all_of(SubExprs, [](Expr *E) { return E != nullptr; }));
 
   llvm::copy(SubExprs, getTrailingObjects<Expr *>());
   setDependence(computeDependence(this));
@@ -4840,7 +4972,7 @@
 }
 
 OMPArrayShapingExpr *
-OMPArrayShapingExpr::Create(const ASTContext &Context, QualType T, Expr *Op,
+OMPArrayShapingExpr::Create(ASTContext const &Context, QualType T, Expr *Op,
                             SourceLocation L, SourceLocation R,
                             ArrayRef<Expr *> Dims,
                             ArrayRef<SourceRange> BracketRanges) {
@@ -4854,7 +4986,7 @@
   return E;
 }
 
-OMPArrayShapingExpr *OMPArrayShapingExpr::CreateEmpty(const ASTContext &Context,
+OMPArrayShapingExpr *OMPArrayShapingExpr::CreateEmpty(ASTContext const &Context,
                                                       unsigned NumDims) {
   void *Mem = Context.Allocate(
       totalSizeToAlloc<Expr *, SourceRange>(NumDims + 1, NumDims),
@@ -4938,7 +5070,7 @@
                         static_cast<int>(RangeLocOffset::SecondColonLoc)];
 }
 
-void OMPIteratorExpr::setHelper(unsigned I, const OMPIteratorHelperData &D) {
+void OMPIteratorExpr::setHelper(unsigned I, OMPIteratorHelperData const &D) {
   getTrailingObjects<OMPIteratorHelperData>()[I] = D;
 }
 
@@ -4946,7 +5078,7 @@
   return getTrailingObjects<OMPIteratorHelperData>()[I];
 }
 
-const OMPIteratorHelperData &OMPIteratorExpr::getHelper(unsigned I) const {
+OMPIteratorHelperData const &OMPIteratorExpr::getHelper(unsigned I) const {
   return getTrailingObjects<OMPIteratorHelperData>()[I];
 }
 
@@ -4958,7 +5090,7 @@
       IteratorKwLoc(IteratorKwLoc), LPLoc(L), RPLoc(R),
       NumIterators(Data.size()) {
   for (unsigned I = 0, E = Data.size(); I < E; ++I) {
-    const IteratorDefinition &D = Data[I];
+    IteratorDefinition const &D = Data[I];
     setIteratorDeclaration(I, D.IteratorDecl);
     setAssignmentLoc(I, D.AssignmentLoc);
     setIteratorRange(I, D.Range.Begin, D.ColonLoc, D.Range.End,
@@ -4969,7 +5101,7 @@
 }
 
 OMPIteratorExpr *
-OMPIteratorExpr::Create(const ASTContext &Context, QualType T,
+OMPIteratorExpr::Create(ASTContext const &Context, QualType T,
                         SourceLocation IteratorKwLoc, SourceLocation L,
                         SourceLocation R,
                         ArrayRef<OMPIteratorExpr::IteratorDefinition> Data,
@@ -4985,7 +5117,7 @@
   return new (Mem) OMPIteratorExpr(T, IteratorKwLoc, L, R, Data, Helpers);
 }
 
-OMPIteratorExpr *OMPIteratorExpr::CreateEmpty(const ASTContext &Context,
+OMPIteratorExpr *OMPIteratorExpr::CreateEmpty(ASTContext const &Context,
                                               unsigned NumIterators) {
   void *Mem = Context.Allocate(
       totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(
Index: clang/lib/AST/ExprCXX.cpp
===================================================================
--- clang/lib/AST/ExprCXX.cpp
+++ clang/lib/AST/ExprCXX.cpp
@@ -54,7 +54,8 @@
     return false;
 
   switch (getOperator()) {
-  case OO_Call: case OO_Subscript:
+  case OO_Call:
+  case OO_Subscript:
     return false;
   default:
     return true;
@@ -64,7 +65,7 @@
 CXXRewrittenBinaryOperator::DecomposedForm
 CXXRewrittenBinaryOperator::getDecomposedForm() const {
   DecomposedForm Result = {};
-  const Expr *E = getSemanticForm()->IgnoreImplicit();
+  Expr const *E = getSemanticForm()->IgnoreImplicit();
 
   // Remove an outer '!' if it exists (only happens for a '!=' rewrite).
   bool SkippedNot = false;
@@ -85,13 +86,26 @@
     assert(!SkippedNot || BO->getOperator() == OO_EqualEqual);
     assert(BO->isInfixBinaryOp());
     switch (BO->getOperator()) {
-    case OO_Less: Result.Opcode = BO_LT; break;
-    case OO_LessEqual: Result.Opcode = BO_LE; break;
-    case OO_Greater: Result.Opcode = BO_GT; break;
-    case OO_GreaterEqual: Result.Opcode = BO_GE; break;
-    case OO_Spaceship: Result.Opcode = BO_Cmp; break;
-    case OO_EqualEqual: Result.Opcode = SkippedNot ? BO_NE : BO_EQ; break;
-    default: llvm_unreachable("unexpected binop in rewritten operator expr");
+    case OO_Less:
+      Result.Opcode = BO_LT;
+      break;
+    case OO_LessEqual:
+      Result.Opcode = BO_LE;
+      break;
+    case OO_Greater:
+      Result.Opcode = BO_GT;
+      break;
+    case OO_GreaterEqual:
+      Result.Opcode = BO_GE;
+      break;
+    case OO_Spaceship:
+      Result.Opcode = BO_Cmp;
+      break;
+    case OO_EqualEqual:
+      Result.Opcode = SkippedNot ? BO_NE : BO_EQ;
+      break;
+    default:
+      llvm_unreachable("unexpected binop in rewritten operator expr");
     }
     Result.LHS = BO->getArg(0);
     Result.RHS = BO->getArg(1);
@@ -138,8 +152,8 @@
   // C++11 [expr.typeid]p3:
   //   When typeid is applied to an expression other than a glvalue of
   //   polymorphic class type, [...] the expression is an unevaluated operand.
-  const Expr *E = getExprOperand();
-  if (const CXXRecordDecl *RD = E->getType()->getAsCXXRecordDecl())
+  Expr const *E = getExprOperand();
+  if (CXXRecordDecl const *RD = E->getType()->getAsCXXRecordDecl())
     if (RD->isPolymorphic() && E->isGLValue())
       return true;
 
@@ -148,8 +162,8 @@
 
 bool CXXTypeidExpr::isMostDerived(ASTContext &Context) const {
   assert(!isTypeOperand() && "Cannot call isMostDerived for typeid(type)");
-  const Expr *E = getExprOperand()->IgnoreParenNoopCasts(Context);
-  if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
+  Expr const *E = getExprOperand()->IgnoreParenNoopCasts(Context);
+  if (auto const *DRE = dyn_cast<DeclRefExpr>(E)) {
     QualType Ty = DRE->getDecl()->getType();
     if (!Ty->isPointerType() && !Ty->isReferenceType())
       return true;
@@ -240,7 +254,7 @@
 }
 
 CXXNewExpr *
-CXXNewExpr::Create(const ASTContext &Ctx, bool IsGlobalNew,
+CXXNewExpr::Create(ASTContext const &Ctx, bool IsGlobalNew,
                    FunctionDecl *OperatorNew, FunctionDecl *OperatorDelete,
                    bool ShouldPassAlignment, bool UsualArrayDeleteWantsSize,
                    ArrayRef<Expr *> PlacementArgs, SourceRange TypeIdParens,
@@ -263,7 +277,7 @@
                  AllocatedTypeInfo, Range, DirectInitRange);
 }
 
-CXXNewExpr *CXXNewExpr::CreateEmpty(const ASTContext &Ctx, bool IsArray,
+CXXNewExpr *CXXNewExpr::CreateEmpty(ASTContext const &Ctx, bool IsArray,
                                     bool HasInit, unsigned NumPlacementArgs,
                                     bool IsParenTypeId) {
   void *Mem =
@@ -285,12 +299,12 @@
 
 // CXXDeleteExpr
 QualType CXXDeleteExpr::getDestroyedType() const {
-  const Expr *Arg = getArgument();
+  Expr const *Arg = getArgument();
 
   // For a destroying operator delete, we may have implicitly converted the
   // pointer type to the type of the parameter of the 'operator delete'
   // function.
-  while (const auto *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
+  while (auto const *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
     if (ICE->getCastKind() == CK_DerivedToBase ||
         ICE->getCastKind() == CK_UncheckedDerivedToBase ||
         ICE->getCastKind() == CK_NoOp) {
@@ -318,7 +332,7 @@
 }
 
 CXXPseudoDestructorExpr::CXXPseudoDestructorExpr(
-    const ASTContext &Context, Expr *Base, bool isArrow,
+    ASTContext const &Context, Expr *Base, bool isArrow,
     SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
     TypeSourceInfo *ScopeType, SourceLocation ColonColonLoc,
     SourceLocation TildeLoc, PseudoDestructorTypeStorage DestroyedType)
@@ -347,10 +361,10 @@
 
 // UnresolvedLookupExpr
 UnresolvedLookupExpr::UnresolvedLookupExpr(
-    const ASTContext &Context, CXXRecordDecl *NamingClass,
+    ASTContext const &Context, CXXRecordDecl *NamingClass,
     NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
-    const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded,
-    const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin,
+    DeclarationNameInfo const &NameInfo, bool RequiresADL, bool Overloaded,
+    TemplateArgumentListInfo const *TemplateArgs, UnresolvedSetIterator Begin,
     UnresolvedSetIterator End)
     : OverloadExpr(UnresolvedLookupExprClass, Context, QualifierLoc,
                    TemplateKWLoc, NameInfo, TemplateArgs, Begin, End, false,
@@ -367,8 +381,8 @@
                    HasTemplateKWAndArgsInfo) {}
 
 UnresolvedLookupExpr *UnresolvedLookupExpr::Create(
-    const ASTContext &Context, CXXRecordDecl *NamingClass,
-    NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
+    ASTContext const &Context, CXXRecordDecl *NamingClass,
+    NestedNameSpecifierLoc QualifierLoc, DeclarationNameInfo const &NameInfo,
     bool RequiresADL, bool Overloaded, UnresolvedSetIterator Begin,
     UnresolvedSetIterator End) {
   unsigned NumResults = End - Begin;
@@ -381,10 +395,10 @@
 }
 
 UnresolvedLookupExpr *UnresolvedLookupExpr::Create(
-    const ASTContext &Context, CXXRecordDecl *NamingClass,
+    ASTContext const &Context, CXXRecordDecl *NamingClass,
     NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
-    const DeclarationNameInfo &NameInfo, bool RequiresADL,
-    const TemplateArgumentListInfo *Args, UnresolvedSetIterator Begin,
+    DeclarationNameInfo const &NameInfo, bool RequiresADL,
+    TemplateArgumentListInfo const *Args, UnresolvedSetIterator Begin,
     UnresolvedSetIterator End) {
   assert(Args || TemplateKWLoc.isValid());
   unsigned NumResults = End - Begin;
@@ -399,7 +413,7 @@
 }
 
 UnresolvedLookupExpr *UnresolvedLookupExpr::CreateEmpty(
-    const ASTContext &Context, unsigned NumResults,
+    ASTContext const &Context, unsigned NumResults,
     bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs) {
   assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
   unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,
@@ -410,11 +424,11 @@
       UnresolvedLookupExpr(EmptyShell(), NumResults, HasTemplateKWAndArgsInfo);
 }
 
-OverloadExpr::OverloadExpr(StmtClass SC, const ASTContext &Context,
+OverloadExpr::OverloadExpr(StmtClass SC, ASTContext const &Context,
                            NestedNameSpecifierLoc QualifierLoc,
                            SourceLocation TemplateKWLoc,
-                           const DeclarationNameInfo &NameInfo,
-                           const TemplateArgumentListInfo *TemplateArgs,
+                           DeclarationNameInfo const &NameInfo,
+                           TemplateArgumentListInfo const *TemplateArgs,
                            UnresolvedSetIterator Begin,
                            UnresolvedSetIterator End, bool KnownDependent,
                            bool KnownInstantiationDependent,
@@ -424,7 +438,7 @@
   unsigned NumResults = End - Begin;
   OverloadExprBits.NumResults = NumResults;
   OverloadExprBits.HasTemplateKWAndArgsInfo =
-      (TemplateArgs != nullptr ) || TemplateKWLoc.isValid();
+      (TemplateArgs != nullptr) || TemplateKWLoc.isValid();
 
   if (NumResults) {
     // Copy the results to the trailing array past UnresolvedLookupExpr
@@ -458,8 +472,8 @@
 // DependentScopeDeclRefExpr
 DependentScopeDeclRefExpr::DependentScopeDeclRefExpr(
     QualType Ty, NestedNameSpecifierLoc QualifierLoc,
-    SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo,
-    const TemplateArgumentListInfo *Args)
+    SourceLocation TemplateKWLoc, DeclarationNameInfo const &NameInfo,
+    TemplateArgumentListInfo const *Args)
     : Expr(DependentScopeDeclRefExprClass, Ty, VK_LValue, OK_Ordinary),
       QualifierLoc(QualifierLoc), NameInfo(NameInfo) {
   DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo =
@@ -476,9 +490,9 @@
 }
 
 DependentScopeDeclRefExpr *DependentScopeDeclRefExpr::Create(
-    const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
-    SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo,
-    const TemplateArgumentListInfo *Args) {
+    ASTContext const &Context, NestedNameSpecifierLoc QualifierLoc,
+    SourceLocation TemplateKWLoc, DeclarationNameInfo const &NameInfo,
+    TemplateArgumentListInfo const *Args) {
   assert(QualifierLoc && "should be created for dependent qualifiers");
   bool HasTemplateKWAndArgsInfo = Args || TemplateKWLoc.isValid();
   std::size_t Size =
@@ -490,7 +504,7 @@
 }
 
 DependentScopeDeclRefExpr *
-DependentScopeDeclRefExpr::CreateEmpty(const ASTContext &Context,
+DependentScopeDeclRefExpr::CreateEmpty(ASTContext const &Context,
                                        bool HasTemplateKWAndArgsInfo,
                                        unsigned NumTemplateArgs) {
   assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
@@ -521,7 +535,7 @@
 
   SourceLocation End = getLocation();
   for (unsigned I = getNumArgs(); I > 0; --I) {
-    const Expr *Arg = getArg(I-1);
+    Expr const *Arg = getArg(I - 1);
     if (!Arg->isDefaultArgument()) {
       SourceLocation NewEnd = Arg->getEndLoc();
       if (NewEnd.isValid()) {
@@ -555,7 +569,7 @@
                HasFPFeatures, Empty) {}
 
 CXXOperatorCallExpr *
-CXXOperatorCallExpr::Create(const ASTContext &Ctx,
+CXXOperatorCallExpr::Create(ASTContext const &Ctx,
                             OverloadedOperatorKind OpKind, Expr *Fn,
                             ArrayRef<Expr *> Args, QualType Ty,
                             ExprValueKind VK, SourceLocation OperatorLoc,
@@ -570,7 +584,7 @@
                                        FPFeatures, UsesADL);
 }
 
-CXXOperatorCallExpr *CXXOperatorCallExpr::CreateEmpty(const ASTContext &Ctx,
+CXXOperatorCallExpr *CXXOperatorCallExpr::CreateEmpty(ASTContext const &Ctx,
                                                       unsigned NumArgs,
                                                       bool HasFPFeatures,
                                                       EmptyShell Empty) {
@@ -619,7 +633,7 @@
     : CallExpr(CXXMemberCallExprClass, /*NumPreArgs=*/0, NumArgs, HasFPFeatures,
                Empty) {}
 
-CXXMemberCallExpr *CXXMemberCallExpr::Create(const ASTContext &Ctx, Expr *Fn,
+CXXMemberCallExpr *CXXMemberCallExpr::Create(ASTContext const &Ctx, Expr *Fn,
                                              ArrayRef<Expr *> Args, QualType Ty,
                                              ExprValueKind VK,
                                              SourceLocation RP,
@@ -635,7 +649,7 @@
       CXXMemberCallExpr(Fn, Args, Ty, VK, RP, FPFeatures, MinNumArgs);
 }
 
-CXXMemberCallExpr *CXXMemberCallExpr::CreateEmpty(const ASTContext &Ctx,
+CXXMemberCallExpr *CXXMemberCallExpr::CreateEmpty(ASTContext const &Ctx,
                                                   unsigned NumArgs,
                                                   bool HasFPFeatures,
                                                   EmptyShell Empty) {
@@ -648,10 +662,10 @@
 }
 
 Expr *CXXMemberCallExpr::getImplicitObjectArgument() const {
-  const Expr *Callee = getCallee()->IgnoreParens();
-  if (const auto *MemExpr = dyn_cast<MemberExpr>(Callee))
+  Expr const *Callee = getCallee()->IgnoreParens();
+  if (auto const *MemExpr = dyn_cast<MemberExpr>(Callee))
     return MemExpr->getBase();
-  if (const auto *BO = dyn_cast<BinaryOperator>(Callee))
+  if (auto const *BO = dyn_cast<BinaryOperator>(Callee))
     if (BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI)
       return BO->getLHS();
 
@@ -667,7 +681,7 @@
 }
 
 CXXMethodDecl *CXXMemberCallExpr::getMethodDecl() const {
-  if (const auto *MemExpr = dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
+  if (auto const *MemExpr = dyn_cast<MemberExpr>(getCallee()->IgnoreParens()))
     return cast<CXXMethodDecl>(MemExpr->getMemberDecl());
 
   // FIXME: Will eventually need to cope with member pointers.
@@ -676,7 +690,7 @@
 }
 
 CXXRecordDecl *CXXMemberCallExpr::getRecordDecl() const {
-  Expr* ThisArg = getImplicitObjectArgument();
+  Expr *ThisArg = getImplicitObjectArgument();
   if (!ThisArg)
     return nullptr;
 
@@ -693,20 +707,26 @@
 /// getCastName - Get the name of the C++ cast being used, e.g.,
 /// "static_cast", "dynamic_cast", "reinterpret_cast", or
 /// "const_cast". The returned pointer must not be freed.
-const char *CXXNamedCastExpr::getCastName() const {
+char const *CXXNamedCastExpr::getCastName() const {
   switch (getStmtClass()) {
-  case CXXStaticCastExprClass:      return "static_cast";
-  case CXXDynamicCastExprClass:     return "dynamic_cast";
-  case CXXReinterpretCastExprClass: return "reinterpret_cast";
-  case CXXConstCastExprClass:       return "const_cast";
-  case CXXAddrspaceCastExprClass:   return "addrspace_cast";
-  default:                          return "<invalid cast>";
+  case CXXStaticCastExprClass:
+    return "static_cast";
+  case CXXDynamicCastExprClass:
+    return "dynamic_cast";
+  case CXXReinterpretCastExprClass:
+    return "reinterpret_cast";
+  case CXXConstCastExprClass:
+    return "const_cast";
+  case CXXAddrspaceCastExprClass:
+    return "addrspace_cast";
+  default:
+    return "<invalid cast>";
   }
 }
 
 CXXStaticCastExpr *
-CXXStaticCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK,
-                          CastKind K, Expr *Op, const CXXCastPath *BasePath,
+CXXStaticCastExpr::Create(ASTContext const &C, QualType T, ExprValueKind VK,
+                          CastKind K, Expr *Op, CXXCastPath const *BasePath,
                           TypeSourceInfo *WrittenTy, FPOptionsOverride FPO,
                           SourceLocation L, SourceLocation RParenLoc,
                           SourceRange AngleBrackets) {
@@ -722,7 +742,7 @@
   return E;
 }
 
-CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(const ASTContext &C,
+CXXStaticCastExpr *CXXStaticCastExpr::CreateEmpty(ASTContext const &C,
                                                   unsigned PathSize,
                                                   bool HasFPFeatures) {
   void *Buffer =
@@ -731,26 +751,21 @@
   return new (Buffer) CXXStaticCastExpr(EmptyShell(), PathSize, HasFPFeatures);
 }
 
-CXXDynamicCastExpr *CXXDynamicCastExpr::Create(const ASTContext &C, QualType T,
-                                               ExprValueKind VK,
-                                               CastKind K, Expr *Op,
-                                               const CXXCastPath *BasePath,
-                                               TypeSourceInfo *WrittenTy,
-                                               SourceLocation L,
-                                               SourceLocation RParenLoc,
-                                               SourceRange AngleBrackets) {
+CXXDynamicCastExpr *CXXDynamicCastExpr::Create(
+    ASTContext const &C, QualType T, ExprValueKind VK, CastKind K, Expr *Op,
+    CXXCastPath const *BasePath, TypeSourceInfo *WrittenTy, SourceLocation L,
+    SourceLocation RParenLoc, SourceRange AngleBrackets) {
   unsigned PathSize = (BasePath ? BasePath->size() : 0);
   void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
-  auto *E =
-      new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
-                                      RParenLoc, AngleBrackets);
+  auto *E = new (Buffer) CXXDynamicCastExpr(T, VK, K, Op, PathSize, WrittenTy,
+                                            L, RParenLoc, AngleBrackets);
   if (PathSize)
     std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
                               E->getTrailingObjects<CXXBaseSpecifier *>());
   return E;
 }
 
-CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(const ASTContext &C,
+CXXDynamicCastExpr *CXXDynamicCastExpr::CreateEmpty(ASTContext const &C,
                                                     unsigned PathSize) {
   void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
   return new (Buffer) CXXDynamicCastExpr(EmptyShell(), PathSize);
@@ -764,12 +779,11 @@
 /// struct C { };
 ///
 /// C *f(B* b) { return dynamic_cast<C*>(b); }
-bool CXXDynamicCastExpr::isAlwaysNull() const
-{
+bool CXXDynamicCastExpr::isAlwaysNull() const {
   QualType SrcType = getSubExpr()->getType();
   QualType DestType = getType();
 
-  if (const auto *SrcPTy = SrcType->getAs<PointerType>()) {
+  if (auto const *SrcPTy = SrcType->getAs<PointerType>()) {
     SrcType = SrcPTy->getPointeeType();
     DestType = DestType->castAs<PointerType>()->getPointeeType();
   }
@@ -777,57 +791,52 @@
   if (DestType->isVoidType())
     return false;
 
-  const auto *SrcRD =
+  auto const *SrcRD =
       cast<CXXRecordDecl>(SrcType->castAs<RecordType>()->getDecl());
 
   if (!SrcRD->hasAttr<FinalAttr>())
     return false;
 
-  const auto *DestRD =
+  auto const *DestRD =
       cast<CXXRecordDecl>(DestType->castAs<RecordType>()->getDecl());
 
   return !DestRD->isDerivedFrom(SrcRD);
 }
 
-CXXReinterpretCastExpr *
-CXXReinterpretCastExpr::Create(const ASTContext &C, QualType T,
-                               ExprValueKind VK, CastKind K, Expr *Op,
-                               const CXXCastPath *BasePath,
-                               TypeSourceInfo *WrittenTy, SourceLocation L,
-                               SourceLocation RParenLoc,
-                               SourceRange AngleBrackets) {
+CXXReinterpretCastExpr *CXXReinterpretCastExpr::Create(
+    ASTContext const &C, QualType T, ExprValueKind VK, CastKind K, Expr *Op,
+    CXXCastPath const *BasePath, TypeSourceInfo *WrittenTy, SourceLocation L,
+    SourceLocation RParenLoc, SourceRange AngleBrackets) {
   unsigned PathSize = (BasePath ? BasePath->size() : 0);
   void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
-  auto *E =
-      new (Buffer) CXXReinterpretCastExpr(T, VK, K, Op, PathSize, WrittenTy, L,
-                                          RParenLoc, AngleBrackets);
+  auto *E = new (Buffer) CXXReinterpretCastExpr(
+      T, VK, K, Op, PathSize, WrittenTy, L, RParenLoc, AngleBrackets);
   if (PathSize)
     std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
                               E->getTrailingObjects<CXXBaseSpecifier *>());
   return E;
 }
 
-CXXReinterpretCastExpr *
-CXXReinterpretCastExpr::CreateEmpty(const ASTContext &C, unsigned PathSize) {
+CXXReinterpretCastExpr *CXXReinterpretCastExpr::CreateEmpty(ASTContext const &C,
+                                                            unsigned PathSize) {
   void *Buffer = C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *>(PathSize));
   return new (Buffer) CXXReinterpretCastExpr(EmptyShell(), PathSize);
 }
 
-CXXConstCastExpr *CXXConstCastExpr::Create(const ASTContext &C, QualType T,
-                                           ExprValueKind VK, Expr *Op,
-                                           TypeSourceInfo *WrittenTy,
-                                           SourceLocation L,
-                                           SourceLocation RParenLoc,
-                                           SourceRange AngleBrackets) {
-  return new (C) CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets);
+CXXConstCastExpr *
+CXXConstCastExpr::Create(ASTContext const &C, QualType T, ExprValueKind VK,
+                         Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L,
+                         SourceLocation RParenLoc, SourceRange AngleBrackets) {
+  return new (C)
+      CXXConstCastExpr(T, VK, Op, WrittenTy, L, RParenLoc, AngleBrackets);
 }
 
-CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(const ASTContext &C) {
+CXXConstCastExpr *CXXConstCastExpr::CreateEmpty(ASTContext const &C) {
   return new (C) CXXConstCastExpr(EmptyShell());
 }
 
 CXXAddrspaceCastExpr *
-CXXAddrspaceCastExpr::Create(const ASTContext &C, QualType T, ExprValueKind VK,
+CXXAddrspaceCastExpr::Create(ASTContext const &C, QualType T, ExprValueKind VK,
                              CastKind K, Expr *Op, TypeSourceInfo *WrittenTy,
                              SourceLocation L, SourceLocation RParenLoc,
                              SourceRange AngleBrackets) {
@@ -835,13 +844,13 @@
                                       AngleBrackets);
 }
 
-CXXAddrspaceCastExpr *CXXAddrspaceCastExpr::CreateEmpty(const ASTContext &C) {
+CXXAddrspaceCastExpr *CXXAddrspaceCastExpr::CreateEmpty(ASTContext const &C) {
   return new (C) CXXAddrspaceCastExpr(EmptyShell());
 }
 
 CXXFunctionalCastExpr *CXXFunctionalCastExpr::Create(
-    const ASTContext &C, QualType T, ExprValueKind VK, TypeSourceInfo *Written,
-    CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO,
+    ASTContext const &C, QualType T, ExprValueKind VK, TypeSourceInfo *Written,
+    CastKind K, Expr *Op, CXXCastPath const *BasePath, FPOptionsOverride FPO,
     SourceLocation L, SourceLocation R) {
   unsigned PathSize = (BasePath ? BasePath->size() : 0);
   void *Buffer =
@@ -855,7 +864,7 @@
   return E;
 }
 
-CXXFunctionalCastExpr *CXXFunctionalCastExpr::CreateEmpty(const ASTContext &C,
+CXXFunctionalCastExpr *CXXFunctionalCastExpr::CreateEmpty(ASTContext const &C,
                                                           unsigned PathSize,
                                                           bool HasFPFeatures) {
   void *Buffer =
@@ -887,7 +896,7 @@
     : CallExpr(UserDefinedLiteralClass, /*NumPreArgs=*/0, NumArgs,
                HasFPFeatures, Empty) {}
 
-UserDefinedLiteral *UserDefinedLiteral::Create(const ASTContext &Ctx, Expr *Fn,
+UserDefinedLiteral *UserDefinedLiteral::Create(ASTContext const &Ctx, Expr *Fn,
                                                ArrayRef<Expr *> Args,
                                                QualType Ty, ExprValueKind VK,
                                                SourceLocation LitEndLoc,
@@ -903,7 +912,7 @@
       UserDefinedLiteral(Fn, Args, Ty, VK, LitEndLoc, SuffixLoc, FPFeatures);
 }
 
-UserDefinedLiteral *UserDefinedLiteral::CreateEmpty(const ASTContext &Ctx,
+UserDefinedLiteral *UserDefinedLiteral::CreateEmpty(ASTContext const &Ctx,
                                                     unsigned NumArgs,
                                                     bool HasFPOptions,
                                                     EmptyShell Empty) {
@@ -924,7 +933,7 @@
 
   assert(getNumArgs() == 1 && "unexpected #args in literal operator call");
   QualType ParamTy =
-    cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType();
+      cast<FunctionDecl>(getCalleeDecl())->getParamDecl(0)->getType();
   if (ParamTy->isPointerType())
     return LOK_Raw;
   if (ParamTy->isAnyCharacterType())
@@ -945,11 +954,11 @@
   return getArg(0);
 }
 
-const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const {
+IdentifierInfo const *UserDefinedLiteral::getUDSuffix() const {
   return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier();
 }
 
-CXXDefaultInitExpr::CXXDefaultInitExpr(const ASTContext &Ctx,
+CXXDefaultInitExpr::CXXDefaultInitExpr(ASTContext const &Ctx,
                                        SourceLocation Loc, FieldDecl *Field,
                                        QualType Ty, DeclContext *UsedContext)
     : Expr(CXXDefaultInitExprClass, Ty.getNonLValueExprType(Ctx),
@@ -964,14 +973,14 @@
   setDependence(computeDependence(this));
 }
 
-CXXTemporary *CXXTemporary::Create(const ASTContext &C,
-                                   const CXXDestructorDecl *Destructor) {
+CXXTemporary *CXXTemporary::Create(ASTContext const &C,
+                                   CXXDestructorDecl const *Destructor) {
   return new (C) CXXTemporary(Destructor);
 }
 
-CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(const ASTContext &C,
+CXXBindTemporaryExpr *CXXBindTemporaryExpr::Create(ASTContext const &C,
                                                    CXXTemporary *Temp,
-                                                   Expr* SubExpr) {
+                                                   Expr *SubExpr) {
   assert((SubExpr->getType()->isRecordType() ||
           SubExpr->getType()->isArrayType()) &&
          "Expression bound to a temporary must have record or array type!");
@@ -996,7 +1005,7 @@
     : CXXConstructExpr(CXXTemporaryObjectExprClass, Empty, NumArgs) {}
 
 CXXTemporaryObjectExpr *CXXTemporaryObjectExpr::Create(
-    const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty,
+    ASTContext const &Ctx, CXXConstructorDecl *Cons, QualType Ty,
     TypeSourceInfo *TSI, ArrayRef<Expr *> Args, SourceRange ParenOrBraceRange,
     bool HadMultipleCandidates, bool ListInitialization,
     bool StdInitListInitialization, bool ZeroInitialization) {
@@ -1010,7 +1019,7 @@
 }
 
 CXXTemporaryObjectExpr *
-CXXTemporaryObjectExpr::CreateEmpty(const ASTContext &Ctx, unsigned NumArgs) {
+CXXTemporaryObjectExpr::CreateEmpty(ASTContext const &Ctx, unsigned NumArgs) {
   unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs);
   void *Mem =
       Ctx.Allocate(sizeof(CXXTemporaryObjectExpr) + SizeOfTrailingObjects,
@@ -1030,7 +1039,7 @@
 }
 
 CXXConstructExpr *CXXConstructExpr::Create(
-    const ASTContext &Ctx, QualType Ty, SourceLocation Loc,
+    ASTContext const &Ctx, QualType Ty, SourceLocation Loc,
     CXXConstructorDecl *Ctor, bool Elidable, ArrayRef<Expr *> Args,
     bool HadMultipleCandidates, bool ListInitialization,
     bool StdInitListInitialization, bool ZeroInitialization,
@@ -1044,7 +1053,7 @@
       ZeroInitialization, ConstructKind, ParenOrBraceRange);
 }
 
-CXXConstructExpr *CXXConstructExpr::CreateEmpty(const ASTContext &Ctx,
+CXXConstructExpr *CXXConstructExpr::CreateEmpty(ASTContext const &Ctx,
                                                 unsigned NumArgs) {
   unsigned SizeOfTrailingObjects = sizeOfTrailingObjects(NumArgs);
   void *Mem = Ctx.Allocate(sizeof(CXXConstructExpr) + SizeOfTrailingObjects,
@@ -1160,7 +1169,7 @@
   getStoredStmts()[NumCaptures] = nullptr; // Not one past the end.
 }
 
-LambdaExpr *LambdaExpr::Create(const ASTContext &Context, CXXRecordDecl *Class,
+LambdaExpr *LambdaExpr::Create(ASTContext const &Context, CXXRecordDecl *Class,
                                SourceRange IntroducerRange,
                                LambdaCaptureDefault CaptureDefault,
                                SourceLocation CaptureDefaultLoc,
@@ -1180,7 +1189,7 @@
                  ContainsUnexpandedParameterPack);
 }
 
-LambdaExpr *LambdaExpr::CreateDeserialized(const ASTContext &C,
+LambdaExpr *LambdaExpr::CreateDeserialized(ASTContext const &C,
                                            unsigned NumCaptures) {
   unsigned Size = totalSizeToAlloc<Stmt *>(NumCaptures + 1);
   void *Mem = C.Allocate(Size);
@@ -1199,14 +1208,14 @@
   return getStoredStmts()[capture_size()];
 }
 
-const CompoundStmt *LambdaExpr::getCompoundStmtBody() const {
+CompoundStmt const *LambdaExpr::getCompoundStmtBody() const {
   Stmt *Body = getBody();
-  if (const auto *CoroBody = dyn_cast<CoroutineBodyStmt>(Body))
+  if (auto const *CoroBody = dyn_cast<CoroutineBodyStmt>(Body))
     return cast<CompoundStmt>(CoroBody->getBody());
   return cast<CompoundStmt>(Body);
 }
 
-bool LambdaExpr::isInitCapture(const LambdaCapture *C) const {
+bool LambdaExpr::isInitCapture(LambdaCapture const *C) const {
   return (C->capturesVariable() && C->getCapturedVar()->isInitCapture() &&
           (getCallOperator() == C->getCapturedVar()->getDeclContext()));
 }
@@ -1228,8 +1237,8 @@
 }
 
 LambdaExpr::capture_iterator LambdaExpr::explicit_capture_end() const {
-  struct CXXRecordDecl::LambdaDefinitionData &Data
-    = getLambdaClass()->getLambdaData();
+  struct CXXRecordDecl::LambdaDefinitionData &Data =
+      getLambdaClass()->getLambdaData();
   return Data.Captures + Data.NumExplicitCaptures;
 }
 
@@ -1269,7 +1278,7 @@
 }
 
 ArrayRef<NamedDecl *> LambdaExpr::getExplicitTemplateParameters() const {
-  const CXXRecordDecl *Record = getLambdaClass();
+  CXXRecordDecl const *Record = getLambdaClass();
   return Record->getLambdaExplicitTemplateParameters();
 }
 
@@ -1290,8 +1299,7 @@
                            getStoredStmts() + capture_size() + 1);
 }
 
-ExprWithCleanups::ExprWithCleanups(Expr *subexpr,
-                                   bool CleanupsHaveSideEffects,
+ExprWithCleanups::ExprWithCleanups(Expr *subexpr, bool CleanupsHaveSideEffects,
                                    ArrayRef<CleanupObject> objects)
     : FullExpr(ExprWithCleanupsClass, subexpr) {
   ExprWithCleanupsBits.CleanupsHaveSideEffects = CleanupsHaveSideEffects;
@@ -1300,7 +1308,7 @@
     getTrailingObjects<CleanupObject>()[i] = objects[i];
 }
 
-ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C, Expr *subexpr,
+ExprWithCleanups *ExprWithCleanups::Create(ASTContext const &C, Expr *subexpr,
                                            bool CleanupsHaveSideEffects,
                                            ArrayRef<CleanupObject> objects) {
   void *buffer = C.Allocate(totalSizeToAlloc<CleanupObject>(objects.size()),
@@ -1314,7 +1322,7 @@
   ExprWithCleanupsBits.NumObjects = numObjects;
 }
 
-ExprWithCleanups *ExprWithCleanups::Create(const ASTContext &C,
+ExprWithCleanups *ExprWithCleanups::Create(ASTContext const &C,
                                            EmptyShell empty,
                                            unsigned numObjects) {
   void *buffer = C.Allocate(totalSizeToAlloc<CleanupObject>(numObjects),
@@ -1341,15 +1349,15 @@
 }
 
 CXXUnresolvedConstructExpr *CXXUnresolvedConstructExpr::Create(
-    const ASTContext &Context, QualType T, TypeSourceInfo *TSI, SourceLocation LParenLoc,
-    ArrayRef<Expr *> Args, SourceLocation RParenLoc) {
+    ASTContext const &Context, QualType T, TypeSourceInfo *TSI,
+    SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc) {
   void *Mem = Context.Allocate(totalSizeToAlloc<Expr *>(Args.size()));
   return new (Mem)
       CXXUnresolvedConstructExpr(T, TSI, LParenLoc, Args, RParenLoc);
 }
 
 CXXUnresolvedConstructExpr *
-CXXUnresolvedConstructExpr::CreateEmpty(const ASTContext &Context,
+CXXUnresolvedConstructExpr::CreateEmpty(ASTContext const &Context,
                                         unsigned NumArgs) {
   void *Mem = Context.Allocate(totalSizeToAlloc<Expr *>(NumArgs));
   return new (Mem) CXXUnresolvedConstructExpr(EmptyShell(), NumArgs);
@@ -1360,11 +1368,11 @@
 }
 
 CXXDependentScopeMemberExpr::CXXDependentScopeMemberExpr(
-    const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
+    ASTContext const &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
     SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
     SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
     DeclarationNameInfo MemberNameInfo,
-    const TemplateArgumentListInfo *TemplateArgs)
+    TemplateArgumentListInfo const *TemplateArgs)
     : Expr(CXXDependentScopeMemberExprClass, Ctx.DependentTy, VK_LValue,
            OK_Ordinary),
       Base(Base), BaseType(BaseType), QualifierLoc(QualifierLoc),
@@ -1402,11 +1410,11 @@
 }
 
 CXXDependentScopeMemberExpr *CXXDependentScopeMemberExpr::Create(
-    const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
+    ASTContext const &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
     SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
     SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
     DeclarationNameInfo MemberNameInfo,
-    const TemplateArgumentListInfo *TemplateArgs) {
+    TemplateArgumentListInfo const *TemplateArgs) {
   bool HasTemplateKWAndArgsInfo =
       (TemplateArgs != nullptr) || TemplateKWLoc.isValid();
   unsigned NumTemplateArgs = TemplateArgs ? TemplateArgs->size() : 0;
@@ -1423,7 +1431,7 @@
 }
 
 CXXDependentScopeMemberExpr *CXXDependentScopeMemberExpr::CreateEmpty(
-    const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo,
+    ASTContext const &Ctx, bool HasTemplateKWAndArgsInfo,
     unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope) {
   assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
 
@@ -1454,11 +1462,11 @@
 }
 
 UnresolvedMemberExpr::UnresolvedMemberExpr(
-    const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base,
+    ASTContext const &Context, bool HasUnresolvedUsing, Expr *Base,
     QualType BaseType, bool IsArrow, SourceLocation OperatorLoc,
     NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
-    const DeclarationNameInfo &MemberNameInfo,
-    const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin,
+    DeclarationNameInfo const &MemberNameInfo,
+    TemplateArgumentListInfo const *TemplateArgs, UnresolvedSetIterator Begin,
     UnresolvedSetIterator End)
     : OverloadExpr(
           UnresolvedMemberExprClass, Context, QualifierLoc, TemplateKWLoc,
@@ -1494,11 +1502,11 @@
 }
 
 UnresolvedMemberExpr *UnresolvedMemberExpr::Create(
-    const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base,
+    ASTContext const &Context, bool HasUnresolvedUsing, Expr *Base,
     QualType BaseType, bool IsArrow, SourceLocation OperatorLoc,
     NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
-    const DeclarationNameInfo &MemberNameInfo,
-    const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin,
+    DeclarationNameInfo const &MemberNameInfo,
+    TemplateArgumentListInfo const *TemplateArgs, UnresolvedSetIterator Begin,
     UnresolvedSetIterator End) {
   unsigned NumResults = End - Begin;
   bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.isValid();
@@ -1513,7 +1521,7 @@
 }
 
 UnresolvedMemberExpr *UnresolvedMemberExpr::CreateEmpty(
-    const ASTContext &Context, unsigned NumResults,
+    ASTContext const &Context, unsigned NumResults,
     bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs) {
   assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
   unsigned Size = totalSizeToAlloc<DeclAccessPair, ASTTemplateKWAndArgsInfo,
@@ -1533,7 +1541,7 @@
   CXXRecordDecl *Record = nullptr;
   auto *NNS = getQualifier();
   if (NNS && NNS->getKind() != NestedNameSpecifier::Super) {
-    const Type *T = getQualifier()->getAsType();
+    Type const *T = getQualifier()->getAsType();
     assert(T && "qualifier in member expression does not name type");
     Record = T->getAsCXXRecordDecl();
     assert(Record && "qualifier in member expression does not name record");
@@ -1551,12 +1559,12 @@
   return Record;
 }
 
-SizeOfPackExpr *
-SizeOfPackExpr::Create(ASTContext &Context, SourceLocation OperatorLoc,
-                       NamedDecl *Pack, SourceLocation PackLoc,
-                       SourceLocation RParenLoc,
-                       Optional<unsigned> Length,
-                       ArrayRef<TemplateArgument> PartialArgs) {
+SizeOfPackExpr *SizeOfPackExpr::Create(ASTContext &Context,
+                                       SourceLocation OperatorLoc,
+                                       NamedDecl *Pack, SourceLocation PackLoc,
+                                       SourceLocation RParenLoc,
+                                       Optional<unsigned> Length,
+                                       ArrayRef<TemplateArgument> PartialArgs) {
   void *Storage =
       Context.Allocate(totalSizeToAlloc<TemplateArgument>(PartialArgs.size()));
   return new (Storage) SizeOfPackExpr(Context.getSizeType(), OperatorLoc, Pack,
@@ -1571,7 +1579,7 @@
 }
 
 QualType SubstNonTypeTemplateParmExpr::getParameterType(
-    const ASTContext &Context) const {
+    ASTContext const &Context) const {
   // Note that, for a class type NTTP, we will have an lvalue of type 'const
   // T', so we can't just compute this from the type and value category.
   if (isReferenceParameter())
@@ -1581,7 +1589,7 @@
 
 SubstNonTypeTemplateParmPackExpr::SubstNonTypeTemplateParmPackExpr(
     QualType T, ExprValueKind ValueKind, NonTypeTemplateParmDecl *Param,
-    SourceLocation NameLoc, const TemplateArgument &ArgPack)
+    SourceLocation NameLoc, TemplateArgument const &ArgPack)
     : Expr(SubstNonTypeTemplateParmPackExprClass, T, ValueKind, OK_Ordinary),
       Param(Param), Arguments(ArgPack.pack_begin()),
       NumArguments(ArgPack.pack_size()), NameLoc(NameLoc) {
@@ -1606,16 +1614,17 @@
                 ExprDependence::UnexpandedPack);
 }
 
-FunctionParmPackExpr *
-FunctionParmPackExpr::Create(const ASTContext &Context, QualType T,
-                             VarDecl *ParamPack, SourceLocation NameLoc,
-                             ArrayRef<VarDecl *> Params) {
+FunctionParmPackExpr *FunctionParmPackExpr::Create(ASTContext const &Context,
+                                                   QualType T,
+                                                   VarDecl *ParamPack,
+                                                   SourceLocation NameLoc,
+                                                   ArrayRef<VarDecl *> Params) {
   return new (Context.Allocate(totalSizeToAlloc<VarDecl *>(Params.size())))
       FunctionParmPackExpr(T, ParamPack, NameLoc, Params.size(), Params.data());
 }
 
 FunctionParmPackExpr *
-FunctionParmPackExpr::CreateEmpty(const ASTContext &Context,
+FunctionParmPackExpr::CreateEmpty(ASTContext const &Context,
                                   unsigned NumParams) {
   return new (Context.Allocate(totalSizeToAlloc<VarDecl *>(NumParams)))
       FunctionParmPackExpr(QualType(), nullptr, SourceLocation(), 0, nullptr);
@@ -1653,7 +1662,7 @@
 }
 
 bool MaterializeTemporaryExpr::isUsableInConstantExpressions(
-    const ASTContext &Context) const {
+    ASTContext const &Context) const {
   // C++20 [expr.const]p4:
   //   An object or reference is usable in constant expressions if it is [...]
   //   a temporary object of non-volatile const-qualified literal type
@@ -1687,17 +1696,15 @@
   setDependence(computeDependence(this));
 }
 
-TypeTraitExpr *TypeTraitExpr::Create(const ASTContext &C, QualType T,
-                                     SourceLocation Loc,
-                                     TypeTrait Kind,
+TypeTraitExpr *TypeTraitExpr::Create(ASTContext const &C, QualType T,
+                                     SourceLocation Loc, TypeTrait Kind,
                                      ArrayRef<TypeSourceInfo *> Args,
-                                     SourceLocation RParenLoc,
-                                     bool Value) {
+                                     SourceLocation RParenLoc, bool Value) {
   void *Mem = C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(Args.size()));
   return new (Mem) TypeTraitExpr(T, Loc, Kind, Args, RParenLoc, Value);
 }
 
-TypeTraitExpr *TypeTraitExpr::CreateDeserialized(const ASTContext &C,
+TypeTraitExpr *TypeTraitExpr::CreateDeserialized(ASTContext const &C,
                                                  unsigned NumArgs) {
   void *Mem = C.Allocate(totalSizeToAlloc<TypeSourceInfo *>(NumArgs));
   return new (Mem) TypeTraitExpr(EmptyShell());
@@ -1717,7 +1724,7 @@
                HasFPFeatures, Empty) {}
 
 CUDAKernelCallExpr *
-CUDAKernelCallExpr::Create(const ASTContext &Ctx, Expr *Fn, CallExpr *Config,
+CUDAKernelCallExpr::Create(ASTContext const &Ctx, Expr *Fn, CallExpr *Config,
                            ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
                            SourceLocation RP, FPOptionsOverride FPFeatures,
                            unsigned MinNumArgs) {
@@ -1731,7 +1738,7 @@
       CUDAKernelCallExpr(Fn, Config, Args, Ty, VK, RP, FPFeatures, MinNumArgs);
 }
 
-CUDAKernelCallExpr *CUDAKernelCallExpr::CreateEmpty(const ASTContext &Ctx,
+CUDAKernelCallExpr *CUDAKernelCallExpr::CreateEmpty(ASTContext const &Ctx,
                                                     unsigned NumArgs,
                                                     bool HasFPFeatures,
                                                     EmptyShell Empty) {
Index: clang/lib/AST/ExprClassification.cpp
===================================================================
--- clang/lib/AST/ExprClassification.cpp
+++ clang/lib/AST/ExprClassification.cpp
@@ -10,11 +10,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/Expr.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -23,15 +23,14 @@
 
 using Cl = Expr::Classification;
 
-static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E);
-static Cl::Kinds ClassifyDecl(ASTContext &Ctx, const Decl *D);
+static Cl::Kinds ClassifyInternal(ASTContext &Ctx, Expr const *E);
+static Cl::Kinds ClassifyDecl(ASTContext &Ctx, Decl const *D);
 static Cl::Kinds ClassifyUnnamed(ASTContext &Ctx, QualType T);
-static Cl::Kinds ClassifyMemberExpr(ASTContext &Ctx, const MemberExpr *E);
-static Cl::Kinds ClassifyBinaryOp(ASTContext &Ctx, const BinaryOperator *E);
-static Cl::Kinds ClassifyConditional(ASTContext &Ctx,
-                                     const Expr *trueExpr,
-                                     const Expr *falseExpr);
-static Cl::ModifiableType IsModifiable(ASTContext &Ctx, const Expr *E,
+static Cl::Kinds ClassifyMemberExpr(ASTContext &Ctx, MemberExpr const *E);
+static Cl::Kinds ClassifyBinaryOp(ASTContext &Ctx, BinaryOperator const *E);
+static Cl::Kinds ClassifyConditional(ASTContext &Ctx, Expr const *trueExpr,
+                                     Expr const *falseExpr);
+static Cl::ModifiableType IsModifiable(ASTContext &Ctx, Expr const *E,
                                        Cl::Kinds Kind, SourceLocation &Loc);
 
 Cl Expr::ClassifyImpl(ASTContext &Ctx, SourceLocation *Loc) const {
@@ -91,8 +90,7 @@
   return Cl::CL_PRValue;
 }
 
-static Cl::Kinds ClassifyExprValueKind(const LangOptions &Lang,
-                                       const Expr *E,
+static Cl::Kinds ClassifyExprValueKind(LangOptions const &Lang, Expr const *E,
                                        ExprValueKind Kind) {
   switch (Kind) {
   case VK_PRValue:
@@ -105,9 +103,9 @@
   llvm_unreachable("Invalid value category of implicit cast.");
 }
 
-static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) {
+static Cl::Kinds ClassifyInternal(ASTContext &Ctx, Expr const *E) {
   // This function takes the first stab at classifying expressions.
-  const LangOptions &Lang = Ctx.getLangOpts();
+  LangOptions const &Lang = Ctx.getLangOpts();
 
   switch (E->getStmtClass()) {
   case Stmt::NoStmtClass:
@@ -210,8 +208,8 @@
 
     // Next come the complicated cases.
   case Expr::SubstNonTypeTemplateParmExprClass:
-    return ClassifyInternal(Ctx,
-                 cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
+    return ClassifyInternal(
+        Ctx, cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
 
     // C, C++98 [expr.sub]p1: The result is an lvalue of type "T".
     // C++11 (DR1213): in the case of an array operand, the result is an lvalue
@@ -237,8 +235,8 @@
     //   function or variable and a prvalue otherwise.
   case Expr::DeclRefExprClass:
     if (E->getType() == Ctx.UnknownAnyTy)
-      return isa<FunctionDecl>(cast<DeclRefExpr>(E)->getDecl())
-               ? Cl::CL_PRValue : Cl::CL_LValue;
+      return isa<FunctionDecl>(cast<DeclRefExpr>(E)->getDecl()) ? Cl::CL_PRValue
+                                                                : Cl::CL_LValue;
     return ClassifyDecl(Ctx, cast<DeclRefExpr>(E)->getDecl());
 
     // Member access is complex.
@@ -261,9 +259,10 @@
     // expressions:  l-value only if the operand is a true l-value.
     case UO_Real:
     case UO_Imag: {
-      const Expr *Op = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
+      Expr const *Op = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
       Cl::Kinds K = ClassifyInternal(Ctx, Op);
-      if (K != Cl::CL_LValue) return K;
+      if (K != Cl::CL_LValue)
+        return K;
 
       if (isa<ObjCPropertyRefExpr>(Op))
         return Cl::CL_SubObjCPropertySetting;
@@ -306,7 +305,8 @@
   case Expr::GenericSelectionExprClass:
     if (cast<GenericSelectionExpr>(E)->isResultDependent())
       return Cl::CL_PRValue;
-    return ClassifyInternal(Ctx,cast<GenericSelectionExpr>(E)->getResultExpr());
+    return ClassifyInternal(Ctx,
+                            cast<GenericSelectionExpr>(E)->getResultExpr());
 
   case Expr::BinaryOperatorClass:
   case Expr::CompoundAssignOperatorClass:
@@ -366,31 +366,34 @@
   case Expr::ObjCBridgedCastExprClass:
   case Expr::BuiltinBitCastExprClass:
     // Only in C++ can casts be interesting at all.
-    if (!Lang.CPlusPlus) return Cl::CL_PRValue;
+    if (!Lang.CPlusPlus)
+      return Cl::CL_PRValue;
     return ClassifyUnnamed(Ctx, cast<ExplicitCastExpr>(E)->getTypeAsWritten());
 
   case Expr::CXXUnresolvedConstructExprClass:
-    return ClassifyUnnamed(Ctx,
-                      cast<CXXUnresolvedConstructExpr>(E)->getTypeAsWritten());
+    return ClassifyUnnamed(
+        Ctx, cast<CXXUnresolvedConstructExpr>(E)->getTypeAsWritten());
 
   case Expr::BinaryConditionalOperatorClass: {
-    if (!Lang.CPlusPlus) return Cl::CL_PRValue;
-    const auto *co = cast<BinaryConditionalOperator>(E);
+    if (!Lang.CPlusPlus)
+      return Cl::CL_PRValue;
+    auto const *co = cast<BinaryConditionalOperator>(E);
     return ClassifyConditional(Ctx, co->getTrueExpr(), co->getFalseExpr());
   }
 
   case Expr::ConditionalOperatorClass: {
     // Once again, only C++ is interesting.
-    if (!Lang.CPlusPlus) return Cl::CL_PRValue;
-    const auto *co = cast<ConditionalOperator>(E);
+    if (!Lang.CPlusPlus)
+      return Cl::CL_PRValue;
+    auto const *co = cast<ConditionalOperator>(E);
     return ClassifyConditional(Ctx, co->getTrueExpr(), co->getFalseExpr());
   }
 
     // ObjC message sends are effectively function calls, if the target function
     // is known.
   case Expr::ObjCMessageExprClass:
-    if (const ObjCMethodDecl *Method =
-          cast<ObjCMessageExpr>(E)->getMethodDecl()) {
+    if (ObjCMethodDecl const *Method =
+            cast<ObjCMessageExpr>(E)->getMethodDecl()) {
       Cl::Kinds kind = ClassifyUnnamed(Ctx, Method->getReturnType());
       return (kind == Cl::CL_PRValue) ? Cl::CL_ObjCMessageRValue : kind;
     }
@@ -411,8 +414,8 @@
     return ClassifyInternal(Ctx, cast<DesignatedInitExpr>(E)->getInit());
 
   case Expr::StmtExprClass: {
-    const CompoundStmt *S = cast<StmtExpr>(E)->getSubStmt();
-    if (const auto *LastExpr = dyn_cast_or_null<Expr>(S->body_back()))
+    CompoundStmt const *S = cast<StmtExpr>(E)->getSubStmt();
+    if (auto const *LastExpr = dyn_cast_or_null<Expr>(S->body_back()))
       return ClassifyUnnamed(Ctx, LastExpr->getType());
     return Cl::CL_PRValue;
   }
@@ -422,8 +425,8 @@
 
   case Expr::MaterializeTemporaryExprClass:
     return cast<MaterializeTemporaryExpr>(E)->isBoundToLvalueReference()
-              ? Cl::CL_LValue
-              : Cl::CL_XValue;
+               ? Cl::CL_LValue
+               : Cl::CL_XValue;
 
   case Expr::InitListExprClass:
     // An init list can be an lvalue if it is bound to a reference and
@@ -438,7 +441,8 @@
 
   case Expr::CoawaitExprClass:
   case Expr::CoyieldExprClass:
-    return ClassifyInternal(Ctx, cast<CoroutineSuspendExpr>(E)->getResumeExpr());
+    return ClassifyInternal(Ctx,
+                            cast<CoroutineSuspendExpr>(E)->getResumeExpr());
   case Expr::SYCLUniqueStableNameExprClass:
     return Cl::CL_PRValue;
     break;
@@ -449,7 +453,7 @@
 
 /// ClassifyDecl - Return the classification of an expression referencing the
 /// given declaration.
-static Cl::Kinds ClassifyDecl(ASTContext &Ctx, const Decl *D) {
+static Cl::Kinds ClassifyDecl(ASTContext &Ctx, Decl const *D) {
   // C++ [expr.prim.general]p6: The result is an lvalue if the entity is a
   //   function, variable, or data member and a prvalue otherwise.
   // In C, functions are not lvalues.
@@ -461,15 +465,13 @@
     return Cl::CL_MemberFunction;
 
   bool islvalue;
-  if (const auto *NTTParm = dyn_cast<NonTypeTemplateParmDecl>(D))
+  if (auto const *NTTParm = dyn_cast<NonTypeTemplateParmDecl>(D))
     islvalue = NTTParm->getType()->isReferenceType() ||
                NTTParm->getType()->isRecordType();
   else
     islvalue = isa<VarDecl>(D) || isa<FieldDecl>(D) ||
-               isa<IndirectFieldDecl>(D) ||
-               isa<BindingDecl>(D) ||
-               isa<MSGuidDecl>(D) ||
-               isa<TemplateParamObjectDecl>(D) ||
+               isa<IndirectFieldDecl>(D) || isa<BindingDecl>(D) ||
+               isa<MSGuidDecl>(D) || isa<TemplateParamObjectDecl>(D) ||
                (Ctx.getLangOpts().CPlusPlus &&
                 (isa<FunctionDecl>(D) || isa<MSPropertyDecl>(D) ||
                  isa<FunctionTemplateDecl>(D)));
@@ -482,7 +484,8 @@
 /// calls and casts.
 static Cl::Kinds ClassifyUnnamed(ASTContext &Ctx, QualType T) {
   // In C, function calls are always rvalues.
-  if (!Ctx.getLangOpts().CPlusPlus) return Cl::CL_PRValue;
+  if (!Ctx.getLangOpts().CPlusPlus)
+    return Cl::CL_PRValue;
 
   // C++ [expr.call]p10: A function call is an lvalue if the result type is an
   //   lvalue reference type or an rvalue reference to function type, an xvalue
@@ -490,17 +493,17 @@
   //   otherwise.
   if (T->isLValueReferenceType())
     return Cl::CL_LValue;
-  const auto *RV = T->getAs<RValueReferenceType>();
+  auto const *RV = T->getAs<RValueReferenceType>();
   if (!RV) // Could still be a class temporary, though.
     return ClassifyTemporary(T);
 
   return RV->getPointeeType()->isFunctionType() ? Cl::CL_LValue : Cl::CL_XValue;
 }
 
-static Cl::Kinds ClassifyMemberExpr(ASTContext &Ctx, const MemberExpr *E) {
+static Cl::Kinds ClassifyMemberExpr(ASTContext &Ctx, MemberExpr const *E) {
   if (E->getType() == Ctx.UnknownAnyTy)
-    return (isa<FunctionDecl>(E->getMemberDecl())
-              ? Cl::CL_PRValue : Cl::CL_LValue);
+    return (isa<FunctionDecl>(E->getMemberDecl()) ? Cl::CL_PRValue
+                                                  : Cl::CL_LValue);
 
   // Handle C first, it's easier.
   if (!Ctx.getLangOpts().CPlusPlus) {
@@ -520,7 +523,7 @@
   // C++ [expr.ref]p3: E1->E2 is converted to the equivalent form (*(E1)).E2.
   // C++ [expr.ref]p4: If E2 is declared to have type "reference to T", then
   //   E1.E2 is an lvalue.
-  if (const auto *Value = dyn_cast<ValueDecl>(Member))
+  if (auto const *Value = dyn_cast<ValueDecl>(Member))
     if (Value->getType()->isReferenceType())
       return Cl::CL_LValue;
 
@@ -546,7 +549,7 @@
   //      -- If it refers to a static member function [...], then E1.E2 is an
   //         lvalue; [...]
   //      -- Otherwise [...] E1.E2 is a prvalue.
-  if (const auto *Method = dyn_cast<CXXMethodDecl>(Member))
+  if (auto const *Method = dyn_cast<CXXMethodDecl>(Member))
     return Method->isStatic() ? Cl::CL_LValue : Cl::CL_MemberFunction;
 
   //   -- If E2 is a member enumerator [...], the expression E1.E2 is a prvalue.
@@ -554,14 +557,13 @@
   return Cl::CL_PRValue;
 }
 
-static Cl::Kinds ClassifyBinaryOp(ASTContext &Ctx, const BinaryOperator *E) {
-  assert(Ctx.getLangOpts().CPlusPlus &&
-         "This is only relevant for C++.");
+static Cl::Kinds ClassifyBinaryOp(ASTContext &Ctx, BinaryOperator const *E) {
+  assert(Ctx.getLangOpts().CPlusPlus && "This is only relevant for C++.");
   // C++ [expr.ass]p1: All [...] return an lvalue referring to the left operand.
   // Except we override this for writes to ObjC properties.
   if (E->isAssignmentOp())
-    return (E->getLHS()->getObjectKind() == OK_ObjCProperty
-              ? Cl::CL_PRValue : Cl::CL_LValue);
+    return (E->getLHS()->getObjectKind() == OK_ObjCProperty ? Cl::CL_PRValue
+                                                            : Cl::CL_LValue);
 
   // C++ [expr.comma]p1: the result is of the same value category as its right
   //   operand, [...].
@@ -574,25 +576,24 @@
   if (E->getOpcode() == BO_PtrMemD)
     return (E->getType()->isFunctionType() ||
             E->hasPlaceholderType(BuiltinType::BoundMember))
-             ? Cl::CL_MemberFunction
-             : ClassifyInternal(Ctx, E->getLHS());
+               ? Cl::CL_MemberFunction
+               : ClassifyInternal(Ctx, E->getLHS());
 
   // C++ [expr.mptr.oper]p6: The result of an ->* expression is an lvalue if its
   //   second operand is a pointer to data member and a prvalue otherwise.
   if (E->getOpcode() == BO_PtrMemI)
     return (E->getType()->isFunctionType() ||
             E->hasPlaceholderType(BuiltinType::BoundMember))
-             ? Cl::CL_MemberFunction
-             : Cl::CL_LValue;
+               ? Cl::CL_MemberFunction
+               : Cl::CL_LValue;
 
   // All other binary operations are prvalues.
   return Cl::CL_PRValue;
 }
 
-static Cl::Kinds ClassifyConditional(ASTContext &Ctx, const Expr *True,
-                                     const Expr *False) {
-  assert(Ctx.getLangOpts().CPlusPlus &&
-         "This is only relevant for C++.");
+static Cl::Kinds ClassifyConditional(ASTContext &Ctx, Expr const *True,
+                                     Expr const *False) {
+  assert(Ctx.getLangOpts().CPlusPlus && "This is only relevant for C++.");
 
   // C++ [expr.cond]p2
   //   If either the second or the third operand has type (cv) void,
@@ -603,7 +604,7 @@
     // category of the other.
     bool TrueIsThrow = isa<CXXThrowExpr>(True->IgnoreParenImpCasts());
     bool FalseIsThrow = isa<CXXThrowExpr>(False->IgnoreParenImpCasts());
-    if (const Expr *NonThrow = TrueIsThrow ? (FalseIsThrow ? nullptr : False)
+    if (Expr const *NonThrow = TrueIsThrow ? (FalseIsThrow ? nullptr : False)
                                            : (FalseIsThrow ? True : nullptr))
       return ClassifyInternal(Ctx, NonThrow);
 
@@ -621,14 +622,14 @@
   return LCl == RCl ? LCl : Cl::CL_PRValue;
 }
 
-static Cl::ModifiableType IsModifiable(ASTContext &Ctx, const Expr *E,
+static Cl::ModifiableType IsModifiable(ASTContext &Ctx, Expr const *E,
                                        Cl::Kinds Kind, SourceLocation &Loc) {
   // As a general rule, we only care about lvalues. But there are some rvalues
   // for which we want to generate special results.
   if (Kind == Cl::CL_PRValue) {
     // For the sake of better diagnostics, we want to specifically recognize
     // use of the GCC cast-as-lvalue extension.
-    if (const auto *CE = dyn_cast<ExplicitCastExpr>(E->IgnoreParens())) {
+    if (auto const *CE = dyn_cast<ExplicitCastExpr>(E->IgnoreParens())) {
       if (CE->getSubExpr()->IgnoreParenImpCasts()->isLValue()) {
         Loc = CE->getExprLoc();
         return Cl::CM_LValueCast;
@@ -645,7 +646,7 @@
 
   // Assignment to a property in ObjC is an implicit setter access. But a
   // setter might not exist.
-  if (const auto *Expr = dyn_cast<ObjCPropertyRefExpr>(E)) {
+  if (auto const *Expr = dyn_cast<ObjCPropertyRefExpr>(E)) {
     if (Expr->isImplicitProperty() &&
         Expr->getImplicitPropertySetter() == nullptr)
       return Cl::CM_NoSetterProperty;
@@ -667,7 +668,7 @@
     return Cl::CM_IncompleteType;
 
   // Records with any const fields (recursively) are not modifiable.
-  if (const RecordType *R = CT->getAs<RecordType>())
+  if (RecordType const *R = CT->getAs<RecordType>())
     if (R->hasConstFields())
       return Cl::CM_ConstQualifiedField;
 
@@ -677,18 +678,30 @@
 Expr::LValueClassification Expr::ClassifyLValue(ASTContext &Ctx) const {
   Classification VC = Classify(Ctx);
   switch (VC.getKind()) {
-  case Cl::CL_LValue: return LV_Valid;
-  case Cl::CL_XValue: return LV_InvalidExpression;
-  case Cl::CL_Function: return LV_NotObjectType;
-  case Cl::CL_Void: return LV_InvalidExpression;
-  case Cl::CL_AddressableVoid: return LV_IncompleteVoidType;
-  case Cl::CL_DuplicateVectorComponents: return LV_DuplicateVectorComponents;
-  case Cl::CL_MemberFunction: return LV_MemberFunction;
-  case Cl::CL_SubObjCPropertySetting: return LV_SubObjCPropertySetting;
-  case Cl::CL_ClassTemporary: return LV_ClassTemporary;
-  case Cl::CL_ArrayTemporary: return LV_ArrayTemporary;
-  case Cl::CL_ObjCMessageRValue: return LV_InvalidMessageExpression;
-  case Cl::CL_PRValue: return LV_InvalidExpression;
+  case Cl::CL_LValue:
+    return LV_Valid;
+  case Cl::CL_XValue:
+    return LV_InvalidExpression;
+  case Cl::CL_Function:
+    return LV_NotObjectType;
+  case Cl::CL_Void:
+    return LV_InvalidExpression;
+  case Cl::CL_AddressableVoid:
+    return LV_IncompleteVoidType;
+  case Cl::CL_DuplicateVectorComponents:
+    return LV_DuplicateVectorComponents;
+  case Cl::CL_MemberFunction:
+    return LV_MemberFunction;
+  case Cl::CL_SubObjCPropertySetting:
+    return LV_SubObjCPropertySetting;
+  case Cl::CL_ClassTemporary:
+    return LV_ClassTemporary;
+  case Cl::CL_ArrayTemporary:
+    return LV_ArrayTemporary;
+  case Cl::CL_ObjCMessageRValue:
+    return LV_InvalidMessageExpression;
+  case Cl::CL_PRValue:
+    return LV_InvalidExpression;
   }
   llvm_unreachable("Unhandled kind");
 }
@@ -698,35 +711,56 @@
   SourceLocation dummy;
   Classification VC = ClassifyModifiable(Ctx, Loc ? *Loc : dummy);
   switch (VC.getKind()) {
-  case Cl::CL_LValue: break;
-  case Cl::CL_XValue: return MLV_InvalidExpression;
-  case Cl::CL_Function: return MLV_NotObjectType;
-  case Cl::CL_Void: return MLV_InvalidExpression;
-  case Cl::CL_AddressableVoid: return MLV_IncompleteVoidType;
-  case Cl::CL_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
-  case Cl::CL_MemberFunction: return MLV_MemberFunction;
-  case Cl::CL_SubObjCPropertySetting: return MLV_SubObjCPropertySetting;
-  case Cl::CL_ClassTemporary: return MLV_ClassTemporary;
-  case Cl::CL_ArrayTemporary: return MLV_ArrayTemporary;
-  case Cl::CL_ObjCMessageRValue: return MLV_InvalidMessageExpression;
+  case Cl::CL_LValue:
+    break;
+  case Cl::CL_XValue:
+    return MLV_InvalidExpression;
+  case Cl::CL_Function:
+    return MLV_NotObjectType;
+  case Cl::CL_Void:
+    return MLV_InvalidExpression;
+  case Cl::CL_AddressableVoid:
+    return MLV_IncompleteVoidType;
+  case Cl::CL_DuplicateVectorComponents:
+    return MLV_DuplicateVectorComponents;
+  case Cl::CL_MemberFunction:
+    return MLV_MemberFunction;
+  case Cl::CL_SubObjCPropertySetting:
+    return MLV_SubObjCPropertySetting;
+  case Cl::CL_ClassTemporary:
+    return MLV_ClassTemporary;
+  case Cl::CL_ArrayTemporary:
+    return MLV_ArrayTemporary;
+  case Cl::CL_ObjCMessageRValue:
+    return MLV_InvalidMessageExpression;
   case Cl::CL_PRValue:
-    return VC.getModifiable() == Cl::CM_LValueCast ?
-      MLV_LValueCast : MLV_InvalidExpression;
+    return VC.getModifiable() == Cl::CM_LValueCast ? MLV_LValueCast
+                                                   : MLV_InvalidExpression;
   }
   assert(VC.getKind() == Cl::CL_LValue && "Unhandled kind");
   switch (VC.getModifiable()) {
-  case Cl::CM_Untested: llvm_unreachable("Did not test modifiability");
-  case Cl::CM_Modifiable: return MLV_Valid;
-  case Cl::CM_RValue: llvm_unreachable("CM_RValue and CL_LValue don't match");
-  case Cl::CM_Function: return MLV_NotObjectType;
+  case Cl::CM_Untested:
+    llvm_unreachable("Did not test modifiability");
+  case Cl::CM_Modifiable:
+    return MLV_Valid;
+  case Cl::CM_RValue:
+    llvm_unreachable("CM_RValue and CL_LValue don't match");
+  case Cl::CM_Function:
+    return MLV_NotObjectType;
   case Cl::CM_LValueCast:
     llvm_unreachable("CM_LValueCast and CL_LValue don't match");
-  case Cl::CM_NoSetterProperty: return MLV_NoSetterProperty;
-  case Cl::CM_ConstQualified: return MLV_ConstQualified;
-  case Cl::CM_ConstQualifiedField: return MLV_ConstQualifiedField;
-  case Cl::CM_ConstAddrSpace: return MLV_ConstAddrSpace;
-  case Cl::CM_ArrayType: return MLV_ArrayType;
-  case Cl::CM_IncompleteType: return MLV_IncompleteType;
+  case Cl::CM_NoSetterProperty:
+    return MLV_NoSetterProperty;
+  case Cl::CM_ConstQualified:
+    return MLV_ConstQualified;
+  case Cl::CM_ConstQualifiedField:
+    return MLV_ConstQualifiedField;
+  case Cl::CM_ConstAddrSpace:
+    return MLV_ConstAddrSpace;
+  case Cl::CM_ArrayType:
+    return MLV_ArrayType;
+  case Cl::CM_IncompleteType:
+    return MLV_IncompleteType;
   }
   llvm_unreachable("Unhandled modifiable type");
 }
Index: clang/lib/AST/ExprConcepts.cpp
===================================================================
--- clang/lib/AST/ExprConcepts.cpp
+++ clang/lib/AST/ExprConcepts.cpp
@@ -31,12 +31,12 @@
 using namespace clang;
 
 ConceptSpecializationExpr::ConceptSpecializationExpr(
-    const ASTContext &C, NestedNameSpecifierLoc NNS,
+    ASTContext const &C, NestedNameSpecifierLoc NNS,
     SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
     NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
-    const ASTTemplateArgumentListInfo *ArgsAsWritten,
+    ASTTemplateArgumentListInfo const *ArgsAsWritten,
     ArrayRef<TemplateArgument> ConvertedArgs,
-    const ConstraintSatisfaction *Satisfaction)
+    ConstraintSatisfaction const *Satisfaction)
     : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_PRValue, OK_Ordinary),
       ConceptReference(NNS, TemplateKWLoc, ConceptNameInfo, FoundDecl,
                        NamedConcept, ArgsAsWritten),
@@ -48,18 +48,19 @@
   setDependence(computeDependence(this, /*ValueDependent=*/!Satisfaction));
 
   // Currently guaranteed by the fact concepts can only be at namespace-scope.
-  assert(!NestedNameSpec ||
-         (!NestedNameSpec.getNestedNameSpecifier()->isInstantiationDependent() &&
-          !NestedNameSpec.getNestedNameSpecifier()
-              ->containsUnexpandedParameterPack()));
+  assert(
+      !NestedNameSpec ||
+      (!NestedNameSpec.getNestedNameSpecifier()->isInstantiationDependent() &&
+       !NestedNameSpec.getNestedNameSpecifier()
+            ->containsUnexpandedParameterPack()));
   assert((!isValueDependent() || isInstantiationDependent()) &&
          "should not be value-dependent");
 }
 
 ConceptSpecializationExpr::ConceptSpecializationExpr(EmptyShell Empty,
-    unsigned NumTemplateArgs)
+                                                     unsigned NumTemplateArgs)
     : Expr(ConceptSpecializationExprClass, Empty), ConceptReference(),
-      NumTemplateArgs(NumTemplateArgs) { }
+      NumTemplateArgs(NumTemplateArgs) {}
 
 void ConceptSpecializationExpr::setTemplateArguments(
     ArrayRef<TemplateArgument> Converted) {
@@ -68,28 +69,24 @@
                           getTrailingObjects<TemplateArgument>());
 }
 
-ConceptSpecializationExpr *
-ConceptSpecializationExpr::Create(const ASTContext &C,
-                                  NestedNameSpecifierLoc NNS,
-                                  SourceLocation TemplateKWLoc,
-                                  DeclarationNameInfo ConceptNameInfo,
-                                  NamedDecl *FoundDecl,
-                                  ConceptDecl *NamedConcept,
-                               const ASTTemplateArgumentListInfo *ArgsAsWritten,
-                                  ArrayRef<TemplateArgument> ConvertedArgs,
-                                  const ConstraintSatisfaction *Satisfaction) {
-  void *Buffer = C.Allocate(totalSizeToAlloc<TemplateArgument>(
-                                ConvertedArgs.size()));
-  return new (Buffer) ConceptSpecializationExpr(C, NNS, TemplateKWLoc,
-                                                ConceptNameInfo, FoundDecl,
-                                                NamedConcept, ArgsAsWritten,
-                                                ConvertedArgs, Satisfaction);
+ConceptSpecializationExpr *ConceptSpecializationExpr::Create(
+    ASTContext const &C, NestedNameSpecifierLoc NNS,
+    SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
+    NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
+    ASTTemplateArgumentListInfo const *ArgsAsWritten,
+    ArrayRef<TemplateArgument> ConvertedArgs,
+    ConstraintSatisfaction const *Satisfaction) {
+  void *Buffer =
+      C.Allocate(totalSizeToAlloc<TemplateArgument>(ConvertedArgs.size()));
+  return new (Buffer) ConceptSpecializationExpr(
+      C, NNS, TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
+      ArgsAsWritten, ConvertedArgs, Satisfaction);
 }
 
 ConceptSpecializationExpr::ConceptSpecializationExpr(
-    const ASTContext &C, ConceptDecl *NamedConcept,
+    ASTContext const &C, ConceptDecl *NamedConcept,
     ArrayRef<TemplateArgument> ConvertedArgs,
-    const ConstraintSatisfaction *Satisfaction, bool Dependent,
+    ConstraintSatisfaction const *Satisfaction, bool Dependent,
     bool ContainsUnexpandedParameterPack)
     : Expr(ConceptSpecializationExprClass, C.BoolTy, VK_PRValue, OK_Ordinary),
       ConceptReference(NestedNameSpecifierLoc(), SourceLocation(),
@@ -110,35 +107,31 @@
   setDependence(D);
 }
 
-ConceptSpecializationExpr *
-ConceptSpecializationExpr::Create(const ASTContext &C,
-                                  ConceptDecl *NamedConcept,
-                                  ArrayRef<TemplateArgument> ConvertedArgs,
-                                  const ConstraintSatisfaction *Satisfaction,
-                                  bool Dependent,
-                                  bool ContainsUnexpandedParameterPack) {
-  void *Buffer = C.Allocate(totalSizeToAlloc<TemplateArgument>(
-                                ConvertedArgs.size()));
-  return new (Buffer) ConceptSpecializationExpr(
-      C, NamedConcept, ConvertedArgs, Satisfaction, Dependent,
-      ContainsUnexpandedParameterPack);
+ConceptSpecializationExpr *ConceptSpecializationExpr::Create(
+    ASTContext const &C, ConceptDecl *NamedConcept,
+    ArrayRef<TemplateArgument> ConvertedArgs,
+    ConstraintSatisfaction const *Satisfaction, bool Dependent,
+    bool ContainsUnexpandedParameterPack) {
+  void *Buffer =
+      C.Allocate(totalSizeToAlloc<TemplateArgument>(ConvertedArgs.size()));
+  return new (Buffer)
+      ConceptSpecializationExpr(C, NamedConcept, ConvertedArgs, Satisfaction,
+                                Dependent, ContainsUnexpandedParameterPack);
 }
 
 ConceptSpecializationExpr *
 ConceptSpecializationExpr::Create(ASTContext &C, EmptyShell Empty,
                                   unsigned NumTemplateArgs) {
-  void *Buffer = C.Allocate(totalSizeToAlloc<TemplateArgument>(
-                                NumTemplateArgs));
+  void *Buffer =
+      C.Allocate(totalSizeToAlloc<TemplateArgument>(NumTemplateArgs));
   return new (Buffer) ConceptSpecializationExpr(Empty, NumTemplateArgs);
 }
 
-const TypeConstraint *
+TypeConstraint const *
 concepts::ExprRequirement::ReturnTypeRequirement::getTypeConstraint() const {
   assert(isTypeConstraint());
-  auto TPL =
-      TypeConstraintInfo.getPointer().get<TemplateParameterList *>();
-  return cast<TemplateTypeParmDecl>(TPL->getParam(0))
-      ->getTypeConstraint();
+  auto TPL = TypeConstraintInfo.getPointer().get<TemplateParameterList *>();
+  return cast<TemplateTypeParmDecl>(TPL->getParam(0))->getTypeConstraint();
 }
 
 RequiresExpr::RequiresExpr(ASTContext &C, SourceLocation RequiresKWLoc,
@@ -187,15 +180,13 @@
 RequiresExpr::RequiresExpr(ASTContext &C, EmptyShell Empty,
                            unsigned NumLocalParameters,
                            unsigned NumRequirements)
-  : Expr(RequiresExprClass, Empty), NumLocalParameters(NumLocalParameters),
-    NumRequirements(NumRequirements) { }
+    : Expr(RequiresExprClass, Empty), NumLocalParameters(NumLocalParameters),
+      NumRequirements(NumRequirements) {}
 
-RequiresExpr *
-RequiresExpr::Create(ASTContext &C, SourceLocation RequiresKWLoc,
-                     RequiresExprBodyDecl *Body,
-                     ArrayRef<ParmVarDecl *> LocalParameters,
-                     ArrayRef<concepts::Requirement *> Requirements,
-                     SourceLocation RBraceLoc) {
+RequiresExpr *RequiresExpr::Create(
+    ASTContext &C, SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body,
+    ArrayRef<ParmVarDecl *> LocalParameters,
+    ArrayRef<concepts::Requirement *> Requirements, SourceLocation RBraceLoc) {
   void *Mem =
       C.Allocate(totalSizeToAlloc<ParmVarDecl *, concepts::Requirement *>(
                      LocalParameters.size(), Requirements.size()),
@@ -204,9 +195,9 @@
                                 Requirements, RBraceLoc);
 }
 
-RequiresExpr *
-RequiresExpr::Create(ASTContext &C, EmptyShell Empty,
-                     unsigned NumLocalParameters, unsigned NumRequirements) {
+RequiresExpr *RequiresExpr::Create(ASTContext &C, EmptyShell Empty,
+                                   unsigned NumLocalParameters,
+                                   unsigned NumRequirements) {
   void *Mem =
       C.Allocate(totalSizeToAlloc<ParmVarDecl *, concepts::Requirement *>(
                      NumLocalParameters, NumRequirements),
Index: clang/lib/AST/ExprConstant.cpp
===================================================================
--- clang/lib/AST/ExprConstant.cpp
+++ clang/lib/AST/ExprConstant.cpp
@@ -64,1345 +64,1318 @@
 
 using namespace clang;
 using llvm::APFixedPoint;
+using llvm::APFloat;
 using llvm::APInt;
 using llvm::APSInt;
-using llvm::APFloat;
 using llvm::FixedPointSemantics;
 using llvm::Optional;
 
 namespace {
-  struct LValue;
-  class CallStackFrame;
-  class EvalInfo;
+struct LValue;
+class CallStackFrame;
+class EvalInfo;
 
-  using SourceLocExprScopeGuard =
-      CurrentSourceLocExprScope::SourceLocExprScopeGuard;
+using SourceLocExprScopeGuard =
+    CurrentSourceLocExprScope::SourceLocExprScopeGuard;
 
-  static QualType getType(APValue::LValueBase B) {
-    return B.getType();
-  }
+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();
-  }
+/// Get an LValue path entry, which is known to not be an array index, as a
+/// field declaration.
+static FieldDecl const *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 CXXRecordDecl const *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->isPRValue())
-      return E->getType();
-    return Ctx.getLValueReferenceType(E->getType());
-  }
+/// Given an expression, determine the type used to store the result of
+/// evaluating that expression.
+static QualType getStorageType(ASTContext const &Ctx, Expr const *E) {
+  if (E->isPRValue())
+    return E->getType();
+  return Ctx.getLValueReferenceType(E->getType());
+}
 
-  /// Given a CallExpr, try to get the alloc_size attribute. May return null.
-  static const AllocSizeAttr *getAllocSizeAttr(const CallExpr *CE) {
-    if (const FunctionDecl *DirectCallee = CE->getDirectCallee())
-      return DirectCallee->getAttr<AllocSizeAttr>();
-    if (const Decl *IndirectCallee = CE->getCalleeDecl())
-      return IndirectCallee->getAttr<AllocSizeAttr>();
+/// Given a CallExpr, try to get the alloc_size attribute. May return null.
+static AllocSizeAttr const *getAllocSizeAttr(CallExpr const *CE) {
+  if (FunctionDecl const *DirectCallee = CE->getDirectCallee())
+    return DirectCallee->getAttr<AllocSizeAttr>();
+  if (Decl const *IndirectCallee = CE->getCalleeDecl())
+    return IndirectCallee->getAttr<AllocSizeAttr>();
+  return nullptr;
+}
+
+/// Attempts to unwrap a CallExpr (with an alloc_size attribute) from an Expr.
+/// This will look through a single cast.
+///
+/// Returns null if we couldn't unwrap a function with alloc_size.
+static CallExpr const *tryUnwrapAllocSizeCall(Expr const *E) {
+  if (!E->getType()->isPointerType())
     return nullptr;
-  }
 
-  /// Attempts to unwrap a CallExpr (with an alloc_size attribute) from an Expr.
-  /// This will look through a single cast.
-  ///
-  /// Returns null if we couldn't unwrap a function with alloc_size.
-  static const CallExpr *tryUnwrapAllocSizeCall(const Expr *E) {
-    if (!E->getType()->isPointerType())
-      return nullptr;
+  E = E->IgnoreParens();
+  // If we're doing a variable assignment from e.g. malloc(N), there will
+  // probably be a cast of some kind. In exotic cases, we might also see a
+  // top-level ExprWithCleanups. Ignore them either way.
+  if (auto const *FE = dyn_cast<FullExpr>(E))
+    E = FE->getSubExpr()->IgnoreParens();
 
-    E = E->IgnoreParens();
-    // If we're doing a variable assignment from e.g. malloc(N), there will
-    // probably be a cast of some kind. In exotic cases, we might also see a
-    // top-level ExprWithCleanups. Ignore them either way.
-    if (const auto *FE = dyn_cast<FullExpr>(E))
-      E = FE->getSubExpr()->IgnoreParens();
+  if (auto const *Cast = dyn_cast<CastExpr>(E))
+    E = Cast->getSubExpr()->IgnoreParens();
 
-    if (const auto *Cast = dyn_cast<CastExpr>(E))
-      E = Cast->getSubExpr()->IgnoreParens();
+  if (auto const *CE = dyn_cast<CallExpr>(E))
+    return getAllocSizeAttr(CE) ? CE : nullptr;
+  return nullptr;
+}
 
-    if (const auto *CE = dyn_cast<CallExpr>(E))
-      return getAllocSizeAttr(CE) ? CE : nullptr;
-    return nullptr;
-  }
+/// Determines whether or not the given Base contains a call to a function
+/// with the alloc_size attribute.
+static bool isBaseAnAllocSizeCall(APValue::LValueBase Base) {
+  auto const *E = Base.dyn_cast<Expr const *>();
+  return E && E->getType()->isPointerType() && tryUnwrapAllocSizeCall(E);
+}
 
-  /// Determines whether or not the given Base contains a call to a function
-  /// with the alloc_size attribute.
-  static bool isBaseAnAllocSizeCall(APValue::LValueBase Base) {
-    const auto *E = Base.dyn_cast<const Expr *>();
-    return E && E->getType()->isPointerType() && tryUnwrapAllocSizeCall(E);
+/// Determines whether the given kind of constant expression is only ever
+/// used for name mangling. If so, it's permitted to reference things that we
+/// can't generate code for (in particular, dllimported functions).
+static bool isForManglingOnly(ConstantExprKind Kind) {
+  switch (Kind) {
+  case ConstantExprKind::Normal:
+  case ConstantExprKind::ClassTemplateArgument:
+  case ConstantExprKind::ImmediateInvocation:
+    // Note that non-type template arguments of class type are emitted as
+    // template parameter objects.
+    return false;
+
+  case ConstantExprKind::NonClassTemplateArgument:
+    return true;
   }
+  llvm_unreachable("unknown ConstantExprKind");
+}
 
-  /// Determines whether the given kind of constant expression is only ever
-  /// used for name mangling. If so, it's permitted to reference things that we
-  /// can't generate code for (in particular, dllimported functions).
-  static bool isForManglingOnly(ConstantExprKind Kind) {
-    switch (Kind) {
-    case ConstantExprKind::Normal:
-    case ConstantExprKind::ClassTemplateArgument:
-    case ConstantExprKind::ImmediateInvocation:
-      // Note that non-type template arguments of class type are emitted as
-      // template parameter objects.
-      return false;
+static bool isTemplateArgument(ConstantExprKind Kind) {
+  switch (Kind) {
+  case ConstantExprKind::Normal:
+  case ConstantExprKind::ImmediateInvocation:
+    return false;
 
-    case ConstantExprKind::NonClassTemplateArgument:
-      return true;
-    }
-    llvm_unreachable("unknown ConstantExprKind");
+  case ConstantExprKind::ClassTemplateArgument:
+  case ConstantExprKind::NonClassTemplateArgument:
+    return true;
   }
+  llvm_unreachable("unknown ConstantExprKind");
+}
 
-  static bool isTemplateArgument(ConstantExprKind Kind) {
-    switch (Kind) {
-    case ConstantExprKind::Normal:
-    case ConstantExprKind::ImmediateInvocation:
-      return false;
+/// The bound to claim that an array of unknown bound has.
+/// The value in MostDerivedArraySize is undefined in this case. So, set it
+/// to an arbitrary value that's likely to loudly break things if it's used.
+static const uint64_t AssumedSizeForUnsizedArray =
+    std::numeric_limits<uint64_t>::max() / 2;
 
-    case ConstantExprKind::ClassTemplateArgument:
-    case ConstantExprKind::NonClassTemplateArgument:
-      return true;
-    }
-    llvm_unreachable("unknown ConstantExprKind");
-  }
-
-  /// The bound to claim that an array of unknown bound has.
-  /// The value in MostDerivedArraySize is undefined in this case. So, set it
-  /// to an arbitrary value that's likely to loudly break things if it's used.
-  static const uint64_t AssumedSizeForUnsizedArray =
-      std::numeric_limits<uint64_t>::max() / 2;
-
-  /// Determines if an LValue with the given LValueBase will have an unsized
-  /// array in its designator.
-  /// Find the path length and type of the most-derived subobject in the given
-  /// path, and find the size of the containing array, if any.
-  static unsigned
-  findMostDerivedSubobject(ASTContext &Ctx, APValue::LValueBase Base,
-                           ArrayRef<APValue::LValuePathEntry> Path,
-                           uint64_t &ArraySize, QualType &Type, bool &IsArray,
-                           bool &FirstEntryIsUnsizedArray) {
-    // This only accepts LValueBases from APValues, and APValues don't support
-    // arrays that lack size info.
-    assert(!isBaseAnAllocSizeCall(Base) &&
-           "Unsized arrays shouldn't appear here");
-    unsigned MostDerivedLength = 0;
-    Type = getType(Base);
-
-    for (unsigned I = 0, N = Path.size(); I != N; ++I) {
-      if (Type->isArrayType()) {
-        const ArrayType *AT = Ctx.getAsArrayType(Type);
-        Type = AT->getElementType();
-        MostDerivedLength = I + 1;
-        IsArray = true;
-
-        if (auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
-          ArraySize = CAT->getSize().getZExtValue();
-        } else {
-          assert(I == 0 && "unexpected unsized array designator");
-          FirstEntryIsUnsizedArray = true;
-          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])) {
-        Type = FD->getType();
-        ArraySize = 0;
-        MostDerivedLength = I + 1;
-        IsArray = false;
+/// Determines if an LValue with the given LValueBase will have an unsized
+/// array in its designator.
+/// Find the path length and type of the most-derived subobject in the given
+/// path, and find the size of the containing array, if any.
+static unsigned
+findMostDerivedSubobject(ASTContext &Ctx, APValue::LValueBase Base,
+                         ArrayRef<APValue::LValuePathEntry> Path,
+                         uint64_t &ArraySize, QualType &Type, bool &IsArray,
+                         bool &FirstEntryIsUnsizedArray) {
+  // This only accepts LValueBases from APValues, and APValues don't support
+  // arrays that lack size info.
+  assert(!isBaseAnAllocSizeCall(Base) &&
+         "Unsized arrays shouldn't appear here");
+  unsigned MostDerivedLength = 0;
+  Type = getType(Base);
+
+  for (unsigned I = 0, N = Path.size(); I != N; ++I) {
+    if (Type->isArrayType()) {
+      ArrayType const *AT = Ctx.getAsArrayType(Type);
+      Type = AT->getElementType();
+      MostDerivedLength = I + 1;
+      IsArray = true;
+
+      if (auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
+        ArraySize = CAT->getSize().getZExtValue();
       } else {
-        // Path[I] describes a base class.
-        ArraySize = 0;
-        IsArray = false;
-      }
-    }
-    return MostDerivedLength;
-  }
-
-  /// A path from a glvalue to a subobject of that glvalue.
-  struct SubobjectDesignator {
-    /// True if the subobject was named in a manner not supported by C++11. Such
-    /// lvalues can still be folded, but they are not core constant expressions
-    /// and we cannot perform lvalue-to-rvalue conversions on them.
-    unsigned Invalid : 1;
-
-    /// Is this a pointer one past the end of an object?
-    unsigned IsOnePastTheEnd : 1;
-
-    /// Indicator of whether the first entry is an unsized array.
-    unsigned FirstEntryIsAnUnsizedArray : 1;
-
-    /// Indicator of whether the most-derived object is an array element.
-    unsigned MostDerivedIsArrayElement : 1;
-
-    /// The length of the path to the most-derived object of which this is a
-    /// subobject.
-    unsigned MostDerivedPathLength : 28;
-
-    /// The size of the array of which the most-derived object is an element.
-    /// This will always be 0 if the most-derived object is not an array
-    /// element. 0 is not an indicator of whether or not the most-derived object
-    /// is an array, however, because 0-length arrays are allowed.
-    ///
-    /// If the current array is an unsized array, the value of this is
-    /// undefined.
-    uint64_t MostDerivedArraySize;
-
-    /// The type of the most derived object referred to by this address.
-    QualType MostDerivedType;
-
-    typedef APValue::LValuePathEntry PathEntry;
-
-    /// The entries on the path from the glvalue to the designated subobject.
-    SmallVector<PathEntry, 8> Entries;
-
-    SubobjectDesignator() : Invalid(true) {}
-
-    explicit SubobjectDesignator(QualType T)
-        : Invalid(false), IsOnePastTheEnd(false),
-          FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
-          MostDerivedPathLength(0), MostDerivedArraySize(0),
-          MostDerivedType(T) {}
-
-    SubobjectDesignator(ASTContext &Ctx, const APValue &V)
-        : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false),
-          FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
-          MostDerivedPathLength(0), MostDerivedArraySize(0) {
-      assert(V.isLValue() && "Non-LValue used to make an LValue designator?");
-      if (!Invalid) {
-        IsOnePastTheEnd = V.isLValueOnePastTheEnd();
-        ArrayRef<PathEntry> VEntries = V.getLValuePath();
-        Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());
-        if (V.getLValueBase()) {
-          bool IsArray = false;
-          bool FirstIsUnsizedArray = false;
-          MostDerivedPathLength = findMostDerivedSubobject(
-              Ctx, V.getLValueBase(), V.getLValuePath(), MostDerivedArraySize,
-              MostDerivedType, IsArray, FirstIsUnsizedArray);
-          MostDerivedIsArrayElement = IsArray;
-          FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
-        }
-      }
+        assert(I == 0 && "unexpected unsized array designator");
+        FirstEntryIsUnsizedArray = true;
+        ArraySize = AssumedSizeForUnsizedArray;
+      }
+    } else if (Type->isAnyComplexType()) {
+      ComplexType const *CT = Type->castAs<ComplexType>();
+      Type = CT->getElementType();
+      ArraySize = 2;
+      MostDerivedLength = I + 1;
+      IsArray = true;
+    } else if (FieldDecl const *FD = getAsField(Path[I])) {
+      Type = FD->getType();
+      ArraySize = 0;
+      MostDerivedLength = I + 1;
+      IsArray = false;
+    } else {
+      // Path[I] describes a base class.
+      ArraySize = 0;
+      IsArray = false;
     }
+  }
+  return MostDerivedLength;
+}
 
-    void truncate(ASTContext &Ctx, APValue::LValueBase Base,
-                  unsigned NewLength) {
-      if (Invalid)
-        return;
+/// A path from a glvalue to a subobject of that glvalue.
+struct SubobjectDesignator {
+  /// True if the subobject was named in a manner not supported by C++11. Such
+  /// lvalues can still be folded, but they are not core constant expressions
+  /// and we cannot perform lvalue-to-rvalue conversions on them.
+  unsigned Invalid : 1;
 
-      assert(Base && "cannot truncate path for null pointer");
-      assert(NewLength <= Entries.size() && "not a truncation");
+  /// Is this a pointer one past the end of an object?
+  unsigned IsOnePastTheEnd : 1;
 
-      if (NewLength == Entries.size())
-        return;
-      Entries.resize(NewLength);
+  /// Indicator of whether the first entry is an unsized array.
+  unsigned FirstEntryIsAnUnsizedArray : 1;
 
-      bool IsArray = false;
-      bool FirstIsUnsizedArray = false;
-      MostDerivedPathLength = findMostDerivedSubobject(
-          Ctx, Base, Entries, MostDerivedArraySize, MostDerivedType, IsArray,
-          FirstIsUnsizedArray);
-      MostDerivedIsArrayElement = IsArray;
-      FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
-    }
+  /// Indicator of whether the most-derived object is an array element.
+  unsigned MostDerivedIsArrayElement : 1;
 
-    void setInvalid() {
-      Invalid = true;
-      Entries.clear();
-    }
+  /// The length of the path to the most-derived object of which this is a
+  /// subobject.
+  unsigned MostDerivedPathLength : 28;
 
-    /// Determine whether the most derived subobject is an array without a
-    /// known bound.
-    bool isMostDerivedAnUnsizedArray() const {
-      assert(!Invalid && "Calling this makes no sense on invalid designators");
-      return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;
-    }
+  /// The size of the array of which the most-derived object is an element.
+  /// This will always be 0 if the most-derived object is not an array
+  /// element. 0 is not an indicator of whether or not the most-derived object
+  /// is an array, however, because 0-length arrays are allowed.
+  ///
+  /// If the current array is an unsized array, the value of this is
+  /// undefined.
+  uint64_t MostDerivedArraySize;
 
-    /// Determine what the most derived array's size is. Results in an assertion
-    /// failure if the most derived array lacks a size.
-    uint64_t getMostDerivedArraySize() const {
-      assert(!isMostDerivedAnUnsizedArray() && "Unsized array has no size");
-      return MostDerivedArraySize;
-    }
+  /// The type of the most derived object referred to by this address.
+  QualType MostDerivedType;
 
-    /// Determine whether this is a one-past-the-end pointer.
-    bool isOnePastTheEnd() const {
-      assert(!Invalid);
-      if (IsOnePastTheEnd)
-        return true;
-      if (!isMostDerivedAnUnsizedArray() && MostDerivedIsArrayElement &&
-          Entries[MostDerivedPathLength - 1].getAsArrayIndex() ==
-              MostDerivedArraySize)
-        return true;
-      return false;
-    }
+  typedef APValue::LValuePathEntry PathEntry;
 
-    /// Get the range of valid index adjustments in the form
-    ///   {maximum value that can be subtracted from this pointer,
-    ///    maximum value that can be added to this pointer}
-    std::pair<uint64_t, uint64_t> validIndexAdjustments() {
-      if (Invalid || isMostDerivedAnUnsizedArray())
-        return {0, 0};
+  /// The entries on the path from the glvalue to the designated subobject.
+  SmallVector<PathEntry, 8> Entries;
 
-      // [expr.add]p4: For the purposes of these operators, a pointer to a
-      // nonarray object behaves the same as a pointer to the first element of
-      // an array of length one with the type of the object as its element type.
-      bool IsArray = MostDerivedPathLength == Entries.size() &&
-                     MostDerivedIsArrayElement;
-      uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex()
-                                    : (uint64_t)IsOnePastTheEnd;
-      uint64_t ArraySize =
-          IsArray ? getMostDerivedArraySize() : (uint64_t)1;
-      return {ArrayIndex, ArraySize - ArrayIndex};
-    }
+  SubobjectDesignator() : Invalid(true) {}
 
-    /// Check that this refers to a valid subobject.
-    bool isValidSubobject() const {
-      if (Invalid)
-        return false;
-      return !isOnePastTheEnd();
-    }
-    /// Check that this refers to a valid subobject, and if not, produce a
-    /// relevant diagnostic and set the designator as invalid.
-    bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK);
+  explicit SubobjectDesignator(QualType T)
+      : Invalid(false), IsOnePastTheEnd(false),
+        FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
+        MostDerivedPathLength(0), MostDerivedArraySize(0), MostDerivedType(T) {}
 
-    /// 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()));
+  SubobjectDesignator(ASTContext &Ctx, APValue const &V)
+      : Invalid(!V.isLValue() || !V.hasLValuePath()), IsOnePastTheEnd(false),
+        FirstEntryIsAnUnsizedArray(false), MostDerivedIsArrayElement(false),
+        MostDerivedPathLength(0), MostDerivedArraySize(0) {
+    assert(V.isLValue() && "Non-LValue used to make an LValue designator?");
+    if (!Invalid) {
+      IsOnePastTheEnd = V.isLValueOnePastTheEnd();
+      ArrayRef<PathEntry> VEntries = V.getLValuePath();
+      Entries.insert(Entries.end(), VEntries.begin(), VEntries.end());
+      if (V.getLValueBase()) {
+        bool IsArray = false;
+        bool FirstIsUnsizedArray = false;
+        MostDerivedPathLength = findMostDerivedSubobject(
+            Ctx, V.getLValueBase(), V.getLValuePath(), MostDerivedArraySize,
+            MostDerivedType, IsArray, FirstIsUnsizedArray);
+        MostDerivedIsArrayElement = IsArray;
+        FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
+      }
     }
+  }
 
-    /// Update this designator to refer to the first element within this array.
-    void addArrayUnchecked(const ConstantArrayType *CAT) {
-      Entries.push_back(PathEntry::ArrayIndex(0));
+  void truncate(ASTContext &Ctx, APValue::LValueBase Base, unsigned NewLength) {
+    if (Invalid)
+      return;
 
-      // This is a most-derived object.
-      MostDerivedType = CAT->getElementType();
-      MostDerivedIsArrayElement = true;
-      MostDerivedArraySize = CAT->getSize().getZExtValue();
-      MostDerivedPathLength = Entries.size();
-    }
-    /// Update this designator to refer to the first element within the array of
-    /// elements of type T. This is an array of unknown size.
-    void addUnsizedArrayUnchecked(QualType ElemTy) {
-      Entries.push_back(PathEntry::ArrayIndex(0));
-
-      MostDerivedType = ElemTy;
-      MostDerivedIsArrayElement = true;
-      // The value in MostDerivedArraySize is undefined in this case. So, set it
-      // to an arbitrary value that's likely to loudly break things if it's
-      // used.
-      MostDerivedArraySize = AssumedSizeForUnsizedArray;
+    assert(Base && "cannot truncate path for null pointer");
+    assert(NewLength <= Entries.size() && "not a truncation");
+
+    if (NewLength == Entries.size())
+      return;
+    Entries.resize(NewLength);
+
+    bool IsArray = false;
+    bool FirstIsUnsizedArray = false;
+    MostDerivedPathLength =
+        findMostDerivedSubobject(Ctx, Base, Entries, MostDerivedArraySize,
+                                 MostDerivedType, IsArray, FirstIsUnsizedArray);
+    MostDerivedIsArrayElement = IsArray;
+    FirstEntryIsAnUnsizedArray = FirstIsUnsizedArray;
+  }
+
+  void setInvalid() {
+    Invalid = true;
+    Entries.clear();
+  }
+
+  /// Determine whether the most derived subobject is an array without a
+  /// known bound.
+  bool isMostDerivedAnUnsizedArray() const {
+    assert(!Invalid && "Calling this makes no sense on invalid designators");
+    return Entries.size() == 1 && FirstEntryIsAnUnsizedArray;
+  }
+
+  /// Determine what the most derived array's size is. Results in an assertion
+  /// failure if the most derived array lacks a size.
+  uint64_t getMostDerivedArraySize() const {
+    assert(!isMostDerivedAnUnsizedArray() && "Unsized array has no size");
+    return MostDerivedArraySize;
+  }
+
+  /// Determine whether this is a one-past-the-end pointer.
+  bool isOnePastTheEnd() const {
+    assert(!Invalid);
+    if (IsOnePastTheEnd)
+      return true;
+    if (!isMostDerivedAnUnsizedArray() && MostDerivedIsArrayElement &&
+        Entries[MostDerivedPathLength - 1].getAsArrayIndex() ==
+            MostDerivedArraySize)
+      return true;
+    return false;
+  }
+
+  /// Get the range of valid index adjustments in the form
+  ///   {maximum value that can be subtracted from this pointer,
+  ///    maximum value that can be added to this pointer}
+  std::pair<uint64_t, uint64_t> validIndexAdjustments() {
+    if (Invalid || isMostDerivedAnUnsizedArray())
+      return {0, 0};
+
+    // [expr.add]p4: For the purposes of these operators, a pointer to a
+    // nonarray object behaves the same as a pointer to the first element of
+    // an array of length one with the type of the object as its element type.
+    bool IsArray =
+        MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement;
+    uint64_t ArrayIndex =
+        IsArray ? Entries.back().getAsArrayIndex() : (uint64_t)IsOnePastTheEnd;
+    uint64_t ArraySize = IsArray ? getMostDerivedArraySize() : (uint64_t)1;
+    return {ArrayIndex, ArraySize - ArrayIndex};
+  }
+
+  /// Check that this refers to a valid subobject.
+  bool isValidSubobject() const {
+    if (Invalid)
+      return false;
+    return !isOnePastTheEnd();
+  }
+  /// Check that this refers to a valid subobject, and if not, produce a
+  /// relevant diagnostic and set the designator as invalid.
+  bool checkSubobject(EvalInfo &Info, Expr const *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()));
+  }
+
+  /// Update this designator to refer to the first element within this array.
+  void addArrayUnchecked(ConstantArrayType const *CAT) {
+    Entries.push_back(PathEntry::ArrayIndex(0));
+
+    // This is a most-derived object.
+    MostDerivedType = CAT->getElementType();
+    MostDerivedIsArrayElement = true;
+    MostDerivedArraySize = CAT->getSize().getZExtValue();
+    MostDerivedPathLength = Entries.size();
+  }
+  /// Update this designator to refer to the first element within the array of
+  /// elements of type T. This is an array of unknown size.
+  void addUnsizedArrayUnchecked(QualType ElemTy) {
+    Entries.push_back(PathEntry::ArrayIndex(0));
+
+    MostDerivedType = ElemTy;
+    MostDerivedIsArrayElement = true;
+    // The value in MostDerivedArraySize is undefined in this case. So, set it
+    // 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(Decl const *D, bool Virtual = false) {
+    Entries.push_back(APValue::BaseOrMemberType(D, Virtual));
+
+    // If this isn't a base class, it's a new most-derived object.
+    if (FieldDecl const *FD = dyn_cast<FieldDecl>(D)) {
+      MostDerivedType = FD->getType();
+      MostDerivedIsArrayElement = false;
+      MostDerivedArraySize = 0;
       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));
-
-      // 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();
-      }
-    }
-    /// Update this designator to refer to the given complex component.
-    void addComplexUnchecked(QualType EltTy, bool Imag) {
-      Entries.push_back(PathEntry::ArrayIndex(Imag));
+  }
+  /// Update this designator to refer to the given complex component.
+  void addComplexUnchecked(QualType EltTy, bool Imag) {
+    Entries.push_back(PathEntry::ArrayIndex(Imag));
 
-      // This is technically a most-derived object, though in practice this
-      // is unlikely to matter.
-      MostDerivedType = EltTy;
-      MostDerivedIsArrayElement = true;
-      MostDerivedArraySize = 2;
-      MostDerivedPathLength = Entries.size();
+    // This is technically a most-derived object, though in practice this
+    // is unlikely to matter.
+    MostDerivedType = EltTy;
+    MostDerivedIsArrayElement = true;
+    MostDerivedArraySize = 2;
+    MostDerivedPathLength = Entries.size();
+  }
+  void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, Expr const *E);
+  void diagnosePointerArithmetic(EvalInfo &Info, Expr const *E,
+                                 APSInt const &N);
+  /// Add N to the address of this subobject.
+  void adjustIndex(EvalInfo &Info, Expr const *E, APSInt N) {
+    if (Invalid || !N)
+      return;
+    uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
+    if (isMostDerivedAnUnsizedArray()) {
+      diagnoseUnsizedArrayPointerArithmetic(Info, E);
+      // Can't verify -- trust that the user is doing the right thing (or if
+      // not, trust that the caller will catch the bad behavior).
+      // FIXME: Should we reject if this overflows, at least?
+      Entries.back() =
+          PathEntry::ArrayIndex(Entries.back().getAsArrayIndex() + TruncatedN);
+      return;
     }
-    void diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info, const Expr *E);
-    void diagnosePointerArithmetic(EvalInfo &Info, const Expr *E,
-                                   const APSInt &N);
-    /// Add N to the address of this subobject.
-    void adjustIndex(EvalInfo &Info, const Expr *E, APSInt N) {
-      if (Invalid || !N) return;
-      uint64_t TruncatedN = N.extOrTrunc(64).getZExtValue();
-      if (isMostDerivedAnUnsizedArray()) {
-        diagnoseUnsizedArrayPointerArithmetic(Info, E);
-        // Can't verify -- trust that the user is doing the right thing (or if
-        // not, trust that the caller will catch the bad behavior).
-        // FIXME: Should we reject if this overflows, at least?
-        Entries.back() = PathEntry::ArrayIndex(
-            Entries.back().getAsArrayIndex() + TruncatedN);
-        return;
-      }
 
-      // [expr.add]p4: For the purposes of these operators, a pointer to a
-      // nonarray object behaves the same as a pointer to the first element of
-      // an array of length one with the type of the object as its element type.
-      bool IsArray = MostDerivedPathLength == Entries.size() &&
-                     MostDerivedIsArrayElement;
-      uint64_t ArrayIndex = IsArray ? Entries.back().getAsArrayIndex()
-                                    : (uint64_t)IsOnePastTheEnd;
-      uint64_t ArraySize =
-          IsArray ? getMostDerivedArraySize() : (uint64_t)1;
-
-      if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
-        // Calculate the actual index in a wide enough type, so we can include
-        // it in the note.
-        N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
-        (llvm::APInt&)N += ArrayIndex;
-        assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index");
-        diagnosePointerArithmetic(Info, E, N);
-        setInvalid();
-        return;
-      }
+    // [expr.add]p4: For the purposes of these operators, a pointer to a
+    // nonarray object behaves the same as a pointer to the first element of
+    // an array of length one with the type of the object as its element type.
+    bool IsArray =
+        MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement;
+    uint64_t ArrayIndex =
+        IsArray ? Entries.back().getAsArrayIndex() : (uint64_t)IsOnePastTheEnd;
+    uint64_t ArraySize = IsArray ? getMostDerivedArraySize() : (uint64_t)1;
+
+    if (N < -(int64_t)ArrayIndex || N > ArraySize - ArrayIndex) {
+      // Calculate the actual index in a wide enough type, so we can include
+      // it in the note.
+      N = N.extend(std::max<unsigned>(N.getBitWidth() + 1, 65));
+      (llvm::APInt &)N += ArrayIndex;
+      assert(N.ugt(ArraySize) && "bounds check failed for in-bounds index");
+      diagnosePointerArithmetic(Info, E, N);
+      setInvalid();
+      return;
+    }
 
-      ArrayIndex += TruncatedN;
-      assert(ArrayIndex <= ArraySize &&
-             "bounds check succeeded for out-of-bounds index");
+    ArrayIndex += TruncatedN;
+    assert(ArrayIndex <= ArraySize &&
+           "bounds check succeeded for out-of-bounds index");
 
-      if (IsArray)
-        Entries.back() = PathEntry::ArrayIndex(ArrayIndex);
-      else
-        IsOnePastTheEnd = (ArrayIndex != 0);
-    }
-  };
+    if (IsArray)
+      Entries.back() = PathEntry::ArrayIndex(ArrayIndex);
+    else
+      IsOnePastTheEnd = (ArrayIndex != 0);
+  }
+};
 
-  /// A scope at the end of which an object can need to be destroyed.
-  enum class ScopeKind {
-    Block,
-    FullExpression,
-    Call
-  };
+/// A scope at the end of which an object can need to be destroyed.
+enum class ScopeKind { Block, FullExpression, Call };
+
+/// A reference to a particular call and its arguments.
+struct CallRef {
+  CallRef() : OrigCallee(), CallIndex(0), Version() {}
+  CallRef(FunctionDecl const *Callee, unsigned CallIndex, unsigned Version)
+      : OrigCallee(Callee), CallIndex(CallIndex), Version(Version) {}
+
+  explicit operator bool() const { return OrigCallee; }
+
+  /// Get the parameter that the caller initialized, corresponding to the
+  /// given parameter in the callee.
+  ParmVarDecl const *getOrigParam(ParmVarDecl const *PVD) const {
+    return OrigCallee ? OrigCallee->getParamDecl(PVD->getFunctionScopeIndex())
+                      : PVD;
+  }
+
+  /// The callee at the point where the arguments were evaluated. This might
+  /// be different from the actual callee (a different redeclaration, or a
+  /// virtual override), but this function's parameters are the ones that
+  /// appear in the parameter map.
+  FunctionDecl const *OrigCallee;
+  /// The call index of the frame that holds the argument values.
+  unsigned CallIndex;
+  /// The version of the parameters corresponding to this call.
+  unsigned Version;
+};
 
-  /// A reference to a particular call and its arguments.
-  struct CallRef {
-    CallRef() : OrigCallee(), CallIndex(0), Version() {}
-    CallRef(const FunctionDecl *Callee, unsigned CallIndex, unsigned Version)
-        : OrigCallee(Callee), CallIndex(CallIndex), Version(Version) {}
-
-    explicit operator bool() const { return OrigCallee; }
-
-    /// Get the parameter that the caller initialized, corresponding to the
-    /// given parameter in the callee.
-    const ParmVarDecl *getOrigParam(const ParmVarDecl *PVD) const {
-      return OrigCallee ? OrigCallee->getParamDecl(PVD->getFunctionScopeIndex())
-                        : PVD;
-    }
-
-    /// The callee at the point where the arguments were evaluated. This might
-    /// be different from the actual callee (a different redeclaration, or a
-    /// virtual override), but this function's parameters are the ones that
-    /// appear in the parameter map.
-    const FunctionDecl *OrigCallee;
-    /// The call index of the frame that holds the argument values.
-    unsigned CallIndex;
-    /// The version of the parameters corresponding to this call.
-    unsigned Version;
-  };
+/// A stack frame in the constexpr call stack.
+class CallStackFrame : public interp::Frame {
+public:
+  EvalInfo &Info;
 
-  /// A stack frame in the constexpr call stack.
-  class CallStackFrame : public interp::Frame {
-  public:
-    EvalInfo &Info;
+  /// Parent - The caller of this stack frame.
+  CallStackFrame *Caller;
 
-    /// Parent - The caller of this stack frame.
-    CallStackFrame *Caller;
+  /// Callee - The function which was called.
+  FunctionDecl const *Callee;
 
-    /// Callee - The function which was called.
-    const FunctionDecl *Callee;
+  /// This - The binding for the this pointer in this call, if any.
+  LValue const *This;
 
-    /// This - The binding for the this pointer in this call, if any.
-    const LValue *This;
+  /// Information on how to find the arguments to this call. Our arguments
+  /// are stored in our parent's CallStackFrame, using the ParmVarDecl* as a
+  /// key and this value as the version.
+  CallRef Arguments;
 
-    /// Information on how to find the arguments to this call. Our arguments
-    /// are stored in our parent's CallStackFrame, using the ParmVarDecl* as a
-    /// key and this value as the version.
-    CallRef Arguments;
+  /// Source location information about the default argument or default
+  /// initializer expression we're evaluating, if any.
+  CurrentSourceLocExprScope CurSourceLocExprScope;
 
-    /// Source location information about the default argument or default
-    /// initializer expression we're evaluating, if any.
-    CurrentSourceLocExprScope CurSourceLocExprScope;
+  // Note that we intentionally use std::map here so that references to
+  // values are stable.
+  typedef std::pair<void const *, unsigned> MapKeyTy;
+  typedef std::map<MapKeyTy, APValue> MapTy;
+  /// Temporaries - Temporary lvalues materialized within this stack frame.
+  MapTy Temporaries;
 
-    // Note that we intentionally use std::map here so that references to
-    // values are stable.
-    typedef std::pair<const void *, unsigned> MapKeyTy;
-    typedef std::map<MapKeyTy, APValue> MapTy;
-    /// Temporaries - Temporary lvalues materialized within this stack frame.
-    MapTy Temporaries;
+  /// CallLoc - The location of the call expression for this call.
+  SourceLocation CallLoc;
 
-    /// CallLoc - The location of the call expression for this call.
-    SourceLocation CallLoc;
+  /// Index - The call index of this call.
+  unsigned Index;
 
-    /// Index - The call index of this call.
-    unsigned Index;
+  /// The stack of integers for tracking version numbers for temporaries.
+  SmallVector<unsigned, 2> TempVersionStack = {1};
+  unsigned CurTempVersion = TempVersionStack.back();
 
-    /// The stack of integers for tracking version numbers for temporaries.
-    SmallVector<unsigned, 2> TempVersionStack = {1};
-    unsigned CurTempVersion = TempVersionStack.back();
+  unsigned getTempVersion() const { return TempVersionStack.back(); }
 
-    unsigned getTempVersion() const { return TempVersionStack.back(); }
+  void pushTempVersion() { TempVersionStack.push_back(++CurTempVersion); }
 
-    void pushTempVersion() {
-      TempVersionStack.push_back(++CurTempVersion);
-    }
+  void popTempVersion() { TempVersionStack.pop_back(); }
 
-    void popTempVersion() {
-      TempVersionStack.pop_back();
-    }
+  CallRef createCall(FunctionDecl const *Callee) {
+    return {Callee, Index, ++CurTempVersion};
+  }
 
-    CallRef createCall(const FunctionDecl *Callee) {
-      return {Callee, Index, ++CurTempVersion};
-    }
+  // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact
+  // on the overall stack usage of deeply-recursing constexpr evaluations.
+  // (We should cache this map rather than recomputing it repeatedly.)
+  // But let's try this and see how it goes; we can look into caching the map
+  // as a later change.
 
-    // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact
-    // on the overall stack usage of deeply-recursing constexpr evaluations.
-    // (We should cache this map rather than recomputing it repeatedly.)
-    // But let's try this and see how it goes; we can look into caching the map
-    // as a later change.
+  /// LambdaCaptureFields - Mapping from captured variables/this to
+  /// corresponding data members in the closure class.
+  llvm::DenseMap<VarDecl const *, FieldDecl *> LambdaCaptureFields;
+  FieldDecl *LambdaThisCaptureField;
 
-    /// LambdaCaptureFields - Mapping from captured variables/this to
-    /// corresponding data members in the closure class.
-    llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields;
-    FieldDecl *LambdaThisCaptureField;
+  CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
+                 FunctionDecl const *Callee, LValue const *This,
+                 CallRef Arguments);
+  ~CallStackFrame();
 
-    CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
-                   const FunctionDecl *Callee, const LValue *This,
-                   CallRef Arguments);
-    ~CallStackFrame();
+  // Return the temporary for Key whose version number is Version.
+  APValue *getTemporary(void const *Key, unsigned Version) {
+    MapKeyTy KV(Key, Version);
+    auto LB = Temporaries.lower_bound(KV);
+    if (LB != Temporaries.end() && LB->first == KV)
+      return &LB->second;
+    // Pair (Key,Version) wasn't found in the map. Check that no elements
+    // in the map have 'Key' as their key.
+    assert((LB == Temporaries.end() || LB->first.first != Key) &&
+           (LB == Temporaries.begin() || std::prev(LB)->first.first != Key) &&
+           "Element with key 'Key' found in map");
+    return nullptr;
+  }
 
-    // Return the temporary for Key whose version number is Version.
-    APValue *getTemporary(const void *Key, unsigned Version) {
-      MapKeyTy KV(Key, Version);
-      auto LB = Temporaries.lower_bound(KV);
-      if (LB != Temporaries.end() && LB->first == KV)
-        return &LB->second;
-      // Pair (Key,Version) wasn't found in the map. Check that no elements
-      // in the map have 'Key' as their key.
-      assert((LB == Temporaries.end() || LB->first.first != Key) &&
-             (LB == Temporaries.begin() || std::prev(LB)->first.first != Key) &&
-             "Element with key 'Key' found in map");
-      return nullptr;
-    }
+  // Return the current temporary for Key in the map.
+  APValue *getCurrentTemporary(void const *Key) {
+    auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
+    if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
+      return &std::prev(UB)->second;
+    return nullptr;
+  }
 
-    // Return the current temporary for Key in the map.
-    APValue *getCurrentTemporary(const void *Key) {
-      auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
-      if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
-        return &std::prev(UB)->second;
-      return nullptr;
-    }
+  // Return the version number of the current temporary for Key.
+  unsigned getCurrentTemporaryVersion(void const *Key) const {
+    auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
+    if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
+      return std::prev(UB)->first.second;
+    return 0;
+  }
 
-    // Return the version number of the current temporary for Key.
-    unsigned getCurrentTemporaryVersion(const void *Key) const {
-      auto UB = Temporaries.upper_bound(MapKeyTy(Key, UINT_MAX));
-      if (UB != Temporaries.begin() && std::prev(UB)->first.first == Key)
-        return std::prev(UB)->first.second;
-      return 0;
-    }
+  /// Allocate storage for an object of type T in this stack frame.
+  /// Populates LV with a handle to the created object. Key identifies
+  /// the temporary within the stack frame, and must not be reused without
+  /// bumping the temporary version number.
+  template <typename KeyT>
+  APValue &createTemporary(KeyT const *Key, QualType T, ScopeKind Scope,
+                           LValue &LV);
 
-    /// Allocate storage for an object of type T in this stack frame.
-    /// Populates LV with a handle to the created object. Key identifies
-    /// the temporary within the stack frame, and must not be reused without
-    /// bumping the temporary version number.
-    template<typename KeyT>
-    APValue &createTemporary(const KeyT *Key, QualType T,
-                             ScopeKind Scope, LValue &LV);
+  /// Allocate storage for a parameter of a function call made in this frame.
+  APValue &createParam(CallRef Args, ParmVarDecl const *PVD, LValue &LV);
 
-    /// Allocate storage for a parameter of a function call made in this frame.
-    APValue &createParam(CallRef Args, const ParmVarDecl *PVD, LValue &LV);
+  void describe(llvm::raw_ostream &OS) override;
 
-    void describe(llvm::raw_ostream &OS) override;
+  Frame *getCaller() const override { return Caller; }
+  SourceLocation getCallLocation() const override { return CallLoc; }
+  FunctionDecl const *getCallee() const override { return Callee; }
 
-    Frame *getCaller() const override { return Caller; }
-    SourceLocation getCallLocation() const override { return CallLoc; }
-    const FunctionDecl *getCallee() const override { return Callee; }
+  bool isStdFunction() const {
+    for (DeclContext const *DC = Callee; DC; DC = DC->getParent())
+      if (DC->isStdNamespace())
+        return true;
+    return false;
+  }
 
-    bool isStdFunction() const {
-      for (const DeclContext *DC = Callee; DC; DC = DC->getParent())
-        if (DC->isStdNamespace())
-          return true;
-      return false;
-    }
+private:
+  APValue &createLocal(APValue::LValueBase Base, void const *Key, QualType T,
+                       ScopeKind Scope);
+};
 
-  private:
-    APValue &createLocal(APValue::LValueBase Base, const void *Key, QualType T,
-                         ScopeKind Scope);
-  };
+/// Temporarily override 'this'.
+class ThisOverrideRAII {
+public:
+  ThisOverrideRAII(CallStackFrame &Frame, LValue const *NewThis, bool Enable)
+      : Frame(Frame), OldThis(Frame.This) {
+    if (Enable)
+      Frame.This = NewThis;
+  }
+  ~ThisOverrideRAII() { Frame.This = OldThis; }
 
-  /// Temporarily override 'this'.
-  class ThisOverrideRAII {
-  public:
-    ThisOverrideRAII(CallStackFrame &Frame, const LValue *NewThis, bool Enable)
-        : Frame(Frame), OldThis(Frame.This) {
-      if (Enable)
-        Frame.This = NewThis;
-    }
-    ~ThisOverrideRAII() {
-      Frame.This = OldThis;
-    }
-  private:
-    CallStackFrame &Frame;
-    const LValue *OldThis;
-  };
-}
+private:
+  CallStackFrame &Frame;
+  LValue const *OldThis;
+};
+} // namespace
 
-static bool HandleDestruction(EvalInfo &Info, const Expr *E,
-                              const LValue &This, QualType ThisType);
+static bool HandleDestruction(EvalInfo &Info, Expr const *E, LValue const &This,
+                              QualType ThisType);
 static bool HandleDestruction(EvalInfo &Info, SourceLocation Loc,
                               APValue::LValueBase LVBase, APValue &Value,
                               QualType T);
 
 namespace {
-  /// A cleanup, and a flag indicating whether it is lifetime-extended.
-  class Cleanup {
-    llvm::PointerIntPair<APValue*, 2, ScopeKind> Value;
-    APValue::LValueBase Base;
-    QualType T;
+/// A cleanup, and a flag indicating whether it is lifetime-extended.
+class Cleanup {
+  llvm::PointerIntPair<APValue *, 2, ScopeKind> Value;
+  APValue::LValueBase Base;
+  QualType T;
 
-  public:
-    Cleanup(APValue *Val, APValue::LValueBase Base, QualType T,
-            ScopeKind Scope)
-        : Value(Val, Scope), Base(Base), T(T) {}
-
-    /// Determine whether this cleanup should be performed at the end of the
-    /// given kind of scope.
-    bool isDestroyedAtEndOf(ScopeKind K) const {
-      return (int)Value.getInt() >= (int)K;
-    }
-    bool endLifetime(EvalInfo &Info, bool RunDestructors) {
-      if (RunDestructors) {
-        SourceLocation Loc;
-        if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
-          Loc = VD->getLocation();
-        else if (const Expr *E = Base.dyn_cast<const Expr*>())
-          Loc = E->getExprLoc();
-        return HandleDestruction(Info, Loc, Base, *Value.getPointer(), T);
-      }
-      *Value.getPointer() = APValue();
-      return true;
-    }
+public:
+  Cleanup(APValue *Val, APValue::LValueBase Base, QualType T, ScopeKind Scope)
+      : Value(Val, Scope), Base(Base), T(T) {}
 
-    bool hasSideEffect() {
-      return T.isDestructedType();
+  /// Determine whether this cleanup should be performed at the end of the
+  /// given kind of scope.
+  bool isDestroyedAtEndOf(ScopeKind K) const {
+    return (int)Value.getInt() >= (int)K;
+  }
+  bool endLifetime(EvalInfo &Info, bool RunDestructors) {
+    if (RunDestructors) {
+      SourceLocation Loc;
+      if (ValueDecl const *VD = Base.dyn_cast<ValueDecl const *>())
+        Loc = VD->getLocation();
+      else if (Expr const *E = Base.dyn_cast<Expr const *>())
+        Loc = E->getExprLoc();
+      return HandleDestruction(Info, Loc, Base, *Value.getPointer(), T);
     }
-  };
+    *Value.getPointer() = APValue();
+    return true;
+  }
 
-  /// A reference to an object whose construction we are currently evaluating.
-  struct ObjectUnderConstruction {
-    APValue::LValueBase Base;
-    ArrayRef<APValue::LValuePathEntry> Path;
-    friend bool operator==(const ObjectUnderConstruction &LHS,
-                           const ObjectUnderConstruction &RHS) {
-      return LHS.Base == RHS.Base && LHS.Path == RHS.Path;
-    }
-    friend llvm::hash_code hash_value(const ObjectUnderConstruction &Obj) {
-      return llvm::hash_combine(Obj.Base, Obj.Path);
-    }
-  };
-  enum class ConstructionPhase {
-    None,
-    Bases,
-    AfterBases,
-    AfterFields,
-    Destroying,
-    DestroyingBases
-  };
-}
+  bool hasSideEffect() { return T.isDestructedType(); }
+};
+
+/// A reference to an object whose construction we are currently evaluating.
+struct ObjectUnderConstruction {
+  APValue::LValueBase Base;
+  ArrayRef<APValue::LValuePathEntry> Path;
+  friend bool operator==(ObjectUnderConstruction const &LHS,
+                         ObjectUnderConstruction const &RHS) {
+    return LHS.Base == RHS.Base && LHS.Path == RHS.Path;
+  }
+  friend llvm::hash_code hash_value(ObjectUnderConstruction const &Obj) {
+    return llvm::hash_combine(Obj.Base, Obj.Path);
+  }
+};
+enum class ConstructionPhase {
+  None,
+  Bases,
+  AfterBases,
+  AfterFields,
+  Destroying,
+  DestroyingBases
+};
+} // namespace
 
 namespace llvm {
-template<> struct DenseMapInfo<ObjectUnderConstruction> {
+template <> struct DenseMapInfo<ObjectUnderConstruction> {
   using Base = DenseMapInfo<APValue::LValueBase>;
   static ObjectUnderConstruction getEmptyKey() {
-    return {Base::getEmptyKey(), {}}; }
+    return {Base::getEmptyKey(), {}};
+  }
   static ObjectUnderConstruction getTombstoneKey() {
     return {Base::getTombstoneKey(), {}};
   }
-  static unsigned getHashValue(const ObjectUnderConstruction &Object) {
+  static unsigned getHashValue(ObjectUnderConstruction const &Object) {
     return hash_value(Object);
   }
-  static bool isEqual(const ObjectUnderConstruction &LHS,
-                      const ObjectUnderConstruction &RHS) {
+  static bool isEqual(ObjectUnderConstruction const &LHS,
+                      ObjectUnderConstruction const &RHS) {
     return LHS == RHS;
   }
 };
-}
+} // namespace llvm
 
 namespace {
-  /// A dynamically-allocated heap object.
-  struct DynAlloc {
-    /// The value of this heap-allocated object.
-    APValue Value;
-    /// The allocating expression; used for diagnostics. Either a CXXNewExpr
-    /// or a CallExpr (the latter is for direct calls to operator new inside
-    /// std::allocator<T>::allocate).
-    const Expr *AllocExpr = nullptr;
-
-    enum Kind {
-      New,
-      ArrayNew,
-      StdAllocator
-    };
-
-    /// Get the kind of the allocation. This must match between allocation
-    /// and deallocation.
-    Kind getKind() const {
-      if (auto *NE = dyn_cast<CXXNewExpr>(AllocExpr))
-        return NE->isArray() ? ArrayNew : New;
-      assert(isa<CallExpr>(AllocExpr));
-      return StdAllocator;
-    }
-  };
-
-  struct DynAllocOrder {
-    bool operator()(DynamicAllocLValue L, DynamicAllocLValue R) const {
-      return L.getIndex() < R.getIndex();
-    }
-  };
-
-  /// EvalInfo - This is a private struct used by the evaluator to capture
-  /// information about a subexpression as it is folded.  It retains information
-  /// about the AST context, but also maintains information about the folded
-  /// expression.
-  ///
-  /// If an expression could be evaluated, it is still possible it is not a C
-  /// "integer constant expression" or constant expression.  If not, this struct
-  /// captures information about how and why not.
-  ///
-  /// One bit of information passed *into* the request for constant folding
-  /// indicates whether the subexpression is "evaluated" or not according to C
-  /// rules.  For example, the RHS of (0 && foo()) is not evaluated.  We can
-  /// evaluate the expression regardless of what the RHS is, but C only allows
-  /// certain things in certain situations.
-  class EvalInfo : public interp::State {
-  public:
-    ASTContext &Ctx;
+/// A dynamically-allocated heap object.
+struct DynAlloc {
+  /// The value of this heap-allocated object.
+  APValue Value;
+  /// The allocating expression; used for diagnostics. Either a CXXNewExpr
+  /// or a CallExpr (the latter is for direct calls to operator new inside
+  /// std::allocator<T>::allocate).
+  Expr const *AllocExpr = nullptr;
+
+  enum Kind { New, ArrayNew, StdAllocator };
+
+  /// Get the kind of the allocation. This must match between allocation
+  /// and deallocation.
+  Kind getKind() const {
+    if (auto *NE = dyn_cast<CXXNewExpr>(AllocExpr))
+      return NE->isArray() ? ArrayNew : New;
+    assert(isa<CallExpr>(AllocExpr));
+    return StdAllocator;
+  }
+};
 
-    /// EvalStatus - Contains information about the evaluation.
-    Expr::EvalStatus &EvalStatus;
+struct DynAllocOrder {
+  bool operator()(DynamicAllocLValue L, DynamicAllocLValue R) const {
+    return L.getIndex() < R.getIndex();
+  }
+};
 
-    /// CurrentCall - The top of the constexpr call stack.
-    CallStackFrame *CurrentCall;
+/// EvalInfo - This is a private struct used by the evaluator to capture
+/// information about a subexpression as it is folded.  It retains information
+/// about the AST context, but also maintains information about the folded
+/// expression.
+///
+/// If an expression could be evaluated, it is still possible it is not a C
+/// "integer constant expression" or constant expression.  If not, this struct
+/// captures information about how and why not.
+///
+/// One bit of information passed *into* the request for constant folding
+/// indicates whether the subexpression is "evaluated" or not according to C
+/// rules.  For example, the RHS of (0 && foo()) is not evaluated.  We can
+/// evaluate the expression regardless of what the RHS is, but C only allows
+/// certain things in certain situations.
+class EvalInfo : public interp::State {
+public:
+  ASTContext &Ctx;
 
-    /// CallStackDepth - The number of calls in the call stack right now.
-    unsigned CallStackDepth;
+  /// EvalStatus - Contains information about the evaluation.
+  Expr::EvalStatus &EvalStatus;
 
-    /// NextCallIndex - The next call index to assign.
-    unsigned NextCallIndex;
+  /// CurrentCall - The top of the constexpr call stack.
+  CallStackFrame *CurrentCall;
 
-    /// StepsLeft - The remaining number of evaluation steps we're permitted
-    /// to perform. This is essentially a limit for the number of statements
-    /// we will evaluate.
-    unsigned StepsLeft;
+  /// CallStackDepth - The number of calls in the call stack right now.
+  unsigned CallStackDepth;
 
-    /// Enable the experimental new constant interpreter. If an expression is
-    /// not supported by the interpreter, an error is triggered.
-    bool EnableNewConstInterp;
+  /// NextCallIndex - The next call index to assign.
+  unsigned NextCallIndex;
 
-    /// BottomFrame - The frame in which evaluation started. This must be
-    /// initialized after CurrentCall and CallStackDepth.
-    CallStackFrame BottomFrame;
+  /// StepsLeft - The remaining number of evaluation steps we're permitted
+  /// to perform. This is essentially a limit for the number of statements
+  /// we will evaluate.
+  unsigned StepsLeft;
 
-    /// A stack of values whose lifetimes end at the end of some surrounding
-    /// evaluation frame.
-    llvm::SmallVector<Cleanup, 16> CleanupStack;
+  /// Enable the experimental new constant interpreter. If an expression is
+  /// not supported by the interpreter, an error is triggered.
+  bool EnableNewConstInterp;
 
-    /// EvaluatingDecl - This is the declaration whose initializer is being
-    /// evaluated, if any.
-    APValue::LValueBase EvaluatingDecl;
+  /// BottomFrame - The frame in which evaluation started. This must be
+  /// initialized after CurrentCall and CallStackDepth.
+  CallStackFrame BottomFrame;
 
-    enum class EvaluatingDeclKind {
-      None,
-      /// We're evaluating the construction of EvaluatingDecl.
-      Ctor,
-      /// We're evaluating the destruction of EvaluatingDecl.
-      Dtor,
-    };
-    EvaluatingDeclKind IsEvaluatingDecl = EvaluatingDeclKind::None;
-
-    /// EvaluatingDeclValue - This is the value being constructed for the
-    /// declaration whose initializer is being evaluated, if any.
-    APValue *EvaluatingDeclValue;
-
-    /// Set of objects that are currently being constructed.
-    llvm::DenseMap<ObjectUnderConstruction, ConstructionPhase>
-        ObjectsUnderConstruction;
-
-    /// Current heap allocations, along with the location where each was
-    /// allocated. We use std::map here because we need stable addresses
-    /// for the stored APValues.
-    std::map<DynamicAllocLValue, DynAlloc, DynAllocOrder> HeapAllocs;
-
-    /// The number of heap allocations performed so far in this evaluation.
-    unsigned NumHeapAllocs = 0;
-
-    struct EvaluatingConstructorRAII {
-      EvalInfo &EI;
-      ObjectUnderConstruction Object;
-      bool DidInsert;
-      EvaluatingConstructorRAII(EvalInfo &EI, ObjectUnderConstruction Object,
-                                bool HasBases)
-          : EI(EI), Object(Object) {
-        DidInsert =
-            EI.ObjectsUnderConstruction
-                .insert({Object, HasBases ? ConstructionPhase::Bases
-                                          : ConstructionPhase::AfterBases})
-                .second;
-      }
-      void finishedConstructingBases() {
-        EI.ObjectsUnderConstruction[Object] = ConstructionPhase::AfterBases;
-      }
-      void finishedConstructingFields() {
-        EI.ObjectsUnderConstruction[Object] = ConstructionPhase::AfterFields;
-      }
-      ~EvaluatingConstructorRAII() {
-        if (DidInsert) EI.ObjectsUnderConstruction.erase(Object);
-      }
-    };
+  /// A stack of values whose lifetimes end at the end of some surrounding
+  /// evaluation frame.
+  llvm::SmallVector<Cleanup, 16> CleanupStack;
 
-    struct EvaluatingDestructorRAII {
-      EvalInfo &EI;
-      ObjectUnderConstruction Object;
-      bool DidInsert;
-      EvaluatingDestructorRAII(EvalInfo &EI, ObjectUnderConstruction Object)
-          : EI(EI), Object(Object) {
-        DidInsert = EI.ObjectsUnderConstruction
-                        .insert({Object, ConstructionPhase::Destroying})
-                        .second;
-      }
-      void startedDestroyingBases() {
-        EI.ObjectsUnderConstruction[Object] =
-            ConstructionPhase::DestroyingBases;
-      }
-      ~EvaluatingDestructorRAII() {
-        if (DidInsert)
-          EI.ObjectsUnderConstruction.erase(Object);
-      }
-    };
+  /// EvaluatingDecl - This is the declaration whose initializer is being
+  /// evaluated, if any.
+  APValue::LValueBase EvaluatingDecl;
 
-    ConstructionPhase
-    isEvaluatingCtorDtor(APValue::LValueBase Base,
-                         ArrayRef<APValue::LValuePathEntry> Path) {
-      return ObjectsUnderConstruction.lookup({Base, Path});
-    }
-
-    /// If we're currently speculatively evaluating, the outermost call stack
-    /// depth at which we can mutate state, otherwise 0.
-    unsigned SpeculativeEvaluationDepth = 0;
-
-    /// The current array initialization index, if we're performing array
-    /// initialization.
-    uint64_t ArrayInitIndex = -1;
-
-    /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further
-    /// notes attached to it will also be stored, otherwise they will not be.
-    bool HasActiveDiagnostic;
-
-    /// Have we emitted a diagnostic explaining why we couldn't constant
-    /// fold (not just why it's not strictly a constant expression)?
-    bool HasFoldFailureDiagnostic;
-
-    /// Whether or not we're in a context where the front end requires a
-    /// constant value.
-    bool InConstantContext;
-
-    /// Whether we're checking that an expression is a potential constant
-    /// expression. If so, do not fail on constructs that could become constant
-    /// later on (such as a use of an undefined global).
-    bool CheckingPotentialConstantExpression = false;
-
-    /// Whether we're checking for an expression that has undefined behavior.
-    /// If so, we will produce warnings if we encounter an operation that is
-    /// always undefined.
-    ///
-    /// Note that we still need to evaluate the expression normally when this
-    /// is set; this is used when evaluating ICEs in C.
-    bool CheckingForUndefinedBehavior = false;
-
-    enum EvaluationMode {
-      /// Evaluate as a constant expression. Stop if we find that the expression
-      /// is not a constant expression.
-      EM_ConstantExpression,
-
-      /// Evaluate as a constant expression. Stop if we find that the expression
-      /// is not a constant expression. Some expressions can be retried in the
-      /// optimizer if we don't constant fold them here, but in an unevaluated
-      /// context we try to fold them immediately since the optimizer never
-      /// gets a chance to look at it.
-      EM_ConstantExpressionUnevaluated,
-
-      /// Fold the expression to a constant. Stop if we hit a side-effect that
-      /// we can't model.
-      EM_ConstantFold,
-
-      /// Evaluate in any way we know how. Don't worry about side-effects that
-      /// can't be modeled.
-      EM_IgnoreSideEffects,
-    } EvalMode;
-
-    /// Are we checking whether the expression is a potential constant
-    /// expression?
-    bool checkingPotentialConstantExpression() const override  {
-      return CheckingPotentialConstantExpression;
-    }
-
-    /// Are we checking an expression for overflow?
-    // FIXME: We should check for any kind of undefined or suspicious behavior
-    // in such constructs, not just overflow.
-    bool checkingForUndefinedBehavior() const override {
-      return CheckingForUndefinedBehavior;
-    }
-
-    EvalInfo(const ASTContext &C, Expr::EvalStatus &S, EvaluationMode Mode)
-        : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
-          CallStackDepth(0), NextCallIndex(1),
-          StepsLeft(C.getLangOpts().ConstexprStepLimit),
-          EnableNewConstInterp(C.getLangOpts().EnableNewConstInterp),
-          BottomFrame(*this, SourceLocation(), nullptr, nullptr, CallRef()),
-          EvaluatingDecl((const ValueDecl *)nullptr),
-          EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
-          HasFoldFailureDiagnostic(false), InConstantContext(false),
-          EvalMode(Mode) {}
-
-    ~EvalInfo() {
-      discardCleanups();
-    }
-
-    void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value,
-                           EvaluatingDeclKind EDK = EvaluatingDeclKind::Ctor) {
-      EvaluatingDecl = Base;
-      IsEvaluatingDecl = EDK;
-      EvaluatingDeclValue = &Value;
-    }
-
-    bool CheckCallLimit(SourceLocation Loc) {
-      // Don't perform any constexpr calls (other than the call we're checking)
-      // when checking a potential constant expression.
-      if (checkingPotentialConstantExpression() && CallStackDepth > 1)
-        return false;
-      if (NextCallIndex == 0) {
-        // NextCallIndex has wrapped around.
-        FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);
-        return false;
-      }
-      if (CallStackDepth <= getLangOpts().ConstexprCallDepth)
-        return true;
-      FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded)
-        << getLangOpts().ConstexprCallDepth;
-      return false;
+  enum class EvaluatingDeclKind {
+    None,
+    /// We're evaluating the construction of EvaluatingDecl.
+    Ctor,
+    /// We're evaluating the destruction of EvaluatingDecl.
+    Dtor,
+  };
+  EvaluatingDeclKind IsEvaluatingDecl = EvaluatingDeclKind::None;
+
+  /// EvaluatingDeclValue - This is the value being constructed for the
+  /// declaration whose initializer is being evaluated, if any.
+  APValue *EvaluatingDeclValue;
+
+  /// Set of objects that are currently being constructed.
+  llvm::DenseMap<ObjectUnderConstruction, ConstructionPhase>
+      ObjectsUnderConstruction;
+
+  /// Current heap allocations, along with the location where each was
+  /// allocated. We use std::map here because we need stable addresses
+  /// for the stored APValues.
+  std::map<DynamicAllocLValue, DynAlloc, DynAllocOrder> HeapAllocs;
+
+  /// The number of heap allocations performed so far in this evaluation.
+  unsigned NumHeapAllocs = 0;
+
+  struct EvaluatingConstructorRAII {
+    EvalInfo &EI;
+    ObjectUnderConstruction Object;
+    bool DidInsert;
+    EvaluatingConstructorRAII(EvalInfo &EI, ObjectUnderConstruction Object,
+                              bool HasBases)
+        : EI(EI), Object(Object) {
+      DidInsert =
+          EI.ObjectsUnderConstruction
+              .insert({Object, HasBases ? ConstructionPhase::Bases
+                                        : ConstructionPhase::AfterBases})
+              .second;
+    }
+    void finishedConstructingBases() {
+      EI.ObjectsUnderConstruction[Object] = ConstructionPhase::AfterBases;
+    }
+    void finishedConstructingFields() {
+      EI.ObjectsUnderConstruction[Object] = ConstructionPhase::AfterFields;
+    }
+    ~EvaluatingConstructorRAII() {
+      if (DidInsert)
+        EI.ObjectsUnderConstruction.erase(Object);
     }
+  };
 
-    std::pair<CallStackFrame *, unsigned>
-    getCallFrameAndDepth(unsigned CallIndex) {
-      assert(CallIndex && "no call index in getCallFrameAndDepth");
-      // We will eventually hit BottomFrame, which has Index 1, so Frame can't
-      // be null in this loop.
-      unsigned Depth = CallStackDepth;
-      CallStackFrame *Frame = CurrentCall;
-      while (Frame->Index > CallIndex) {
-        Frame = Frame->Caller;
-        --Depth;
-      }
-      if (Frame->Index == CallIndex)
-        return {Frame, Depth};
-      return {nullptr, 0};
+  struct EvaluatingDestructorRAII {
+    EvalInfo &EI;
+    ObjectUnderConstruction Object;
+    bool DidInsert;
+    EvaluatingDestructorRAII(EvalInfo &EI, ObjectUnderConstruction Object)
+        : EI(EI), Object(Object) {
+      DidInsert = EI.ObjectsUnderConstruction
+                      .insert({Object, ConstructionPhase::Destroying})
+                      .second;
     }
-
-    bool nextStep(const Stmt *S) {
-      if (!StepsLeft) {
-        FFDiag(S->getBeginLoc(), diag::note_constexpr_step_limit_exceeded);
-        return false;
-      }
-      --StepsLeft;
-      return true;
+    void startedDestroyingBases() {
+      EI.ObjectsUnderConstruction[Object] = ConstructionPhase::DestroyingBases;
     }
+    ~EvaluatingDestructorRAII() {
+      if (DidInsert)
+        EI.ObjectsUnderConstruction.erase(Object);
+    }
+  };
 
-    APValue *createHeapAlloc(const Expr *E, QualType T, LValue &LV);
+  ConstructionPhase
+  isEvaluatingCtorDtor(APValue::LValueBase Base,
+                       ArrayRef<APValue::LValuePathEntry> Path) {
+    return ObjectsUnderConstruction.lookup({Base, Path});
+  }
 
-    Optional<DynAlloc*> lookupDynamicAlloc(DynamicAllocLValue DA) {
-      Optional<DynAlloc*> Result;
-      auto It = HeapAllocs.find(DA);
-      if (It != HeapAllocs.end())
-        Result = &It->second;
-      return Result;
-    }
+  /// If we're currently speculatively evaluating, the outermost call stack
+  /// depth at which we can mutate state, otherwise 0.
+  unsigned SpeculativeEvaluationDepth = 0;
 
-    /// Get the allocated storage for the given parameter of the given call.
-    APValue *getParamSlot(CallRef Call, const ParmVarDecl *PVD) {
-      CallStackFrame *Frame = getCallFrameAndDepth(Call.CallIndex).first;
-      return Frame ? Frame->getTemporary(Call.getOrigParam(PVD), Call.Version)
-                   : nullptr;
-    }
+  /// The current array initialization index, if we're performing array
+  /// initialization.
+  uint64_t ArrayInitIndex = -1;
 
-    /// Information about a stack frame for std::allocator<T>::[de]allocate.
-    struct StdAllocatorCaller {
-      unsigned FrameIndex;
-      QualType ElemType;
-      explicit operator bool() const { return FrameIndex != 0; };
-    };
+  /// HasActiveDiagnostic - Was the previous diagnostic stored? If so, further
+  /// notes attached to it will also be stored, otherwise they will not be.
+  bool HasActiveDiagnostic;
 
-    StdAllocatorCaller getStdAllocatorCaller(StringRef FnName) const {
-      for (const CallStackFrame *Call = CurrentCall; Call != &BottomFrame;
-           Call = Call->Caller) {
-        const auto *MD = dyn_cast_or_null<CXXMethodDecl>(Call->Callee);
-        if (!MD)
-          continue;
-        const IdentifierInfo *FnII = MD->getIdentifier();
-        if (!FnII || !FnII->isStr(FnName))
-          continue;
+  /// Have we emitted a diagnostic explaining why we couldn't constant
+  /// fold (not just why it's not strictly a constant expression)?
+  bool HasFoldFailureDiagnostic;
 
-        const auto *CTSD =
-            dyn_cast<ClassTemplateSpecializationDecl>(MD->getParent());
-        if (!CTSD)
-          continue;
+  /// Whether or not we're in a context where the front end requires a
+  /// constant value.
+  bool InConstantContext;
 
-        const IdentifierInfo *ClassII = CTSD->getIdentifier();
-        const TemplateArgumentList &TAL = CTSD->getTemplateArgs();
-        if (CTSD->isInStdNamespace() && ClassII &&
-            ClassII->isStr("allocator") && TAL.size() >= 1 &&
-            TAL[0].getKind() == TemplateArgument::Type)
-          return {Call->Index, TAL[0].getAsType()};
-      }
+  /// Whether we're checking that an expression is a potential constant
+  /// expression. If so, do not fail on constructs that could become constant
+  /// later on (such as a use of an undefined global).
+  bool CheckingPotentialConstantExpression = false;
 
-      return {};
-    }
-
-    void performLifetimeExtension() {
-      // Disable the cleanups for lifetime-extended temporaries.
-      CleanupStack.erase(std::remove_if(CleanupStack.begin(),
-                                        CleanupStack.end(),
-                                        [](Cleanup &C) {
-                                          return !C.isDestroyedAtEndOf(
-                                              ScopeKind::FullExpression);
-                                        }),
-                         CleanupStack.end());
-     }
-
-    /// Throw away any remaining cleanups at the end of evaluation. If any
-    /// cleanups would have had a side-effect, note that as an unmodeled
-    /// side-effect and return false. Otherwise, return true.
-    bool discardCleanups() {
-      for (Cleanup &C : CleanupStack) {
-        if (C.hasSideEffect() && !noteSideEffect()) {
-          CleanupStack.clear();
-          return false;
-        }
-      }
-      CleanupStack.clear();
+  /// Whether we're checking for an expression that has undefined behavior.
+  /// If so, we will produce warnings if we encounter an operation that is
+  /// always undefined.
+  ///
+  /// Note that we still need to evaluate the expression normally when this
+  /// is set; this is used when evaluating ICEs in C.
+  bool CheckingForUndefinedBehavior = false;
+
+  enum EvaluationMode {
+    /// Evaluate as a constant expression. Stop if we find that the expression
+    /// is not a constant expression.
+    EM_ConstantExpression,
+
+    /// Evaluate as a constant expression. Stop if we find that the expression
+    /// is not a constant expression. Some expressions can be retried in the
+    /// optimizer if we don't constant fold them here, but in an unevaluated
+    /// context we try to fold them immediately since the optimizer never
+    /// gets a chance to look at it.
+    EM_ConstantExpressionUnevaluated,
+
+    /// Fold the expression to a constant. Stop if we hit a side-effect that
+    /// we can't model.
+    EM_ConstantFold,
+
+    /// Evaluate in any way we know how. Don't worry about side-effects that
+    /// can't be modeled.
+    EM_IgnoreSideEffects,
+  } EvalMode;
+
+  /// Are we checking whether the expression is a potential constant
+  /// expression?
+  bool checkingPotentialConstantExpression() const override {
+    return CheckingPotentialConstantExpression;
+  }
+
+  /// Are we checking an expression for overflow?
+  // FIXME: We should check for any kind of undefined or suspicious behavior
+  // in such constructs, not just overflow.
+  bool checkingForUndefinedBehavior() const override {
+    return CheckingForUndefinedBehavior;
+  }
+
+  EvalInfo(ASTContext const &C, Expr::EvalStatus &S, EvaluationMode Mode)
+      : Ctx(const_cast<ASTContext &>(C)), EvalStatus(S), CurrentCall(nullptr),
+        CallStackDepth(0), NextCallIndex(1),
+        StepsLeft(C.getLangOpts().ConstexprStepLimit),
+        EnableNewConstInterp(C.getLangOpts().EnableNewConstInterp),
+        BottomFrame(*this, SourceLocation(), nullptr, nullptr, CallRef()),
+        EvaluatingDecl((ValueDecl const *)nullptr),
+        EvaluatingDeclValue(nullptr), HasActiveDiagnostic(false),
+        HasFoldFailureDiagnostic(false), InConstantContext(false),
+        EvalMode(Mode) {}
+
+  ~EvalInfo() { discardCleanups(); }
+
+  void setEvaluatingDecl(APValue::LValueBase Base, APValue &Value,
+                         EvaluatingDeclKind EDK = EvaluatingDeclKind::Ctor) {
+    EvaluatingDecl = Base;
+    IsEvaluatingDecl = EDK;
+    EvaluatingDeclValue = &Value;
+  }
+
+  bool CheckCallLimit(SourceLocation Loc) {
+    // Don't perform any constexpr calls (other than the call we're checking)
+    // when checking a potential constant expression.
+    if (checkingPotentialConstantExpression() && CallStackDepth > 1)
+      return false;
+    if (NextCallIndex == 0) {
+      // NextCallIndex has wrapped around.
+      FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);
+      return false;
+    }
+    if (CallStackDepth <= getLangOpts().ConstexprCallDepth)
       return true;
+    FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded)
+        << getLangOpts().ConstexprCallDepth;
+    return false;
+  }
+
+  std::pair<CallStackFrame *, unsigned>
+  getCallFrameAndDepth(unsigned CallIndex) {
+    assert(CallIndex && "no call index in getCallFrameAndDepth");
+    // We will eventually hit BottomFrame, which has Index 1, so Frame can't
+    // be null in this loop.
+    unsigned Depth = CallStackDepth;
+    CallStackFrame *Frame = CurrentCall;
+    while (Frame->Index > CallIndex) {
+      Frame = Frame->Caller;
+      --Depth;
     }
+    if (Frame->Index == CallIndex)
+      return {Frame, Depth};
+    return {nullptr, 0};
+  }
 
-  private:
-    interp::Frame *getCurrentFrame() override { return CurrentCall; }
-    const interp::Frame *getBottomFrame() const override { return &BottomFrame; }
+  bool nextStep(Stmt const *S) {
+    if (!StepsLeft) {
+      FFDiag(S->getBeginLoc(), diag::note_constexpr_step_limit_exceeded);
+      return false;
+    }
+    --StepsLeft;
+    return true;
+  }
 
-    bool hasActiveDiagnostic() override { return HasActiveDiagnostic; }
-    void setActiveDiagnostic(bool Flag) override { HasActiveDiagnostic = Flag; }
+  APValue *createHeapAlloc(Expr const *E, QualType T, LValue &LV);
 
-    void setFoldFailureDiagnostic(bool Flag) override {
-      HasFoldFailureDiagnostic = Flag;
-    }
+  Optional<DynAlloc *> lookupDynamicAlloc(DynamicAllocLValue DA) {
+    Optional<DynAlloc *> Result;
+    auto It = HeapAllocs.find(DA);
+    if (It != HeapAllocs.end())
+      Result = &It->second;
+    return Result;
+  }
 
-    Expr::EvalStatus &getEvalStatus() const override { return EvalStatus; }
+  /// Get the allocated storage for the given parameter of the given call.
+  APValue *getParamSlot(CallRef Call, ParmVarDecl const *PVD) {
+    CallStackFrame *Frame = getCallFrameAndDepth(Call.CallIndex).first;
+    return Frame ? Frame->getTemporary(Call.getOrigParam(PVD), Call.Version)
+                 : nullptr;
+  }
 
-    ASTContext &getCtx() const override { return Ctx; }
+  /// Information about a stack frame for std::allocator<T>::[de]allocate.
+  struct StdAllocatorCaller {
+    unsigned FrameIndex;
+    QualType ElemType;
+    explicit operator bool() const { return FrameIndex != 0; };
+  };
 
-    // If we have a prior diagnostic, it will be noting that the expression
-    // isn't a constant expression. This diagnostic is more important,
-    // unless we require this evaluation to produce a constant expression.
-    //
-    // FIXME: We might want to show both diagnostics to the user in
-    // EM_ConstantFold mode.
-    bool hasPriorDiagnostic() override {
-      if (!EvalStatus.Diag->empty()) {
-        switch (EvalMode) {
-        case EM_ConstantFold:
-        case EM_IgnoreSideEffects:
-          if (!HasFoldFailureDiagnostic)
-            break;
-          // We've already failed to fold something. Keep that diagnostic.
-          LLVM_FALLTHROUGH;
-        case EM_ConstantExpression:
-        case EM_ConstantExpressionUnevaluated:
-          setActiveDiagnostic(false);
-          return true;
-        }
-      }
-      return false;
+  StdAllocatorCaller getStdAllocatorCaller(StringRef FnName) const {
+    for (CallStackFrame const *Call = CurrentCall; Call != &BottomFrame;
+         Call = Call->Caller) {
+      auto const *MD = dyn_cast_or_null<CXXMethodDecl>(Call->Callee);
+      if (!MD)
+        continue;
+      IdentifierInfo const *FnII = MD->getIdentifier();
+      if (!FnII || !FnII->isStr(FnName))
+        continue;
+
+      auto const *CTSD =
+          dyn_cast<ClassTemplateSpecializationDecl>(MD->getParent());
+      if (!CTSD)
+        continue;
+
+      IdentifierInfo const *ClassII = CTSD->getIdentifier();
+      TemplateArgumentList const &TAL = CTSD->getTemplateArgs();
+      if (CTSD->isInStdNamespace() && ClassII && ClassII->isStr("allocator") &&
+          TAL.size() >= 1 && TAL[0].getKind() == TemplateArgument::Type)
+        return {Call->Index, TAL[0].getAsType()};
     }
 
-    unsigned getCallStackDepth() override { return CallStackDepth; }
+    return {};
+  }
 
-  public:
-    /// Should we continue evaluation after encountering a side-effect that we
-    /// couldn't model?
-    bool keepEvaluatingAfterSideEffect() {
-      switch (EvalMode) {
-      case EM_IgnoreSideEffects:
-        return true;
+  void performLifetimeExtension() {
+    // Disable the cleanups for lifetime-extended temporaries.
+    CleanupStack.erase(std::remove_if(CleanupStack.begin(), CleanupStack.end(),
+                                      [](Cleanup &C) {
+                                        return !C.isDestroyedAtEndOf(
+                                            ScopeKind::FullExpression);
+                                      }),
+                       CleanupStack.end());
+  }
 
-      case EM_ConstantExpression:
-      case EM_ConstantExpressionUnevaluated:
-      case EM_ConstantFold:
-        // By default, assume any side effect might be valid in some other
-        // evaluation of this expression from a different context.
-        return checkingPotentialConstantExpression() ||
-               checkingForUndefinedBehavior();
+  /// Throw away any remaining cleanups at the end of evaluation. If any
+  /// cleanups would have had a side-effect, note that as an unmodeled
+  /// side-effect and return false. Otherwise, return true.
+  bool discardCleanups() {
+    for (Cleanup &C : CleanupStack) {
+      if (C.hasSideEffect() && !noteSideEffect()) {
+        CleanupStack.clear();
+        return false;
       }
-      llvm_unreachable("Missed EvalMode case");
     }
+    CleanupStack.clear();
+    return true;
+  }
 
-    /// Note that we have had a side-effect, and determine whether we should
-    /// keep evaluating.
-    bool noteSideEffect() {
-      EvalStatus.HasSideEffects = true;
-      return keepEvaluatingAfterSideEffect();
-    }
+private:
+  interp::Frame *getCurrentFrame() override { return CurrentCall; }
+  interp::Frame const *getBottomFrame() const override { return &BottomFrame; }
+
+  bool hasActiveDiagnostic() override { return HasActiveDiagnostic; }
+  void setActiveDiagnostic(bool Flag) override { HasActiveDiagnostic = Flag; }
 
-    /// Should we continue evaluation after encountering undefined behavior?
-    bool keepEvaluatingAfterUndefinedBehavior() {
+  void setFoldFailureDiagnostic(bool Flag) override {
+    HasFoldFailureDiagnostic = Flag;
+  }
+
+  Expr::EvalStatus &getEvalStatus() const override { return EvalStatus; }
+
+  ASTContext &getCtx() const override { return Ctx; }
+
+  // If we have a prior diagnostic, it will be noting that the expression
+  // isn't a constant expression. This diagnostic is more important,
+  // unless we require this evaluation to produce a constant expression.
+  //
+  // FIXME: We might want to show both diagnostics to the user in
+  // EM_ConstantFold mode.
+  bool hasPriorDiagnostic() override {
+    if (!EvalStatus.Diag->empty()) {
       switch (EvalMode) {
-      case EM_IgnoreSideEffects:
       case EM_ConstantFold:
-        return true;
-
+      case EM_IgnoreSideEffects:
+        if (!HasFoldFailureDiagnostic)
+          break;
+        // We've already failed to fold something. Keep that diagnostic.
+        LLVM_FALLTHROUGH;
       case EM_ConstantExpression:
       case EM_ConstantExpressionUnevaluated:
-        return checkingForUndefinedBehavior();
+        setActiveDiagnostic(false);
+        return true;
       }
-      llvm_unreachable("Missed EvalMode case");
     }
+    return false;
+  }
+
+  unsigned getCallStackDepth() override { return CallStackDepth; }
 
-    /// Note that we hit something that was technically undefined behavior, but
-    /// that we can evaluate past it (such as signed overflow or floating-point
-    /// division by zero.)
-    bool noteUndefinedBehavior() override {
-      EvalStatus.HasUndefinedBehavior = true;
-      return keepEvaluatingAfterUndefinedBehavior();
+public:
+  /// Should we continue evaluation after encountering a side-effect that we
+  /// couldn't model?
+  bool keepEvaluatingAfterSideEffect() {
+    switch (EvalMode) {
+    case EM_IgnoreSideEffects:
+      return true;
+
+    case EM_ConstantExpression:
+    case EM_ConstantExpressionUnevaluated:
+    case EM_ConstantFold:
+      // By default, assume any side effect might be valid in some other
+      // evaluation of this expression from a different context.
+      return checkingPotentialConstantExpression() ||
+             checkingForUndefinedBehavior();
     }
+    llvm_unreachable("Missed EvalMode case");
+  }
 
-    /// Should we continue evaluation as much as possible after encountering a
-    /// construct which can't be reduced to a value?
-    bool keepEvaluatingAfterFailure() const override {
-      if (!StepsLeft)
-        return false;
+  /// Note that we have had a side-effect, and determine whether we should
+  /// keep evaluating.
+  bool noteSideEffect() {
+    EvalStatus.HasSideEffects = true;
+    return keepEvaluatingAfterSideEffect();
+  }
 
-      switch (EvalMode) {
-      case EM_ConstantExpression:
-      case EM_ConstantExpressionUnevaluated:
-      case EM_ConstantFold:
-      case EM_IgnoreSideEffects:
-        return checkingPotentialConstantExpression() ||
-               checkingForUndefinedBehavior();
-      }
-      llvm_unreachable("Missed EvalMode case");
-    }
-
-    /// Notes that we failed to evaluate an expression that other expressions
-    /// directly depend on, and determine if we should keep evaluating. This
-    /// should only be called if we actually intend to keep evaluating.
-    ///
-    /// Call noteSideEffect() instead if we may be able to ignore the value that
-    /// we failed to evaluate, e.g. if we failed to evaluate Foo() in:
-    ///
-    /// (Foo(), 1)      // use noteSideEffect
-    /// (Foo() || true) // use noteSideEffect
-    /// Foo() + 1       // use noteFailure
-    LLVM_NODISCARD bool noteFailure() {
-      // Failure when evaluating some expression often means there is some
-      // subexpression whose evaluation was skipped. Therefore, (because we
-      // don't track whether we skipped an expression when unwinding after an
-      // evaluation failure) every evaluation failure that bubbles up from a
-      // subexpression implies that a side-effect has potentially happened. We
-      // skip setting the HasSideEffects flag to true until we decide to
-      // continue evaluating after that point, which happens here.
-      bool KeepGoing = keepEvaluatingAfterFailure();
-      EvalStatus.HasSideEffects |= KeepGoing;
-      return KeepGoing;
-    }
-
-    class ArrayInitLoopIndex {
-      EvalInfo &Info;
-      uint64_t OuterIndex;
+  /// Should we continue evaluation after encountering undefined behavior?
+  bool keepEvaluatingAfterUndefinedBehavior() {
+    switch (EvalMode) {
+    case EM_IgnoreSideEffects:
+    case EM_ConstantFold:
+      return true;
 
-    public:
-      ArrayInitLoopIndex(EvalInfo &Info)
-          : Info(Info), OuterIndex(Info.ArrayInitIndex) {
-        Info.ArrayInitIndex = 0;
-      }
-      ~ArrayInitLoopIndex() { Info.ArrayInitIndex = OuterIndex; }
+    case EM_ConstantExpression:
+    case EM_ConstantExpressionUnevaluated:
+      return checkingForUndefinedBehavior();
+    }
+    llvm_unreachable("Missed EvalMode case");
+  }
 
-      operator uint64_t&() { return Info.ArrayInitIndex; }
-    };
-  };
+  /// Note that we hit something that was technically undefined behavior, but
+  /// that we can evaluate past it (such as signed overflow or floating-point
+  /// division by zero.)
+  bool noteUndefinedBehavior() override {
+    EvalStatus.HasUndefinedBehavior = true;
+    return keepEvaluatingAfterUndefinedBehavior();
+  }
 
-  /// Object used to treat all foldable expressions as constant expressions.
-  struct FoldConstant {
-    EvalInfo &Info;
-    bool Enabled;
-    bool HadNoPriorDiags;
-    EvalInfo::EvaluationMode OldMode;
+  /// Should we continue evaluation as much as possible after encountering a
+  /// construct which can't be reduced to a value?
+  bool keepEvaluatingAfterFailure() const override {
+    if (!StepsLeft)
+      return false;
 
-    explicit FoldConstant(EvalInfo &Info, bool Enabled)
-      : Info(Info),
-        Enabled(Enabled),
-        HadNoPriorDiags(Info.EvalStatus.Diag &&
-                        Info.EvalStatus.Diag->empty() &&
-                        !Info.EvalStatus.HasSideEffects),
-        OldMode(Info.EvalMode) {
-      if (Enabled)
-        Info.EvalMode = EvalInfo::EM_ConstantFold;
-    }
-    void keepDiagnostics() { Enabled = false; }
-    ~FoldConstant() {
-      if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
-          !Info.EvalStatus.HasSideEffects)
-        Info.EvalStatus.Diag->clear();
-      Info.EvalMode = OldMode;
+    switch (EvalMode) {
+    case EM_ConstantExpression:
+    case EM_ConstantExpressionUnevaluated:
+    case EM_ConstantFold:
+    case EM_IgnoreSideEffects:
+      return checkingPotentialConstantExpression() ||
+             checkingForUndefinedBehavior();
     }
-  };
+    llvm_unreachable("Missed EvalMode case");
+  }
 
-  /// RAII object used to set the current evaluation mode to ignore
-  /// side-effects.
-  struct IgnoreSideEffectsRAII {
+  /// Notes that we failed to evaluate an expression that other expressions
+  /// directly depend on, and determine if we should keep evaluating. This
+  /// should only be called if we actually intend to keep evaluating.
+  ///
+  /// Call noteSideEffect() instead if we may be able to ignore the value that
+  /// we failed to evaluate, e.g. if we failed to evaluate Foo() in:
+  ///
+  /// (Foo(), 1)      // use noteSideEffect
+  /// (Foo() || true) // use noteSideEffect
+  /// Foo() + 1       // use noteFailure
+  LLVM_NODISCARD bool noteFailure() {
+    // Failure when evaluating some expression often means there is some
+    // subexpression whose evaluation was skipped. Therefore, (because we
+    // don't track whether we skipped an expression when unwinding after an
+    // evaluation failure) every evaluation failure that bubbles up from a
+    // subexpression implies that a side-effect has potentially happened. We
+    // skip setting the HasSideEffects flag to true until we decide to
+    // continue evaluating after that point, which happens here.
+    bool KeepGoing = keepEvaluatingAfterFailure();
+    EvalStatus.HasSideEffects |= KeepGoing;
+    return KeepGoing;
+  }
+
+  class ArrayInitLoopIndex {
     EvalInfo &Info;
-    EvalInfo::EvaluationMode OldMode;
-    explicit IgnoreSideEffectsRAII(EvalInfo &Info)
-        : Info(Info), OldMode(Info.EvalMode) {
-      Info.EvalMode = EvalInfo::EM_IgnoreSideEffects;
+    uint64_t OuterIndex;
+
+  public:
+    ArrayInitLoopIndex(EvalInfo &Info)
+        : Info(Info), OuterIndex(Info.ArrayInitIndex) {
+      Info.ArrayInitIndex = 0;
     }
+    ~ArrayInitLoopIndex() { Info.ArrayInitIndex = OuterIndex; }
 
-    ~IgnoreSideEffectsRAII() { Info.EvalMode = OldMode; }
+    operator uint64_t &() { return Info.ArrayInitIndex; }
   };
+};
 
-  /// RAII object used to optionally suppress diagnostics and side-effects from
-  /// a speculative evaluation.
-  class SpeculativeEvaluationRAII {
-    EvalInfo *Info = nullptr;
-    Expr::EvalStatus OldStatus;
-    unsigned OldSpeculativeEvaluationDepth;
+/// Object used to treat all foldable expressions as constant expressions.
+struct FoldConstant {
+  EvalInfo &Info;
+  bool Enabled;
+  bool HadNoPriorDiags;
+  EvalInfo::EvaluationMode OldMode;
 
-    void moveFromAndCancel(SpeculativeEvaluationRAII &&Other) {
-      Info = Other.Info;
-      OldStatus = Other.OldStatus;
-      OldSpeculativeEvaluationDepth = Other.OldSpeculativeEvaluationDepth;
-      Other.Info = nullptr;
-    }
+  explicit FoldConstant(EvalInfo &Info, bool Enabled)
+      : Info(Info), Enabled(Enabled),
+        HadNoPriorDiags(Info.EvalStatus.Diag && Info.EvalStatus.Diag->empty() &&
+                        !Info.EvalStatus.HasSideEffects),
+        OldMode(Info.EvalMode) {
+    if (Enabled)
+      Info.EvalMode = EvalInfo::EM_ConstantFold;
+  }
+  void keepDiagnostics() { Enabled = false; }
+  ~FoldConstant() {
+    if (Enabled && HadNoPriorDiags && !Info.EvalStatus.Diag->empty() &&
+        !Info.EvalStatus.HasSideEffects)
+      Info.EvalStatus.Diag->clear();
+    Info.EvalMode = OldMode;
+  }
+};
 
-    void maybeRestoreState() {
-      if (!Info)
-        return;
+/// RAII object used to set the current evaluation mode to ignore
+/// side-effects.
+struct IgnoreSideEffectsRAII {
+  EvalInfo &Info;
+  EvalInfo::EvaluationMode OldMode;
+  explicit IgnoreSideEffectsRAII(EvalInfo &Info)
+      : Info(Info), OldMode(Info.EvalMode) {
+    Info.EvalMode = EvalInfo::EM_IgnoreSideEffects;
+  }
 
-      Info->EvalStatus = OldStatus;
-      Info->SpeculativeEvaluationDepth = OldSpeculativeEvaluationDepth;
-    }
+  ~IgnoreSideEffectsRAII() { Info.EvalMode = OldMode; }
+};
 
-  public:
-    SpeculativeEvaluationRAII() = default;
+/// RAII object used to optionally suppress diagnostics and side-effects from
+/// a speculative evaluation.
+class SpeculativeEvaluationRAII {
+  EvalInfo *Info = nullptr;
+  Expr::EvalStatus OldStatus;
+  unsigned OldSpeculativeEvaluationDepth;
 
-    SpeculativeEvaluationRAII(
-        EvalInfo &Info, SmallVectorImpl<PartialDiagnosticAt> *NewDiag = nullptr)
-        : Info(&Info), OldStatus(Info.EvalStatus),
-          OldSpeculativeEvaluationDepth(Info.SpeculativeEvaluationDepth) {
-      Info.EvalStatus.Diag = NewDiag;
-      Info.SpeculativeEvaluationDepth = Info.CallStackDepth + 1;
-    }
+  void moveFromAndCancel(SpeculativeEvaluationRAII &&Other) {
+    Info = Other.Info;
+    OldStatus = Other.OldStatus;
+    OldSpeculativeEvaluationDepth = Other.OldSpeculativeEvaluationDepth;
+    Other.Info = nullptr;
+  }
 
-    SpeculativeEvaluationRAII(const SpeculativeEvaluationRAII &Other) = delete;
-    SpeculativeEvaluationRAII(SpeculativeEvaluationRAII &&Other) {
-      moveFromAndCancel(std::move(Other));
-    }
+  void maybeRestoreState() {
+    if (!Info)
+      return;
 
-    SpeculativeEvaluationRAII &operator=(SpeculativeEvaluationRAII &&Other) {
-      maybeRestoreState();
-      moveFromAndCancel(std::move(Other));
-      return *this;
-    }
+    Info->EvalStatus = OldStatus;
+    Info->SpeculativeEvaluationDepth = OldSpeculativeEvaluationDepth;
+  }
 
-    ~SpeculativeEvaluationRAII() { maybeRestoreState(); }
-  };
+public:
+  SpeculativeEvaluationRAII() = default;
 
-  /// RAII object wrapping a full-expression or block scope, and handling
-  /// the ending of the lifetime of temporaries created within it.
-  template<ScopeKind Kind>
-  class ScopeRAII {
-    EvalInfo &Info;
-    unsigned OldStackSize;
-  public:
-    ScopeRAII(EvalInfo &Info)
-        : Info(Info), OldStackSize(Info.CleanupStack.size()) {
-      // Push a new temporary version. This is needed to distinguish between
-      // temporaries created in different iterations of a loop.
-      Info.CurrentCall->pushTempVersion();
-    }
-    bool destroy(bool RunDestructors = true) {
-      bool OK = cleanup(Info, RunDestructors, OldStackSize);
-      OldStackSize = -1U;
-      return OK;
-    }
-    ~ScopeRAII() {
-      if (OldStackSize != -1U)
-        destroy(false);
-      // Body moved to a static method to encourage the compiler to inline away
-      // instances of this class.
-      Info.CurrentCall->popTempVersion();
-    }
-  private:
-    static bool cleanup(EvalInfo &Info, bool RunDestructors,
-                        unsigned OldStackSize) {
-      assert(OldStackSize <= Info.CleanupStack.size() &&
-             "running cleanups out of order?");
+  SpeculativeEvaluationRAII(
+      EvalInfo &Info, SmallVectorImpl<PartialDiagnosticAt> *NewDiag = nullptr)
+      : Info(&Info), OldStatus(Info.EvalStatus),
+        OldSpeculativeEvaluationDepth(Info.SpeculativeEvaluationDepth) {
+    Info.EvalStatus.Diag = NewDiag;
+    Info.SpeculativeEvaluationDepth = Info.CallStackDepth + 1;
+  }
 
-      // Run all cleanups for a block scope, and non-lifetime-extended cleanups
-      // for a full-expression scope.
-      bool Success = true;
-      for (unsigned I = Info.CleanupStack.size(); I > OldStackSize; --I) {
-        if (Info.CleanupStack[I - 1].isDestroyedAtEndOf(Kind)) {
-          if (!Info.CleanupStack[I - 1].endLifetime(Info, RunDestructors)) {
-            Success = false;
-            break;
-          }
+  SpeculativeEvaluationRAII(SpeculativeEvaluationRAII const &Other) = delete;
+  SpeculativeEvaluationRAII(SpeculativeEvaluationRAII &&Other) {
+    moveFromAndCancel(std::move(Other));
+  }
+
+  SpeculativeEvaluationRAII &operator=(SpeculativeEvaluationRAII &&Other) {
+    maybeRestoreState();
+    moveFromAndCancel(std::move(Other));
+    return *this;
+  }
+
+  ~SpeculativeEvaluationRAII() { maybeRestoreState(); }
+};
+
+/// RAII object wrapping a full-expression or block scope, and handling
+/// the ending of the lifetime of temporaries created within it.
+template <ScopeKind Kind> class ScopeRAII {
+  EvalInfo &Info;
+  unsigned OldStackSize;
+
+public:
+  ScopeRAII(EvalInfo &Info)
+      : Info(Info), OldStackSize(Info.CleanupStack.size()) {
+    // Push a new temporary version. This is needed to distinguish between
+    // temporaries created in different iterations of a loop.
+    Info.CurrentCall->pushTempVersion();
+  }
+  bool destroy(bool RunDestructors = true) {
+    bool OK = cleanup(Info, RunDestructors, OldStackSize);
+    OldStackSize = -1U;
+    return OK;
+  }
+  ~ScopeRAII() {
+    if (OldStackSize != -1U)
+      destroy(false);
+    // Body moved to a static method to encourage the compiler to inline away
+    // instances of this class.
+    Info.CurrentCall->popTempVersion();
+  }
+
+private:
+  static bool cleanup(EvalInfo &Info, bool RunDestructors,
+                      unsigned OldStackSize) {
+    assert(OldStackSize <= Info.CleanupStack.size() &&
+           "running cleanups out of order?");
+
+    // Run all cleanups for a block scope, and non-lifetime-extended cleanups
+    // for a full-expression scope.
+    bool Success = true;
+    for (unsigned I = Info.CleanupStack.size(); I > OldStackSize; --I) {
+      if (Info.CleanupStack[I - 1].isDestroyedAtEndOf(Kind)) {
+        if (!Info.CleanupStack[I - 1].endLifetime(Info, RunDestructors)) {
+          Success = false;
+          break;
         }
       }
-
-      // Compact any retained cleanups.
-      auto NewEnd = Info.CleanupStack.begin() + OldStackSize;
-      if (Kind != ScopeKind::Block)
-        NewEnd =
-            std::remove_if(NewEnd, Info.CleanupStack.end(), [](Cleanup &C) {
-              return C.isDestroyedAtEndOf(Kind);
-            });
-      Info.CleanupStack.erase(NewEnd, Info.CleanupStack.end());
-      return Success;
     }
-  };
-  typedef ScopeRAII<ScopeKind::Block> BlockScopeRAII;
-  typedef ScopeRAII<ScopeKind::FullExpression> FullExpressionRAII;
-  typedef ScopeRAII<ScopeKind::Call> CallScopeRAII;
-}
 
-bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E,
+    // Compact any retained cleanups.
+    auto NewEnd = Info.CleanupStack.begin() + OldStackSize;
+    if (Kind != ScopeKind::Block)
+      NewEnd = std::remove_if(NewEnd, Info.CleanupStack.end(), [](Cleanup &C) {
+        return C.isDestroyedAtEndOf(Kind);
+      });
+    Info.CleanupStack.erase(NewEnd, Info.CleanupStack.end());
+    return Success;
+  }
+};
+typedef ScopeRAII<ScopeKind::Block> BlockScopeRAII;
+typedef ScopeRAII<ScopeKind::FullExpression> FullExpressionRAII;
+typedef ScopeRAII<ScopeKind::Call> CallScopeRAII;
+} // namespace
+
+bool SubobjectDesignator::checkSubobject(EvalInfo &Info, Expr const *E,
                                          CheckSubobjectKind CSK) {
   if (Invalid)
     return false;
   if (isOnePastTheEnd()) {
-    Info.CCEDiag(E, diag::note_constexpr_past_end_subobject)
-      << CSK;
+    Info.CCEDiag(E, diag::note_constexpr_past_end_subobject) << CSK;
     setInvalid();
     return false;
   }
@@ -1413,29 +1386,27 @@
 }
 
 void SubobjectDesignator::diagnoseUnsizedArrayPointerArithmetic(EvalInfo &Info,
-                                                                const Expr *E) {
+                                                                Expr const *E) {
   Info.CCEDiag(E, diag::note_constexpr_unsized_array_indexed);
   // Do not set the designator as invalid: we can represent this situation,
   // and correct handling of __builtin_object_size requires us to do so.
 }
 
 void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info,
-                                                    const Expr *E,
-                                                    const APSInt &N) {
+                                                    Expr const *E,
+                                                    APSInt const &N) {
   // If we're complaining, we must be able to statically determine the size of
   // the most derived array.
   if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)
     Info.CCEDiag(E, diag::note_constexpr_array_index)
-      << N << /*array*/ 0
-      << static_cast<unsigned>(getMostDerivedArraySize());
+        << N << /*array*/ 0 << static_cast<unsigned>(getMostDerivedArraySize());
   else
-    Info.CCEDiag(E, diag::note_constexpr_array_index)
-      << N << /*non-array*/ 1;
+    Info.CCEDiag(E, diag::note_constexpr_array_index) << N << /*non-array*/ 1;
   setInvalid();
 }
 
 CallStackFrame::CallStackFrame(EvalInfo &Info, SourceLocation CallLoc,
-                               const FunctionDecl *Callee, const LValue *This,
+                               FunctionDecl const *Callee, LValue const *This,
                                CallRef Call)
     : Info(Info), Caller(Info.CurrentCall), Callee(Callee), This(This),
       Arguments(Call), CallLoc(CallLoc), Index(Info.NextCallIndex++) {
@@ -1506,335 +1477,326 @@
 }
 
 namespace {
-  struct ComplexValue {
-  private:
-    bool IsInt;
+struct ComplexValue {
+private:
+  bool IsInt;
 
-  public:
-    APSInt IntReal, IntImag;
-    APFloat FloatReal, FloatImag;
+public:
+  APSInt IntReal, IntImag;
+  APFloat FloatReal, FloatImag;
 
-    ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
+  ComplexValue() : FloatReal(APFloat::Bogus()), FloatImag(APFloat::Bogus()) {}
 
-    void makeComplexFloat() { IsInt = false; }
-    bool isComplexFloat() const { return !IsInt; }
-    APFloat &getComplexFloatReal() { return FloatReal; }
-    APFloat &getComplexFloatImag() { return FloatImag; }
+  void makeComplexFloat() { IsInt = false; }
+  bool isComplexFloat() const { return !IsInt; }
+  APFloat &getComplexFloatReal() { return FloatReal; }
+  APFloat &getComplexFloatImag() { return FloatImag; }
 
-    void makeComplexInt() { IsInt = true; }
-    bool isComplexInt() const { return IsInt; }
-    APSInt &getComplexIntReal() { return IntReal; }
-    APSInt &getComplexIntImag() { return IntImag; }
+  void makeComplexInt() { IsInt = true; }
+  bool isComplexInt() const { return IsInt; }
+  APSInt &getComplexIntReal() { return IntReal; }
+  APSInt &getComplexIntImag() { return IntImag; }
 
-    void moveInto(APValue &v) const {
-      if (isComplexFloat())
-        v = APValue(FloatReal, FloatImag);
-      else
-        v = APValue(IntReal, IntImag);
-    }
-    void setFrom(const APValue &v) {
-      assert(v.isComplexFloat() || v.isComplexInt());
-      if (v.isComplexFloat()) {
-        makeComplexFloat();
-        FloatReal = v.getComplexFloatReal();
-        FloatImag = v.getComplexFloatImag();
-      } else {
-        makeComplexInt();
-        IntReal = v.getComplexIntReal();
-        IntImag = v.getComplexIntImag();
-      }
+  void moveInto(APValue &v) const {
+    if (isComplexFloat())
+      v = APValue(FloatReal, FloatImag);
+    else
+      v = APValue(IntReal, IntImag);
+  }
+  void setFrom(APValue const &v) {
+    assert(v.isComplexFloat() || v.isComplexInt());
+    if (v.isComplexFloat()) {
+      makeComplexFloat();
+      FloatReal = v.getComplexFloatReal();
+      FloatImag = v.getComplexFloatImag();
+    } else {
+      makeComplexInt();
+      IntReal = v.getComplexIntReal();
+      IntImag = v.getComplexIntImag();
     }
-  };
+  }
+};
 
-  struct LValue {
-    APValue::LValueBase Base;
-    CharUnits Offset;
-    SubobjectDesignator Designator;
-    bool IsNullPtr : 1;
-    bool InvalidBase : 1;
-
-    const APValue::LValueBase getLValueBase() const { return Base; }
-    CharUnits &getLValueOffset() { return Offset; }
-    const CharUnits &getLValueOffset() const { return Offset; }
-    SubobjectDesignator &getLValueDesignator() { return Designator; }
-    const SubobjectDesignator &getLValueDesignator() const { return Designator;}
-    bool isNullPointer() const { return IsNullPtr;}
-
-    unsigned getLValueCallIndex() const { return Base.getCallIndex(); }
-    unsigned getLValueVersion() const { return Base.getVersion(); }
-
-    void moveInto(APValue &V) const {
-      if (Designator.Invalid)
-        V = APValue(Base, Offset, APValue::NoLValuePath(), IsNullPtr);
-      else {
-        assert(!InvalidBase && "APValues can't handle invalid LValue bases");
-        V = APValue(Base, Offset, Designator.Entries,
-                    Designator.IsOnePastTheEnd, IsNullPtr);
-      }
-    }
-    void setFrom(ASTContext &Ctx, const APValue &V) {
-      assert(V.isLValue() && "Setting LValue from a non-LValue?");
-      Base = V.getLValueBase();
-      Offset = V.getLValueOffset();
-      InvalidBase = false;
-      Designator = SubobjectDesignator(Ctx, V);
-      IsNullPtr = V.isNullPointer();
+struct LValue {
+  APValue::LValueBase Base;
+  CharUnits Offset;
+  SubobjectDesignator Designator;
+  bool IsNullPtr : 1;
+  bool InvalidBase : 1;
+
+  const APValue::LValueBase getLValueBase() const { return Base; }
+  CharUnits &getLValueOffset() { return Offset; }
+  CharUnits const &getLValueOffset() const { return Offset; }
+  SubobjectDesignator &getLValueDesignator() { return Designator; }
+  SubobjectDesignator const &getLValueDesignator() const { return Designator; }
+  bool isNullPointer() const { return IsNullPtr; }
+
+  unsigned getLValueCallIndex() const { return Base.getCallIndex(); }
+  unsigned getLValueVersion() const { return Base.getVersion(); }
+
+  void moveInto(APValue &V) const {
+    if (Designator.Invalid)
+      V = APValue(Base, Offset, APValue::NoLValuePath(), IsNullPtr);
+    else {
+      assert(!InvalidBase && "APValues can't handle invalid LValue bases");
+      V = APValue(Base, Offset, Designator.Entries, Designator.IsOnePastTheEnd,
+                  IsNullPtr);
     }
+  }
+  void setFrom(ASTContext &Ctx, APValue const &V) {
+    assert(V.isLValue() && "Setting LValue from a non-LValue?");
+    Base = V.getLValueBase();
+    Offset = V.getLValueOffset();
+    InvalidBase = false;
+    Designator = SubobjectDesignator(Ctx, V);
+    IsNullPtr = V.isNullPointer();
+  }
 
-    void set(APValue::LValueBase B, bool BInvalid = false) {
+  void set(APValue::LValueBase B, bool BInvalid = false) {
 #ifndef NDEBUG
-      // We only allow a few types of invalid bases. Enforce that here.
-      if (BInvalid) {
-        const auto *E = B.get<const Expr *>();
-        assert((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&
-               "Unexpected type of invalid base");
-      }
-#endif
-
-      Base = B;
-      Offset = CharUnits::fromQuantity(0);
-      InvalidBase = BInvalid;
-      Designator = SubobjectDesignator(getType(B));
-      IsNullPtr = false;
-    }
-
-    void setNull(ASTContext &Ctx, QualType PointerTy) {
-      Base = (const ValueDecl *)nullptr;
-      Offset =
-          CharUnits::fromQuantity(Ctx.getTargetNullPointerValue(PointerTy));
-      InvalidBase = false;
-      Designator = SubobjectDesignator(PointerTy->getPointeeType());
-      IsNullPtr = true;
+    // We only allow a few types of invalid bases. Enforce that here.
+    if (BInvalid) {
+      auto const *E = B.get<Expr const *>();
+      assert((isa<MemberExpr>(E) || tryUnwrapAllocSizeCall(E)) &&
+             "Unexpected type of invalid base");
     }
+#endif
 
-    void setInvalid(APValue::LValueBase B, unsigned I = 0) {
-      set(B, true);
-    }
+    Base = B;
+    Offset = CharUnits::fromQuantity(0);
+    InvalidBase = BInvalid;
+    Designator = SubobjectDesignator(getType(B));
+    IsNullPtr = false;
+  }
 
-    std::string toString(ASTContext &Ctx, QualType T) const {
-      APValue Printable;
-      moveInto(Printable);
-      return Printable.getAsString(Ctx, T);
-    }
+  void setNull(ASTContext &Ctx, QualType PointerTy) {
+    Base = (ValueDecl const *)nullptr;
+    Offset = CharUnits::fromQuantity(Ctx.getTargetNullPointerValue(PointerTy));
+    InvalidBase = false;
+    Designator = SubobjectDesignator(PointerTy->getPointeeType());
+    IsNullPtr = true;
+  }
 
-  private:
-    // Check that this LValue is not based on a null pointer. If it is, produce
-    // a diagnostic and mark the designator as invalid.
-    template <typename GenDiagType>
-    bool checkNullPointerDiagnosingWith(const GenDiagType &GenDiag) {
-      if (Designator.Invalid)
-        return false;
-      if (IsNullPtr) {
-        GenDiag();
-        Designator.setInvalid();
-        return false;
-      }
-      return true;
-    }
+  void setInvalid(APValue::LValueBase B, unsigned I = 0) { set(B, true); }
 
-  public:
-    bool checkNullPointer(EvalInfo &Info, const Expr *E,
-                          CheckSubobjectKind CSK) {
-      return checkNullPointerDiagnosingWith([&Info, E, CSK] {
-        Info.CCEDiag(E, diag::note_constexpr_null_subobject) << CSK;
-      });
-    }
+  std::string toString(ASTContext &Ctx, QualType T) const {
+    APValue Printable;
+    moveInto(Printable);
+    return Printable.getAsString(Ctx, T);
+  }
 
-    bool checkNullPointerForFoldAccess(EvalInfo &Info, const Expr *E,
-                                       AccessKinds AK) {
-      return checkNullPointerDiagnosingWith([&Info, E, AK] {
-        Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
-      });
+private:
+  // Check that this LValue is not based on a null pointer. If it is, produce
+  // a diagnostic and mark the designator as invalid.
+  template <typename GenDiagType>
+  bool checkNullPointerDiagnosingWith(GenDiagType const &GenDiag) {
+    if (Designator.Invalid)
+      return false;
+    if (IsNullPtr) {
+      GenDiag();
+      Designator.setInvalid();
+      return false;
     }
+    return true;
+  }
 
-    // Check this LValue refers to an object. If not, set the designator to be
-    // invalid and emit a diagnostic.
-    bool checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {
-      return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
-             Designator.checkSubobject(Info, E, CSK);
-    }
+public:
+  bool checkNullPointer(EvalInfo &Info, Expr const *E, CheckSubobjectKind CSK) {
+    return checkNullPointerDiagnosingWith([&Info, E, CSK] {
+      Info.CCEDiag(E, diag::note_constexpr_null_subobject) << CSK;
+    });
+  }
 
-    void addDecl(EvalInfo &Info, const Expr *E,
-                 const Decl *D, bool Virtual = false) {
-      if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
-        Designator.addDeclUnchecked(D, Virtual);
-    }
-    void addUnsizedArray(EvalInfo &Info, const Expr *E, QualType ElemTy) {
-      if (!Designator.Entries.empty()) {
-        Info.CCEDiag(E, diag::note_constexpr_unsupported_unsized_array);
-        Designator.setInvalid();
-        return;
-      }
-      if (checkSubobject(Info, E, CSK_ArrayToPointer)) {
-        assert(getType(Base)->isPointerType() || getType(Base)->isArrayType());
-        Designator.FirstEntryIsAnUnsizedArray = true;
-        Designator.addUnsizedArrayUnchecked(ElemTy);
-      }
-    }
-    void addArray(EvalInfo &Info, const Expr *E, const ConstantArrayType *CAT) {
-      if (checkSubobject(Info, E, CSK_ArrayToPointer))
-        Designator.addArrayUnchecked(CAT);
-    }
-    void addComplex(EvalInfo &Info, const Expr *E, QualType EltTy, bool Imag) {
-      if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
-        Designator.addComplexUnchecked(EltTy, Imag);
-    }
-    void clearIsNullPointer() {
-      IsNullPtr = false;
-    }
-    void adjustOffsetAndIndex(EvalInfo &Info, const Expr *E,
-                              const APSInt &Index, CharUnits ElementSize) {
-      // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB,
-      // but we're not required to diagnose it and it's valid in C++.)
-      if (!Index)
-        return;
+  bool checkNullPointerForFoldAccess(EvalInfo &Info, Expr const *E,
+                                     AccessKinds AK) {
+    return checkNullPointerDiagnosingWith([&Info, E, AK] {
+      Info.FFDiag(E, diag::note_constexpr_access_null) << AK;
+    });
+  }
 
-      // Compute the new offset in the appropriate width, wrapping at 64 bits.
-      // FIXME: When compiling for a 32-bit target, we should use 32-bit
-      // offsets.
-      uint64_t Offset64 = Offset.getQuantity();
-      uint64_t ElemSize64 = ElementSize.getQuantity();
-      uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
-      Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64);
+  // Check this LValue refers to an object. If not, set the designator to be
+  // invalid and emit a diagnostic.
+  bool checkSubobject(EvalInfo &Info, Expr const *E, CheckSubobjectKind CSK) {
+    return (CSK == CSK_ArrayToPointer || checkNullPointer(Info, E, CSK)) &&
+           Designator.checkSubobject(Info, E, CSK);
+  }
 
-      if (checkNullPointer(Info, E, CSK_ArrayIndex))
-        Designator.adjustIndex(Info, E, Index);
-      clearIsNullPointer();
+  void addDecl(EvalInfo &Info, Expr const *E, Decl const *D,
+               bool Virtual = false) {
+    if (checkSubobject(Info, E, isa<FieldDecl>(D) ? CSK_Field : CSK_Base))
+      Designator.addDeclUnchecked(D, Virtual);
+  }
+  void addUnsizedArray(EvalInfo &Info, Expr const *E, QualType ElemTy) {
+    if (!Designator.Entries.empty()) {
+      Info.CCEDiag(E, diag::note_constexpr_unsupported_unsized_array);
+      Designator.setInvalid();
+      return;
     }
-    void adjustOffset(CharUnits N) {
-      Offset += N;
-      if (N.getQuantity())
-        clearIsNullPointer();
+    if (checkSubobject(Info, E, CSK_ArrayToPointer)) {
+      assert(getType(Base)->isPointerType() || getType(Base)->isArrayType());
+      Designator.FirstEntryIsAnUnsizedArray = true;
+      Designator.addUnsizedArrayUnchecked(ElemTy);
     }
-  };
+  }
+  void addArray(EvalInfo &Info, Expr const *E, ConstantArrayType const *CAT) {
+    if (checkSubobject(Info, E, CSK_ArrayToPointer))
+      Designator.addArrayUnchecked(CAT);
+  }
+  void addComplex(EvalInfo &Info, Expr const *E, QualType EltTy, bool Imag) {
+    if (checkSubobject(Info, E, Imag ? CSK_Imag : CSK_Real))
+      Designator.addComplexUnchecked(EltTy, Imag);
+  }
+  void clearIsNullPointer() { IsNullPtr = false; }
+  void adjustOffsetAndIndex(EvalInfo &Info, Expr const *E, APSInt const &Index,
+                            CharUnits ElementSize) {
+    // An index of 0 has no effect. (In C, adding 0 to a null pointer is UB,
+    // but we're not required to diagnose it and it's valid in C++.)
+    if (!Index)
+      return;
 
-  struct MemberPtr {
-    MemberPtr() {}
-    explicit MemberPtr(const ValueDecl *Decl) :
-      DeclAndIsDerivedMember(Decl, false), Path() {}
-
-    /// The member or (direct or indirect) field referred to by this member
-    /// pointer, or 0 if this is a null member pointer.
-    const ValueDecl *getDecl() const {
-      return DeclAndIsDerivedMember.getPointer();
-    }
-    /// Is this actually a member of some type derived from the relevant class?
-    bool isDerivedMember() const {
-      return DeclAndIsDerivedMember.getInt();
-    }
-    /// Get the class which the declaration actually lives in.
-    const CXXRecordDecl *getContainingRecord() const {
-      return cast<CXXRecordDecl>(
-          DeclAndIsDerivedMember.getPointer()->getDeclContext());
-    }
-
-    void moveInto(APValue &V) const {
-      V = APValue(getDecl(), isDerivedMember(), Path);
-    }
-    void setFrom(const APValue &V) {
-      assert(V.isMemberPointer());
-      DeclAndIsDerivedMember.setPointer(V.getMemberPointerDecl());
-      DeclAndIsDerivedMember.setInt(V.isMemberPointerToDerivedMember());
-      Path.clear();
-      ArrayRef<const CXXRecordDecl*> P = V.getMemberPointerPath();
-      Path.insert(Path.end(), P.begin(), P.end());
-    }
-
-    /// DeclAndIsDerivedMember - The member declaration, and a flag indicating
-    /// whether the member is a member of some class derived from the class type
-    /// of the member pointer.
-    llvm::PointerIntPair<const ValueDecl*, 1, bool> DeclAndIsDerivedMember;
-    /// Path - The path of base/derived classes from the member declaration's
-    /// class (exclusive) to the class type of the member pointer (inclusive).
-    SmallVector<const CXXRecordDecl*, 4> Path;
-
-    /// Perform a cast towards the class of the Decl (either up or down the
-    /// hierarchy).
-    bool castBack(const CXXRecordDecl *Class) {
-      assert(!Path.empty());
-      const CXXRecordDecl *Expected;
-      if (Path.size() >= 2)
-        Expected = Path[Path.size() - 2];
-      else
-        Expected = getContainingRecord();
-      if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) {
-        // C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*),
-        // if B does not contain the original member and is not a base or
-        // derived class of the class containing the original member, the result
-        // of the cast is undefined.
-        // C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to
-        // (D::*). We consider that to be a language defect.
-        return false;
-      }
-      Path.pop_back();
-      return true;
+    // Compute the new offset in the appropriate width, wrapping at 64 bits.
+    // FIXME: When compiling for a 32-bit target, we should use 32-bit
+    // offsets.
+    uint64_t Offset64 = Offset.getQuantity();
+    uint64_t ElemSize64 = ElementSize.getQuantity();
+    uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
+    Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64);
+
+    if (checkNullPointer(Info, E, CSK_ArrayIndex))
+      Designator.adjustIndex(Info, E, Index);
+    clearIsNullPointer();
+  }
+  void adjustOffset(CharUnits N) {
+    Offset += N;
+    if (N.getQuantity())
+      clearIsNullPointer();
+  }
+};
+
+struct MemberPtr {
+  MemberPtr() {}
+  explicit MemberPtr(ValueDecl const *Decl)
+      : DeclAndIsDerivedMember(Decl, false), Path() {}
+
+  /// The member or (direct or indirect) field referred to by this member
+  /// pointer, or 0 if this is a null member pointer.
+  ValueDecl const *getDecl() const {
+    return DeclAndIsDerivedMember.getPointer();
+  }
+  /// Is this actually a member of some type derived from the relevant class?
+  bool isDerivedMember() const { return DeclAndIsDerivedMember.getInt(); }
+  /// Get the class which the declaration actually lives in.
+  CXXRecordDecl const *getContainingRecord() const {
+    return cast<CXXRecordDecl>(
+        DeclAndIsDerivedMember.getPointer()->getDeclContext());
+  }
+
+  void moveInto(APValue &V) const {
+    V = APValue(getDecl(), isDerivedMember(), Path);
+  }
+  void setFrom(APValue const &V) {
+    assert(V.isMemberPointer());
+    DeclAndIsDerivedMember.setPointer(V.getMemberPointerDecl());
+    DeclAndIsDerivedMember.setInt(V.isMemberPointerToDerivedMember());
+    Path.clear();
+    ArrayRef<CXXRecordDecl const *> P = V.getMemberPointerPath();
+    Path.insert(Path.end(), P.begin(), P.end());
+  }
+
+  /// DeclAndIsDerivedMember - The member declaration, and a flag indicating
+  /// whether the member is a member of some class derived from the class type
+  /// of the member pointer.
+  llvm::PointerIntPair<ValueDecl const *, 1, bool> DeclAndIsDerivedMember;
+  /// Path - The path of base/derived classes from the member declaration's
+  /// class (exclusive) to the class type of the member pointer (inclusive).
+  SmallVector<CXXRecordDecl const *, 4> Path;
+
+  /// Perform a cast towards the class of the Decl (either up or down the
+  /// hierarchy).
+  bool castBack(CXXRecordDecl const *Class) {
+    assert(!Path.empty());
+    CXXRecordDecl const *Expected;
+    if (Path.size() >= 2)
+      Expected = Path[Path.size() - 2];
+    else
+      Expected = getContainingRecord();
+    if (Expected->getCanonicalDecl() != Class->getCanonicalDecl()) {
+      // C++11 [expr.static.cast]p12: In a conversion from (D::*) to (B::*),
+      // if B does not contain the original member and is not a base or
+      // derived class of the class containing the original member, the result
+      // of the cast is undefined.
+      // C++11 [conv.mem]p2 does not cover this case for a cast from (B::*) to
+      // (D::*). We consider that to be a language defect.
+      return false;
     }
-    /// Perform a base-to-derived member pointer cast.
-    bool castToDerived(const CXXRecordDecl *Derived) {
-      if (!getDecl())
-        return true;
-      if (!isDerivedMember()) {
-        Path.push_back(Derived);
-        return true;
-      }
-      if (!castBack(Derived))
-        return false;
-      if (Path.empty())
-        DeclAndIsDerivedMember.setInt(false);
+    Path.pop_back();
+    return true;
+  }
+  /// Perform a base-to-derived member pointer cast.
+  bool castToDerived(CXXRecordDecl const *Derived) {
+    if (!getDecl())
+      return true;
+    if (!isDerivedMember()) {
+      Path.push_back(Derived);
       return true;
     }
-    /// Perform a derived-to-base member pointer cast.
-    bool castToBase(const CXXRecordDecl *Base) {
-      if (!getDecl())
-        return true;
-      if (Path.empty())
-        DeclAndIsDerivedMember.setInt(true);
-      if (isDerivedMember()) {
-        Path.push_back(Base);
-        return true;
-      }
-      return castBack(Base);
-    }
-  };
-
-  /// Compare two member pointers, which are assumed to be of the same type.
-  static bool operator==(const MemberPtr &LHS, const MemberPtr &RHS) {
-    if (!LHS.getDecl() || !RHS.getDecl())
-      return !LHS.getDecl() && !RHS.getDecl();
-    if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl())
+    if (!castBack(Derived))
       return false;
-    return LHS.Path == RHS.Path;
+    if (Path.empty())
+      DeclAndIsDerivedMember.setInt(false);
+    return true;
+  }
+  /// Perform a derived-to-base member pointer cast.
+  bool castToBase(CXXRecordDecl const *Base) {
+    if (!getDecl())
+      return true;
+    if (Path.empty())
+      DeclAndIsDerivedMember.setInt(true);
+    if (isDerivedMember()) {
+      Path.push_back(Base);
+      return true;
+    }
+    return castBack(Base);
   }
+};
+
+/// Compare two member pointers, which are assumed to be of the same type.
+static bool operator==(MemberPtr const &LHS, MemberPtr const &RHS) {
+  if (!LHS.getDecl() || !RHS.getDecl())
+    return !LHS.getDecl() && !RHS.getDecl();
+  if (LHS.getDecl()->getCanonicalDecl() != RHS.getDecl()->getCanonicalDecl())
+    return false;
+  return LHS.Path == RHS.Path;
 }
+} // namespace
 
-static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E);
-static bool EvaluateInPlace(APValue &Result, EvalInfo &Info,
-                            const LValue &This, const Expr *E,
-                            bool AllowNonLiteralTypes = false);
-static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
+static bool Evaluate(APValue &Result, EvalInfo &Info, Expr const *E);
+static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, LValue const &This,
+                            Expr const *E, bool AllowNonLiteralTypes = false);
+static bool EvaluateLValue(Expr const *E, LValue &Result, EvalInfo &Info,
                            bool InvalidBaseOK = false);
-static bool EvaluatePointer(const Expr *E, LValue &Result, EvalInfo &Info,
+static bool EvaluatePointer(Expr const *E, LValue &Result, EvalInfo &Info,
                             bool InvalidBaseOK = false);
-static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
+static bool EvaluateMemberPointer(Expr const *E, MemberPtr &Result,
                                   EvalInfo &Info);
-static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info);
-static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info);
-static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
+static bool EvaluateTemporary(Expr const *E, LValue &Result, EvalInfo &Info);
+static bool EvaluateInteger(Expr const *E, APSInt &Result, EvalInfo &Info);
+static bool EvaluateIntegerOrLValue(Expr const *E, APValue &Result,
                                     EvalInfo &Info);
-static bool EvaluateFloat(const Expr *E, APFloat &Result, EvalInfo &Info);
-static bool EvaluateComplex(const Expr *E, ComplexValue &Res, EvalInfo &Info);
-static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
+static bool EvaluateFloat(Expr const *E, APFloat &Result, EvalInfo &Info);
+static bool EvaluateComplex(Expr const *E, ComplexValue &Res, EvalInfo &Info);
+static bool EvaluateAtomic(Expr const *E, LValue const *This, APValue &Result,
                            EvalInfo &Info);
-static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result);
-static bool EvaluateBuiltinStrLen(const Expr *E, uint64_t &Result,
+static bool EvaluateAsRValue(EvalInfo &Info, Expr const *E, APValue &Result);
+static bool EvaluateBuiltinStrLen(Expr const *E, uint64_t &Result,
                                   EvalInfo &Info);
 
 /// Evaluate an integer or fixed point expression into an APResult.
-static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
+static bool EvaluateFixedPointOrInteger(Expr const *E, APFixedPoint &Result,
                                         EvalInfo &Info);
 
 /// Evaluate only a fixed point expression into an APResult.
-static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
+static bool EvaluateFixedPoint(Expr const *E, APFixedPoint &Result,
                                EvalInfo &Info);
 
 //===----------------------------------------------------------------------===//
@@ -1851,8 +1813,8 @@
   Int = -Int;
 }
 
-template<typename KeyT>
-APValue &CallStackFrame::createTemporary(const KeyT *Key, QualType T,
+template <typename KeyT>
+APValue &CallStackFrame::createTemporary(KeyT const *Key, QualType T,
                                          ScopeKind Scope, LValue &LV) {
   unsigned Version = getTempVersion();
   APValue::LValueBase Base(Key, Index, Version);
@@ -1861,7 +1823,7 @@
 }
 
 /// Allocate storage for a parameter of a function call made in this frame.
-APValue &CallStackFrame::createParam(CallRef Args, const ParmVarDecl *PVD,
+APValue &CallStackFrame::createParam(CallRef Args, ParmVarDecl const *PVD,
                                      LValue &LV) {
   assert(Args.CallIndex == Index && "creating parameter in wrong frame");
   APValue::LValueBase Base(PVD, Index, Args.Version);
@@ -1872,7 +1834,7 @@
   return createLocal(Base, PVD, PVD->getType(), ScopeKind::Call);
 }
 
-APValue &CallStackFrame::createLocal(APValue::LValueBase Base, const void *Key,
+APValue &CallStackFrame::createLocal(APValue::LValueBase Base, void const *Key,
                                      QualType T, ScopeKind Scope) {
   assert(Base.getCallIndex() == Index && "lvalue for wrong frame");
   unsigned Version = Base.getVersion();
@@ -1892,7 +1854,7 @@
   return Result;
 }
 
-APValue *EvalInfo::createHeapAlloc(const Expr *E, QualType T, LValue &LV) {
+APValue *EvalInfo::createHeapAlloc(Expr const *E, QualType T, LValue &LV) {
   if (NumHeapAllocs > DynamicAllocLValue::getMaxIndex()) {
     FFDiag(E, diag::note_constexpr_heap_alloc_limit_exceeded);
     return nullptr;
@@ -1920,19 +1882,19 @@
   if (This && IsMemberCall) {
     APValue Val;
     This->moveInto(Val);
-    Val.printPretty(Out, Info.Ctx,
-                    This->Designator.MostDerivedType);
+    Val.printPretty(Out, Info.Ctx, This->Designator.MostDerivedType);
     // FIXME: Add parens around Val if needed.
     Out << "->" << *Callee << '(';
     IsMemberCall = false;
   }
 
   for (FunctionDecl::param_const_iterator I = Callee->param_begin(),
-       E = Callee->param_end(); I != E; ++I, ++ArgIndex) {
+                                          E = Callee->param_end();
+       I != E; ++I, ++ArgIndex) {
     if (ArgIndex > (unsigned)IsMemberCall)
       Out << ", ";
 
-    const ParmVarDecl *Param = *I;
+    ParmVarDecl const *Param = *I;
     APValue *V = Info.getParamSlot(Arguments, Param);
     if (V)
       V->printPretty(Out, Info.Ctx, Param->getType());
@@ -1949,7 +1911,7 @@
 /// Evaluate an expression to see if it had side-effects, and discard its
 /// result.
 /// \return \c true if the caller should keep evaluating.
-static bool EvaluateIgnoredValue(EvalInfo &Info, const Expr *E) {
+static bool EvaluateIgnoredValue(EvalInfo &Info, Expr const *E) {
   assert(!E->isValueDependent());
   APValue Scratch;
   if (!Evaluate(Scratch, Info, E))
@@ -1959,7 +1921,7 @@
 }
 
 /// Should this call expression be treated as a string literal?
-static bool IsStringLiteralCall(const CallExpr *E) {
+static bool IsStringLiteralCall(CallExpr const *E) {
   unsigned Builtin = E->getBuiltinCallee();
   return (Builtin == Builtin::BI__builtin___CFStringMakeConstantString ||
           Builtin == Builtin::BI__builtin___NSStringMakeConstantString);
@@ -1971,11 +1933,12 @@
 
   // ... a null pointer value, or a prvalue core constant expression of type
   // std::nullptr_t.
-  if (!B) return true;
+  if (!B)
+    return true;
 
-  if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
+  if (ValueDecl const *D = B.dyn_cast<ValueDecl const *>()) {
     // ... the address of an object with static storage duration,
-    if (const VarDecl *VD = dyn_cast<VarDecl>(D))
+    if (VarDecl const *VD = dyn_cast<VarDecl>(D))
       return VD->hasGlobalStorage();
     if (isa<TemplateParamObjectDecl>(D))
       return true;
@@ -1987,12 +1950,12 @@
   if (B.is<TypeInfoLValue>() || B.is<DynamicAllocLValue>())
     return true;
 
-  const Expr *E = B.get<const Expr*>();
+  Expr const *E = B.get<Expr const *>();
   switch (E->getStmtClass()) {
   default:
     return false;
   case Expr::CompoundLiteralExprClass: {
-    const CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
+    CompoundLiteralExpr const *CLE = cast<CompoundLiteralExpr>(E);
     return CLE->isFileScope() && CLE->isLValue();
   }
   case Expr::MaterializeTemporaryExprClass:
@@ -2027,24 +1990,24 @@
   }
 }
 
-static const ValueDecl *GetLValueBaseDecl(const LValue &LVal) {
-  return LVal.Base.dyn_cast<const ValueDecl*>();
+static ValueDecl const *GetLValueBaseDecl(LValue const &LVal) {
+  return LVal.Base.dyn_cast<ValueDecl const *>();
 }
 
-static bool IsLiteralLValue(const LValue &Value) {
+static bool IsLiteralLValue(LValue const &Value) {
   if (Value.getLValueCallIndex())
     return false;
-  const Expr *E = Value.Base.dyn_cast<const Expr*>();
+  Expr const *E = Value.Base.dyn_cast<Expr const *>();
   return E && !isa<MaterializeTemporaryExpr>(E);
 }
 
-static bool IsWeakLValue(const LValue &Value) {
-  const ValueDecl *Decl = GetLValueBaseDecl(Value);
+static bool IsWeakLValue(LValue const &Value) {
+  ValueDecl const *Decl = GetLValueBaseDecl(Value);
   return Decl && Decl->isWeak();
 }
 
-static bool isZeroSized(const LValue &Value) {
-  const ValueDecl *Decl = GetLValueBaseDecl(Value);
+static bool isZeroSized(LValue const &Value) {
+  ValueDecl const *Decl = GetLValueBaseDecl(Value);
   if (Decl && isa<VarDecl>(Decl)) {
     QualType Ty = Decl->getType();
     if (Ty->isArrayType())
@@ -2054,14 +2017,13 @@
   return false;
 }
 
-static bool HasSameBase(const LValue &A, const LValue &B) {
+static bool HasSameBase(LValue const &A, LValue const &B) {
   if (!A.getLValueBase())
     return !B.getLValueBase();
   if (!B.getLValueBase())
     return false;
 
-  if (A.getLValueBase().getOpaqueValue() !=
-      B.getLValueBase().getOpaqueValue())
+  if (A.getLValueBase().getOpaqueValue() != B.getLValueBase().getOpaqueValue())
     return false;
 
   return A.getLValueCallIndex() == B.getLValueCallIndex() &&
@@ -2070,7 +2032,7 @@
 
 static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) {
   assert(Base && "no location for a null lvalue");
-  const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
+  ValueDecl const *VD = Base.dyn_cast<ValueDecl const *>();
 
   // For a parameter, find the corresponding call stack frame (if it still
   // exists), and point at the parameter of the function definition we actually
@@ -2089,11 +2051,11 @@
 
   if (VD)
     Info.Note(VD->getLocation(), diag::note_declared_at);
-  else if (const Expr *E = Base.dyn_cast<const Expr*>())
+  else if (Expr const *E = Base.dyn_cast<Expr const *>())
     Info.Note(E->getExprLoc(), diag::note_constexpr_temporary_here);
   else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
     // FIXME: Produce a note for dangling pointers too.
-    if (Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA))
+    if (Optional<DynAlloc *> Alloc = Info.lookupDynamicAlloc(DA))
       Info.Note((*Alloc)->AllocExpr->getExprLoc(),
                 diag::note_constexpr_dynamic_alloc_here);
   }
@@ -2108,11 +2070,11 @@
 /// Materialized temporaries that we've already checked to determine if they're
 /// initializsed by a constant expression.
 using CheckedTemporaries =
-    llvm::SmallPtrSet<const MaterializeTemporaryExpr *, 8>;
+    llvm::SmallPtrSet<MaterializeTemporaryExpr const *, 8>;
 
 static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
                                   EvalInfo &Info, SourceLocation DiagLoc,
-                                  QualType Type, const APValue &Value,
+                                  QualType Type, APValue const &Value,
                                   ConstantExprKind Kind,
                                   SourceLocation SubobjectLoc,
                                   CheckedTemporaries &CheckedTemps);
@@ -2121,16 +2083,16 @@
 /// value for an address or reference constant expression. Return true if we
 /// can fold this expression, whether or not it's a constant expression.
 static bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc,
-                                          QualType Type, const LValue &LVal,
+                                          QualType Type, LValue const &LVal,
                                           ConstantExprKind Kind,
                                           CheckedTemporaries &CheckedTemps) {
   bool IsReferenceType = Type->isReferenceType();
 
   APValue::LValueBase Base = LVal.getLValueBase();
-  const SubobjectDesignator &Designator = LVal.getLValueDesignator();
+  SubobjectDesignator const &Designator = LVal.getLValueDesignator();
 
-  const Expr *BaseE = Base.dyn_cast<const Expr *>();
-  const ValueDecl *BaseVD = Base.dyn_cast<const ValueDecl*>();
+  Expr const *BaseE = Base.dyn_cast<Expr const *>();
+  ValueDecl const *BaseVD = Base.dyn_cast<ValueDecl const *>();
 
   // Additional restrictions apply in a template argument. We only enforce the
   // C++20 restrictions here; additional syntactic and semantic restrictions
@@ -2172,10 +2134,9 @@
   // assumed to be global here.
   if (!IsGlobalLValue(Base)) {
     if (Info.getLangOpts().CPlusPlus11) {
-      const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>();
+      ValueDecl const *VD = Base.dyn_cast<ValueDecl const *>();
       Info.FFDiag(Loc, diag::note_constexpr_non_global, 1)
-        << IsReferenceType << !Designator.Entries.empty()
-        << !!VD << VD;
+          << IsReferenceType << !Designator.Entries.empty() << !!VD << VD;
 
       auto *VarD = dyn_cast_or_null<VarDecl>(VD);
       if (VarD && VarD->isConstexpr()) {
@@ -2208,7 +2169,7 @@
   }
 
   if (BaseVD) {
-    if (const VarDecl *Var = dyn_cast<const VarDecl>(BaseVD)) {
+    if (VarDecl const *Var = dyn_cast<const VarDecl>(BaseVD)) {
       // Check if this is a thread-local variable.
       if (Var->getTLSKind())
         // FIXME: Diagnostic!
@@ -2220,7 +2181,7 @@
         // FIXME: Diagnostic!
         return false;
     }
-    if (const auto *FD = dyn_cast<const FunctionDecl>(BaseVD)) {
+    if (auto const *FD = dyn_cast<const FunctionDecl>(BaseVD)) {
       // __declspec(dllimport) must be handled very carefully:
       // We must never initialize an expression with the thunk in C++.
       // Doing otherwise would allow the same id-expression to yield
@@ -2236,7 +2197,7 @@
         // FIXME: Diagnostic!
         return false;
     }
-  } else if (const auto *MTE =
+  } else if (auto const *MTE =
                  dyn_cast_or_null<MaterializeTemporaryExpr>(BaseE)) {
     if (CheckedTemps.insert(MTE).second) {
       QualType TempType = getType(Base);
@@ -2250,8 +2211,8 @@
       APValue *V = MTE->getOrCreateValue(false);
       assert(V && "evasluation result refers to uninitialised temporary");
       if (!CheckEvaluationResult(CheckEvaluationResultKind::ConstantExpression,
-                                 Info, MTE->getExprLoc(), TempType, *V,
-                                 Kind, SourceLocation(), CheckedTemps))
+                                 Info, MTE->getExprLoc(), TempType, *V, Kind,
+                                 SourceLocation(), CheckedTemps))
         return false;
     }
   }
@@ -2271,7 +2232,7 @@
   // Does this refer one past the end of some object?
   if (!Designator.Invalid && Designator.isOnePastTheEnd()) {
     Info.FFDiag(Loc, diag::note_constexpr_past_end, 1)
-      << !Designator.Entries.empty() << !!BaseVD << BaseVD;
+        << !Designator.Entries.empty() << !!BaseVD << BaseVD;
     NoteLValueLocation(Info, Base);
   }
 
@@ -2283,10 +2244,10 @@
 static bool CheckMemberPointerConstantExpression(EvalInfo &Info,
                                                  SourceLocation Loc,
                                                  QualType Type,
-                                                 const APValue &Value,
+                                                 APValue const &Value,
                                                  ConstantExprKind Kind) {
-  const ValueDecl *Member = Value.getMemberPointerDecl();
-  const auto *FD = dyn_cast_or_null<CXXMethodDecl>(Member);
+  ValueDecl const *Member = Value.getMemberPointerDecl();
+  auto const *FD = dyn_cast_or_null<CXXMethodDecl>(Member);
   if (!FD)
     return true;
   if (FD->isConsteval()) {
@@ -2300,8 +2261,8 @@
 
 /// Check that this core constant expression is of literal type, and if not,
 /// produce an appropriate diagnostic.
-static bool CheckLiteralType(EvalInfo &Info, const Expr *E,
-                             const LValue *This = nullptr) {
+static bool CheckLiteralType(EvalInfo &Info, Expr const *E,
+                             LValue const *This = nullptr) {
   if (!E->isPRValue() || E->getType()->isLiteralType(Info.Ctx))
     return true;
 
@@ -2323,8 +2284,7 @@
 
   // Prvalue constant expressions must be of literal types.
   if (Info.getLangOpts().CPlusPlus11)
-    Info.FFDiag(E, diag::note_constexpr_nonliteral)
-      << E->getType();
+    Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();
   else
     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
   return false;
@@ -2332,13 +2292,12 @@
 
 static bool CheckEvaluationResult(CheckEvaluationResultKind CERK,
                                   EvalInfo &Info, SourceLocation DiagLoc,
-                                  QualType Type, const APValue &Value,
+                                  QualType Type, APValue const &Value,
                                   ConstantExprKind Kind,
                                   SourceLocation SubobjectLoc,
                                   CheckedTemporaries &CheckedTemps) {
   if (!Value.hasValue()) {
-    Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized)
-      << true << Type;
+    Info.FFDiag(DiagLoc, diag::note_constexpr_uninitialized) << true << Type;
     if (SubobjectLoc.isValid())
       Info.Note(SubobjectLoc, diag::note_constexpr_subobject_declared_here);
     return false;
@@ -2346,7 +2305,7 @@
 
   // We allow _Atomic(T) to be initialized from anything that T can be
   // initialized from.
-  if (const AtomicType *AT = Type->getAs<AtomicType>())
+  if (AtomicType const *AT = Type->getAs<AtomicType>())
     Type = AT->getValueType();
 
   // Core issue 1454: For a literal constant expression of array or class type,
@@ -2374,9 +2333,9 @@
   }
   if (Value.isStruct()) {
     RecordDecl *RD = Type->castAs<RecordType>()->getDecl();
-    if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
+    if (CXXRecordDecl const *CD = dyn_cast<CXXRecordDecl>(RD)) {
       unsigned BaseIndex = 0;
-      for (const CXXBaseSpecifier &BS : CD->bases()) {
+      for (CXXBaseSpecifier const &BS : CD->bases()) {
         if (!CheckEvaluationResult(CERK, Info, DiagLoc, BS.getType(),
                                    Value.getStructBase(BaseIndex), Kind,
                                    BS.getBeginLoc(), CheckedTemps))
@@ -2384,13 +2343,13 @@
         ++BaseIndex;
       }
     }
-    for (const auto *I : RD->fields()) {
+    for (auto const *I : RD->fields()) {
       if (I->isUnnamedBitfield())
         continue;
 
       if (!CheckEvaluationResult(CERK, Info, DiagLoc, I->getType(),
-                                 Value.getStructField(I->getFieldIndex()),
-                                 Kind, I->getLocation(), CheckedTemps))
+                                 Value.getStructField(I->getFieldIndex()), Kind,
+                                 I->getLocation(), CheckedTemps))
         return false;
     }
   }
@@ -2405,7 +2364,8 @@
 
   if (Value.isMemberPointer() &&
       CERK == CheckEvaluationResultKind::ConstantExpression)
-    return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value, Kind);
+    return CheckMemberPointerConstantExpression(Info, DiagLoc, Type, Value,
+                                                Kind);
 
   // Everything else is fine.
   return true;
@@ -2415,7 +2375,7 @@
 /// constant expression. If not, report an appropriate diagnostic. Does not
 /// check that the expression is of literal type.
 static bool CheckConstantExpression(EvalInfo &Info, SourceLocation DiagLoc,
-                                    QualType Type, const APValue &Value,
+                                    QualType Type, APValue const &Value,
                                     ConstantExprKind Kind) {
   // Nothing to check for a constant expression of type 'cv void'.
   if (Type->isVoidType())
@@ -2430,7 +2390,7 @@
 /// Check that this evaluated value is fully-initialized and can be loaded by
 /// an lvalue-to-rvalue conversion.
 static bool CheckFullyInitialized(EvalInfo &Info, SourceLocation DiagLoc,
-                                  QualType Type, const APValue &Value) {
+                                  QualType Type, APValue const &Value) {
   CheckedTemporaries CheckedTemps;
   return CheckEvaluationResult(
       CheckEvaluationResultKind::FullyInitialized, Info, DiagLoc, Type, Value,
@@ -2451,7 +2411,7 @@
   return true;
 }
 
-static bool EvalPointerValueAsBool(const APValue &Value, bool &Result) {
+static bool EvalPointerValueAsBool(APValue const &Value, bool &Result) {
   // A null base expression indicates a null pointer.  These are always
   // evaluatable, and they are false unless the offset is zero.
   if (!Value.getLValueBase()) {
@@ -2462,11 +2422,11 @@
   // We have a non-null base.  These are generally known to be true, but if it's
   // a weak declaration it can be null at runtime.
   Result = true;
-  const ValueDecl *Decl = Value.getLValueBase().dyn_cast<const ValueDecl*>();
+  ValueDecl const *Decl = Value.getLValueBase().dyn_cast<ValueDecl const *>();
   return !Decl || !Decl->isWeak();
 }
 
-static bool HandleConversionToBool(const APValue &Val, bool &Result) {
+static bool HandleConversionToBool(APValue const &Val, bool &Result) {
   switch (Val.getKind()) {
   case APValue::None:
   case APValue::Indeterminate:
@@ -2504,7 +2464,7 @@
   llvm_unreachable("unknown APValue kind");
 }
 
-static bool EvaluateAsBooleanCondition(const Expr *E, bool &Result,
+static bool EvaluateAsBooleanCondition(Expr const *E, bool &Result,
                                        EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && "missing lvalue-to-rvalue conv in bool condition");
@@ -2514,16 +2474,15 @@
   return HandleConversionToBool(Val, Result);
 }
 
-template<typename T>
-static bool HandleOverflow(EvalInfo &Info, const Expr *E,
-                           const T &SrcValue, QualType DestType) {
-  Info.CCEDiag(E, diag::note_constexpr_overflow)
-    << SrcValue << DestType;
+template <typename T>
+static bool HandleOverflow(EvalInfo &Info, Expr const *E, const T &SrcValue,
+                           QualType DestType) {
+  Info.CCEDiag(E, diag::note_constexpr_overflow) << SrcValue << DestType;
   return Info.noteUndefinedBehavior();
 }
 
-static bool HandleFloatToIntCast(EvalInfo &Info, const Expr *E,
-                                 QualType SrcType, const APFloat &Value,
+static bool HandleFloatToIntCast(EvalInfo &Info, Expr const *E,
+                                 QualType SrcType, APFloat const &Value,
                                  QualType DestType, APSInt &Result) {
   unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
   // Determine whether we are converting to unsigned or signed.
@@ -2531,8 +2490,8 @@
 
   Result = APSInt(DestWidth, !DestSigned);
   bool ignored;
-  if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored)
-      & APFloat::opInvalidOp)
+  if (Value.convertToInteger(Result, llvm::APFloat::rmTowardZero, &ignored) &
+      APFloat::opInvalidOp)
     return HandleOverflow(Info, E, Value, DestType);
   return true;
 }
@@ -2543,7 +2502,7 @@
 /// If rounding mode is unknown at compile time, still try to evaluate the
 /// expression. If the result is exact, it does not depend on rounding mode.
 /// So return "tonearest" mode instead of "dynamic".
-static llvm::RoundingMode getActiveRoundingMode(EvalInfo &Info, const Expr *E,
+static llvm::RoundingMode getActiveRoundingMode(EvalInfo &Info, Expr const *E,
                                                 bool &DynamicRM) {
   llvm::RoundingMode RM =
       E->getFPFeaturesInEffect(Info.Ctx.getLangOpts()).getRoundingMode();
@@ -2554,7 +2513,7 @@
 }
 
 /// Check if the given evaluation result is allowed for constant evaluation.
-static bool checkFloatingPointResult(EvalInfo &Info, const Expr *E,
+static bool checkFloatingPointResult(EvalInfo &Info, Expr const *E,
                                      APFloat::opStatus St) {
   // In a constant context, assume that any dynamic rounding mode or FP
   // exception state matches the default floating-point environment.
@@ -2594,7 +2553,7 @@
   return true;
 }
 
-static bool HandleFloatToFloatCast(EvalInfo &Info, const Expr *E,
+static bool HandleFloatToFloatCast(EvalInfo &Info, Expr const *E,
                                    QualType SrcType, QualType DestType,
                                    APFloat &Result) {
   assert(isa<CastExpr>(E) || isa<CompoundAssignOperator>(E));
@@ -2607,9 +2566,9 @@
   return checkFloatingPointResult(Info, E, St);
 }
 
-static APSInt HandleIntToIntCast(EvalInfo &Info, const Expr *E,
+static APSInt HandleIntToIntCast(EvalInfo &Info, Expr const *E,
                                  QualType DestType, QualType SrcType,
-                                 const APSInt &Value) {
+                                 APSInt const &Value) {
   unsigned DestWidth = Info.Ctx.getIntWidth(DestType);
   // Figure out if this is a truncate, extend or noop cast.
   // If the input is signed, do a sign extend, noop, or truncate.
@@ -2620,13 +2579,13 @@
   return Result;
 }
 
-static bool HandleIntToFloatCast(EvalInfo &Info, const Expr *E,
-                                 const FPOptions FPO,
-                                 QualType SrcType, const APSInt &Value,
-                                 QualType DestType, APFloat &Result) {
+static bool HandleIntToFloatCast(EvalInfo &Info, Expr const *E,
+                                 const FPOptions FPO, QualType SrcType,
+                                 APSInt const &Value, QualType DestType,
+                                 APFloat &Result) {
   Result = APFloat(Info.Ctx.getFloatTypeSemantics(DestType), 1);
   APFloat::opStatus St = Result.convertFromAPInt(Value, Value.isSigned(),
-       APFloat::rmNearestTiesToEven);
+                                                 APFloat::rmNearestTiesToEven);
   if (!Info.InConstantContext && St != llvm::APFloatBase::opOK &&
       FPO.isFPConstrained()) {
     Info.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
@@ -2635,8 +2594,8 @@
   return true;
 }
 
-static bool truncateBitfieldValue(EvalInfo &Info, const Expr *E,
-                                  APValue &Value, const FieldDecl *FD) {
+static bool truncateBitfieldValue(EvalInfo &Info, Expr const *E, APValue &Value,
+                                  FieldDecl const *FD) {
   assert(FD->isBitField() && "truncateBitfieldValue on non-bitfield");
 
   if (!Value.isInt()) {
@@ -2656,7 +2615,7 @@
   return true;
 }
 
-static bool EvalAndBitcastToAPInt(EvalInfo &Info, const Expr *E,
+static bool EvalAndBitcastToAPInt(EvalInfo &Info, Expr const *E,
                                   llvm::APInt &Res) {
   APValue SVal;
   if (!Evaluate(SVal, Info, E))
@@ -2691,9 +2650,9 @@
       }
       unsigned BaseEltSize = EltAsInt.getBitWidth();
       if (BigEndian)
-        Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i*EltSize+BaseEltSize);
+        Res |= EltAsInt.zextOrTrunc(VecSize).rotr(i * EltSize + BaseEltSize);
       else
-        Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i*EltSize);
+        Res |= EltAsInt.zextOrTrunc(VecSize).rotl(i * EltSize);
     }
     return true;
   }
@@ -2706,9 +2665,9 @@
 /// Perform the given integer operation, which is known to need at most BitWidth
 /// bits, and check for overflow in the original type (if that type was not an
 /// unsigned type).
-template<typename Operation>
-static bool CheckedIntArithmetic(EvalInfo &Info, const Expr *E,
-                                 const APSInt &LHS, const APSInt &RHS,
+template <typename Operation>
+static bool CheckedIntArithmetic(EvalInfo &Info, Expr const *E,
+                                 APSInt const &LHS, APSInt const &RHS,
                                  unsigned BitWidth, Operation Op,
                                  APSInt &Result) {
   if (LHS.isUnsigned()) {
@@ -2729,7 +2688,7 @@
 }
 
 /// Perform the given binary integer operation.
-static bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS,
+static bool handleIntIntBinOp(EvalInfo &Info, Expr const *E, APSInt const &LHS,
                               BinaryOperatorKind Opcode, APSInt RHS,
                               APSInt &Result) {
   switch (Opcode) {
@@ -2745,9 +2704,15 @@
   case BO_Sub:
     return CheckedIntArithmetic(Info, E, LHS, RHS, LHS.getBitWidth() + 1,
                                 std::minus<APSInt>(), Result);
-  case BO_And: Result = LHS & RHS; return true;
-  case BO_Xor: Result = LHS ^ RHS; return true;
-  case BO_Or:  Result = LHS | RHS; return true;
+  case BO_And:
+    Result = LHS & RHS;
+    return true;
+  case BO_Xor:
+    Result = LHS ^ RHS;
+    return true;
+  case BO_Or:
+    Result = LHS | RHS;
+    return true;
   case BO_Div:
   case BO_Rem:
     if (RHS == 0) {
@@ -2757,8 +2722,8 @@
     Result = (Opcode == BO_Rem ? LHS % RHS : LHS / RHS);
     // Check for overflow case: INT_MIN / -1 or INT_MIN % -1. APSInt supports
     // this operation and gives the two's complement result.
-    if (RHS.isNegative() && RHS.isAllOnesValue() &&
-        LHS.isSigned() && LHS.isMinSignedValue())
+    if (RHS.isNegative() && RHS.isAllOnesValue() && LHS.isSigned() &&
+        LHS.isMinSignedValue())
       return HandleOverflow(Info, E, -LHS.extend(LHS.getBitWidth() + 1),
                             E->getType());
     return true;
@@ -2766,7 +2731,7 @@
     if (Info.getLangOpts().OpenCL)
       // OpenCL 6.3j: shift values are effectively % word size of LHS.
       RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
-                    static_cast<uint64_t>(LHS.getBitWidth() - 1)),
+                                static_cast<uint64_t>(LHS.getBitWidth() - 1)),
                     RHS.isUnsigned());
     else if (RHS.isSigned() && RHS.isNegative()) {
       // During constant-folding, a negative shift is an opposite shift. Such
@@ -2778,10 +2743,10 @@
   shift_left:
     // C++11 [expr.shift]p1: Shift width must be less than the bit width of
     // the shifted type.
-    unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
+    unsigned SA = (unsigned)RHS.getLimitedValue(LHS.getBitWidth() - 1);
     if (SA != RHS) {
       Info.CCEDiag(E, diag::note_constexpr_large_shift)
-        << RHS << E->getType() << LHS.getBitWidth();
+          << RHS << E->getType() << LHS.getBitWidth();
     } else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus20) {
       // C++11 [expr.shift]p2: A signed left shift must have a non-negative
       // operand, and must not overflow the corresponding unsigned type.
@@ -2799,7 +2764,7 @@
     if (Info.getLangOpts().OpenCL)
       // OpenCL 6.3j: shift values are effectively % word size of LHS.
       RHS &= APSInt(llvm::APInt(RHS.getBitWidth(),
-                    static_cast<uint64_t>(LHS.getBitWidth() - 1)),
+                                static_cast<uint64_t>(LHS.getBitWidth() - 1)),
                     RHS.isUnsigned());
     else if (RHS.isSigned() && RHS.isNegative()) {
       // During constant-folding, a negative shift is an opposite shift. Such a
@@ -2811,29 +2776,41 @@
   shift_right:
     // C++11 [expr.shift]p1: Shift width must be less than the bit width of the
     // shifted type.
-    unsigned SA = (unsigned) RHS.getLimitedValue(LHS.getBitWidth()-1);
+    unsigned SA = (unsigned)RHS.getLimitedValue(LHS.getBitWidth() - 1);
     if (SA != RHS)
       Info.CCEDiag(E, diag::note_constexpr_large_shift)
-        << RHS << E->getType() << LHS.getBitWidth();
+          << RHS << E->getType() << LHS.getBitWidth();
     Result = LHS >> SA;
     return true;
   }
 
-  case BO_LT: Result = LHS < RHS; return true;
-  case BO_GT: Result = LHS > RHS; return true;
-  case BO_LE: Result = LHS <= RHS; return true;
-  case BO_GE: Result = LHS >= RHS; return true;
-  case BO_EQ: Result = LHS == RHS; return true;
-  case BO_NE: Result = LHS != RHS; return true;
+  case BO_LT:
+    Result = LHS < RHS;
+    return true;
+  case BO_GT:
+    Result = LHS > RHS;
+    return true;
+  case BO_LE:
+    Result = LHS <= RHS;
+    return true;
+  case BO_GE:
+    Result = LHS >= RHS;
+    return true;
+  case BO_EQ:
+    Result = LHS == RHS;
+    return true;
+  case BO_NE:
+    Result = LHS != RHS;
+    return true;
   case BO_Cmp:
     llvm_unreachable("BO_Cmp should be handled elsewhere");
   }
 }
 
 /// Perform the given binary floating-point operation, in-place, on LHS.
-static bool handleFloatFloatBinOp(EvalInfo &Info, const BinaryOperator *E,
+static bool handleFloatFloatBinOp(EvalInfo &Info, BinaryOperator const *E,
                                   APFloat &LHS, BinaryOperatorKind Opcode,
-                                  const APFloat &RHS) {
+                                  APFloat const &RHS) {
   bool DynamicRM;
   llvm::RoundingMode RM = getActiveRoundingMode(Info, E, DynamicRM);
   APFloat::opStatus St;
@@ -2871,9 +2848,9 @@
   return checkFloatingPointResult(Info, E, St);
 }
 
-static bool handleLogicalOpForVector(const APInt &LHSValue,
+static bool handleLogicalOpForVector(APInt const &LHSValue,
                                      BinaryOperatorKind Opcode,
-                                     const APInt &RHSValue, APInt &Result) {
+                                     APInt const &RHSValue, APInt &Result) {
   bool LHS = (LHSValue != 0);
   bool RHS = (RHSValue != 0);
 
@@ -2883,9 +2860,9 @@
     Result = LHS || RHS;
   return true;
 }
-static bool handleLogicalOpForVector(const APFloat &LHSValue,
+static bool handleLogicalOpForVector(APFloat const &LHSValue,
                                      BinaryOperatorKind Opcode,
-                                     const APFloat &RHSValue, APInt &Result) {
+                                     APFloat const &RHSValue, APInt &Result) {
   bool LHS = !LHSValue.isZero();
   bool RHS = !RHSValue.isZero();
 
@@ -2896,9 +2873,9 @@
   return true;
 }
 
-static bool handleLogicalOpForVector(const APValue &LHSValue,
+static bool handleLogicalOpForVector(APValue const &LHSValue,
                                      BinaryOperatorKind Opcode,
-                                     const APValue &RHSValue, APInt &Result) {
+                                     APValue const &RHSValue, APInt &Result) {
   // The result is always an int type, however operands match the first.
   if (LHSValue.getKind() == APValue::Int)
     return handleLogicalOpForVector(LHSValue.getInt(), Opcode,
@@ -2910,8 +2887,8 @@
 
 template <typename APTy>
 static bool
-handleCompareOpForVectorHelper(const APTy &LHSValue, BinaryOperatorKind Opcode,
-                               const APTy &RHSValue, APInt &Result) {
+handleCompareOpForVectorHelper(APTy const &LHSValue, BinaryOperatorKind Opcode,
+                               APTy const &RHSValue, APInt &Result) {
   switch (Opcode) {
   default:
     llvm_unreachable("unsupported binary operator");
@@ -2938,9 +2915,9 @@
   return true;
 }
 
-static bool handleCompareOpForVector(const APValue &LHSValue,
+static bool handleCompareOpForVector(APValue const &LHSValue,
                                      BinaryOperatorKind Opcode,
-                                     const APValue &RHSValue, APInt &Result) {
+                                     APValue const &RHSValue, APInt &Result) {
   // The result is always an int type, however operands match the first.
   if (LHSValue.getKind() == APValue::Int)
     return handleCompareOpForVectorHelper(LHSValue.getInt(), Opcode,
@@ -2951,14 +2928,14 @@
 }
 
 // Perform binary operations for vector types, in place on the LHS.
-static bool handleVectorVectorBinOp(EvalInfo &Info, const BinaryOperator *E,
+static bool handleVectorVectorBinOp(EvalInfo &Info, BinaryOperator const *E,
                                     BinaryOperatorKind Opcode,
                                     APValue &LHSValue,
-                                    const APValue &RHSValue) {
+                                    APValue const &RHSValue) {
   assert(Opcode != BO_PtrMemD && Opcode != BO_PtrMemI &&
          "Operation not supported on vector types");
 
-  const auto *VT = E->getType()->castAs<VectorType>();
+  auto const *VT = E->getType()->castAs<VectorType>();
   unsigned NumElements = VT->getNumElements();
   QualType EltTy = VT->getElementType();
 
@@ -3022,8 +2999,8 @@
 
 /// Cast an lvalue referring to a base subobject to a derived class, by
 /// truncating the lvalue's path to the given length.
-static bool CastToDerivedClass(EvalInfo &Info, const Expr *E, LValue &Result,
-                               const RecordDecl *TruncatedType,
+static bool CastToDerivedClass(EvalInfo &Info, Expr const *E, LValue &Result,
+                               RecordDecl const *TruncatedType,
                                unsigned TruncatedElements) {
   SubobjectDesignator &D = Result.Designator;
 
@@ -3036,11 +3013,12 @@
     return false;
 
   // Truncate the path to the subobject, and remove any derived-to-base offsets.
-  const RecordDecl *RD = TruncatedType;
+  RecordDecl const *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 (RD->isInvalidDecl())
+      return false;
+    ASTRecordLayout const &Layout = Info.Ctx.getASTRecordLayout(RD);
+    CXXRecordDecl const *Base = getAsBaseClass(D.Entries[I]);
     if (isVirtualBaseClass(D.Entries[I]))
       Result.Offset -= Layout.getVBaseClassOffset(Base);
     else
@@ -3051,12 +3029,13 @@
   return true;
 }
 
-static bool HandleLValueDirectBase(EvalInfo &Info, const Expr *E, LValue &Obj,
-                                   const CXXRecordDecl *Derived,
-                                   const CXXRecordDecl *Base,
-                                   const ASTRecordLayout *RL = nullptr) {
+static bool HandleLValueDirectBase(EvalInfo &Info, Expr const *E, LValue &Obj,
+                                   CXXRecordDecl const *Derived,
+                                   CXXRecordDecl const *Base,
+                                   ASTRecordLayout const *RL = nullptr) {
   if (!RL) {
-    if (Derived->isInvalidDecl()) return false;
+    if (Derived->isInvalidDecl())
+      return false;
     RL = &Info.Ctx.getASTRecordLayout(Derived);
   }
 
@@ -3065,10 +3044,10 @@
   return true;
 }
 
-static bool HandleLValueBase(EvalInfo &Info, const Expr *E, LValue &Obj,
-                             const CXXRecordDecl *DerivedDecl,
-                             const CXXBaseSpecifier *Base) {
-  const CXXRecordDecl *BaseDecl = Base->getType()->getAsCXXRecordDecl();
+static bool HandleLValueBase(EvalInfo &Info, Expr const *E, LValue &Obj,
+                             CXXRecordDecl const *DerivedDecl,
+                             CXXBaseSpecifier const *Base) {
+  CXXRecordDecl const *BaseDecl = Base->getType()->getAsCXXRecordDecl();
 
   if (!Base->isVirtual())
     return HandleLValueDirectBase(Info, E, Obj, DerivedDecl, BaseDecl);
@@ -3083,20 +3062,20 @@
     return false;
 
   // Find the virtual base class.
-  if (DerivedDecl->isInvalidDecl()) return false;
-  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
+  if (DerivedDecl->isInvalidDecl())
+    return false;
+  ASTRecordLayout const &Layout = Info.Ctx.getASTRecordLayout(DerivedDecl);
   Obj.getLValueOffset() += Layout.getVBaseClassOffset(BaseDecl);
   Obj.addDecl(Info, E, BaseDecl, /*Virtual*/ true);
   return true;
 }
 
-static bool HandleLValueBasePath(EvalInfo &Info, const CastExpr *E,
+static bool HandleLValueBasePath(EvalInfo &Info, CastExpr const *E,
                                  QualType Type, LValue &Result) {
   for (CastExpr::path_const_iterator PathI = E->path_begin(),
                                      PathE = E->path_end();
        PathI != PathE; ++PathI) {
-    if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(),
-                          *PathI))
+    if (!HandleLValueBase(Info, E, Result, Type->getAsCXXRecordDecl(), *PathI))
       return false;
     Type = (*PathI)->getType();
   }
@@ -3104,9 +3083,9 @@
 }
 
 /// Cast an lvalue referring to a derived class to a known base subobject.
-static bool CastToBaseClass(EvalInfo &Info, const Expr *E, LValue &Result,
-                            const CXXRecordDecl *DerivedRD,
-                            const CXXRecordDecl *BaseRD) {
+static bool CastToBaseClass(EvalInfo &Info, Expr const *E, LValue &Result,
+                            CXXRecordDecl const *DerivedRD,
+                            CXXRecordDecl const *BaseRD) {
   CXXBasePaths Paths(/*FindAmbiguities=*/false,
                      /*RecordPaths=*/true, /*DetectVirtual=*/false);
   if (!DerivedRD->isDerivedFrom(BaseRD, Paths))
@@ -3120,11 +3099,12 @@
 
 /// Update LVal to refer to the given field, which must be a member of the type
 /// currently described by LVal.
-static bool HandleLValueMember(EvalInfo &Info, const Expr *E, LValue &LVal,
-                               const FieldDecl *FD,
-                               const ASTRecordLayout *RL = nullptr) {
+static bool HandleLValueMember(EvalInfo &Info, Expr const *E, LValue &LVal,
+                               FieldDecl const *FD,
+                               ASTRecordLayout const *RL = nullptr) {
   if (!RL) {
-    if (FD->getParent()->isInvalidDecl()) return false;
+    if (FD->getParent()->isInvalidDecl())
+      return false;
     RL = &Info.Ctx.getASTRecordLayout(FD->getParent());
   }
 
@@ -3135,18 +3115,18 @@
 }
 
 /// Update LVal to refer to the given indirect field.
-static bool HandleLValueIndirectMember(EvalInfo &Info, const Expr *E,
+static bool HandleLValueIndirectMember(EvalInfo &Info, Expr const *E,
                                        LValue &LVal,
-                                       const IndirectFieldDecl *IFD) {
-  for (const auto *C : IFD->chain())
+                                       IndirectFieldDecl const *IFD) {
+  for (auto const *C : IFD->chain())
     if (!HandleLValueMember(Info, E, LVal, cast<FieldDecl>(C)))
       return false;
   return true;
 }
 
 /// Get the size of the given type in char units.
-static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc,
-                         QualType Type, CharUnits &Size) {
+static bool HandleSizeof(EvalInfo &Info, SourceLocation Loc, QualType Type,
+                         CharUnits &Size) {
   // sizeof(void), __alignof__(void), sizeof(function) = 1 as a gcc
   // extension.
   if (Type->isVoidType() || Type->isFunctionType()) {
@@ -3176,7 +3156,7 @@
 /// \param LVal - The pointer value to be updated.
 /// \param EltTy - The pointee type represented by LVal.
 /// \param Adjustment - The adjustment, in objects of type EltTy, to add.
-static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
+static bool HandleLValueArrayAdjustment(EvalInfo &Info, Expr const *E,
                                         LValue &LVal, QualType EltTy,
                                         APSInt Adjustment) {
   CharUnits SizeOfPointee;
@@ -3187,7 +3167,7 @@
   return true;
 }
 
-static bool HandleLValueArrayAdjustment(EvalInfo &Info, const Expr *E,
+static bool HandleLValueArrayAdjustment(EvalInfo &Info, Expr const *E,
                                         LValue &LVal, QualType EltTy,
                                         int64_t Adjustment) {
   return HandleLValueArrayAdjustment(Info, E, LVal, EltTy,
@@ -3199,7 +3179,7 @@
 /// \param LVal - The lvalue to be updated.
 /// \param EltTy - The complex number's component type.
 /// \param Imag - False for the real component, true for the imaginary.
-static bool HandleLValueComplexElement(EvalInfo &Info, const Expr *E,
+static bool HandleLValueComplexElement(EvalInfo &Info, Expr const *E,
                                        LValue &LVal, QualType EltTy,
                                        bool Imag) {
   if (Imag) {
@@ -3221,8 +3201,8 @@
 /// \param Frame  The frame in which the variable was created. Must be null
 ///               if this variable is not local to the evaluation.
 /// \param Result Filled in with a pointer to the value of the variable.
-static bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E,
-                                const VarDecl *VD, CallStackFrame *Frame,
+static bool evaluateVarDeclInit(EvalInfo &Info, Expr const *E,
+                                VarDecl const *VD, CallStackFrame *Frame,
                                 unsigned Version, APValue *&Result) {
   APValue::LValueBase Base(VD, Frame ? Frame->Index : 0, Version);
 
@@ -3265,8 +3245,7 @@
         !Info.CurrentCall->Callee ||
         !Info.CurrentCall->Callee->Equals(VD->getDeclContext())) {
       if (Info.getLangOpts().CPlusPlus11) {
-        Info.FFDiag(E, diag::note_constexpr_function_param_value_unknown)
-            << VD;
+        Info.FFDiag(E, diag::note_constexpr_function_param_value_unknown) << VD;
         NoteLValueLocation(Info, Base);
       } else {
         Info.FFDiag(E);
@@ -3278,13 +3257,12 @@
   // Dig out the initializer, and use the declaration which it's attached to.
   // FIXME: We should eventually check whether the variable has a reachable
   // initializing declaration.
-  const Expr *Init = VD->getAnyInitializer(VD);
+  Expr const *Init = VD->getAnyInitializer(VD);
   if (!Init) {
     // Don't diagnose during potential constant expression checking; an
     // initializer might be added later.
     if (!Info.checkingPotentialConstantExpression()) {
-      Info.FFDiag(E, diag::note_constexpr_var_init_unknown, 1)
-        << VD;
+      Info.FFDiag(E, diag::note_constexpr_var_init_unknown, 1) << VD;
       NoteLValueLocation(Info, Base);
     }
     return false;
@@ -3298,9 +3276,11 @@
     // have been value-dependent too), so diagnose that.
     assert(!VD->mightBeUsableInConstantExpressions(Info.Ctx));
     if (!Info.checkingPotentialConstantExpression()) {
-      Info.FFDiag(E, Info.getLangOpts().CPlusPlus11
-                         ? diag::note_constexpr_ltor_non_constexpr
-                         : diag::note_constexpr_ltor_non_integral, 1)
+      Info.FFDiag(E,
+                  Info.getLangOpts().CPlusPlus11
+                      ? diag::note_constexpr_ltor_non_constexpr
+                      : diag::note_constexpr_ltor_non_integral,
+                  1)
           << VD << VD->getType();
       NoteLValueLocation(Info, Base);
     }
@@ -3346,12 +3326,13 @@
 
 /// Get the base index of the given base class within an APValue representing
 /// the given derived class.
-static unsigned getBaseIndex(const CXXRecordDecl *Derived,
-                             const CXXRecordDecl *Base) {
+static unsigned getBaseIndex(CXXRecordDecl const *Derived,
+                             CXXRecordDecl const *Base) {
   Base = Base->getCanonicalDecl();
   unsigned Index = 0;
   for (CXXRecordDecl::base_class_const_iterator I = Derived->bases_begin(),
-         E = Derived->bases_end(); I != E; ++I, ++Index) {
+                                                E = Derived->bases_end();
+       I != E; ++I, ++Index) {
     if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == Base)
       return Index;
   }
@@ -3360,13 +3341,13 @@
 }
 
 /// Extract the value of a character from a string literal.
-static APSInt extractStringLiteralCharacter(EvalInfo &Info, const Expr *Lit,
+static APSInt extractStringLiteralCharacter(EvalInfo &Info, Expr const *Lit,
                                             uint64_t Index) {
   assert(!isa<SourceLocExpr>(Lit) &&
          "SourceLocExpr should have already been converted to a StringLiteral");
 
   // FIXME: Support MakeStringConstant
-  if (const auto *ObjCEnc = dyn_cast<ObjCEncodeExpr>(Lit)) {
+  if (auto const *ObjCEnc = dyn_cast<ObjCEncodeExpr>(Lit)) {
     std::string Str;
     Info.Ctx.getObjCEncodingForType(ObjCEnc->getEncodedType(), Str);
     assert(Index <= Str.size() && "Index too large");
@@ -3375,9 +3356,8 @@
 
   if (auto PE = dyn_cast<PredefinedExpr>(Lit))
     Lit = PE->getFunctionName();
-  const StringLiteral *S = cast<StringLiteral>(Lit);
-  const ConstantArrayType *CAT =
-      Info.Ctx.getAsConstantArrayType(S->getType());
+  StringLiteral const *S = cast<StringLiteral>(Lit);
+  ConstantArrayType const *CAT = Info.Ctx.getAsConstantArrayType(S->getType());
   assert(CAT && "string literal isn't an array");
   QualType CharType = CAT->getElementType();
   assert(CharType->isIntegerType() && "unexpected character type");
@@ -3393,18 +3373,18 @@
 //
 // FIXME: This is inefficient; we should probably introduce something similar
 // to the LLVM ConstantDataArray to make this cheaper.
-static void expandStringLiteral(EvalInfo &Info, const StringLiteral *S,
+static void expandStringLiteral(EvalInfo &Info, StringLiteral const *S,
                                 APValue &Result,
                                 QualType AllocType = QualType()) {
-  const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(
+  ConstantArrayType const *CAT = Info.Ctx.getAsConstantArrayType(
       AllocType.isNull() ? S->getType() : AllocType);
   assert(CAT && "string literal isn't an array");
   QualType CharType = CAT->getElementType();
   assert(CharType->isIntegerType() && "unexpected character type");
 
   unsigned Elts = CAT->getSize().getZExtValue();
-  Result = APValue(APValue::UninitArray(),
-                   std::min(S->getLength(), Elts), Elts);
+  Result =
+      APValue(APValue::UninitArray(), std::min(S->getLength(), Elts), Elts);
   APSInt Value(S->getCharByteWidth() * Info.Ctx.getCharWidth(),
                CharType->isUnsignedIntegerType());
   if (Result.hasArrayFiller())
@@ -3422,7 +3402,7 @@
 
   // Always at least double the number of elements for which we store a value.
   unsigned OldElts = Array.getArrayInitializedElts();
-  unsigned NewElts = std::max(Index+1, OldElts * 2);
+  unsigned NewElts = std::max(Index + 1, OldElts * 2);
   NewElts = std::min(Size, std::max(NewElts, 8u));
 
   // Copy the data across.
@@ -3441,12 +3421,12 @@
 /// is trivial. Note that this is never true for a union type with fields
 /// (because the copy always "reads" the active member) and always true for
 /// a non-class type.
-static bool isReadByLvalueToRvalueConversion(const CXXRecordDecl *RD);
+static bool isReadByLvalueToRvalueConversion(CXXRecordDecl const *RD);
 static bool isReadByLvalueToRvalueConversion(QualType T) {
   CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
   return !RD || isReadByLvalueToRvalueConversion(RD);
 }
-static bool isReadByLvalueToRvalueConversion(const CXXRecordDecl *RD) {
+static bool isReadByLvalueToRvalueConversion(CXXRecordDecl const *RD) {
   // FIXME: A trivial copy of a union copies the object representation, even if
   // the union is empty.
   if (RD->isUnion())
@@ -3468,7 +3448,7 @@
 
 /// Diagnose an attempt to read from any unreadable field within the specified
 /// type, which might be a class type.
-static bool diagnoseMutableFields(EvalInfo &Info, const Expr *E, AccessKinds AK,
+static bool diagnoseMutableFields(EvalInfo &Info, Expr const *E, AccessKinds AK,
                                   QualType T) {
   CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
   if (!RD)
@@ -3519,7 +3499,7 @@
 
     // A temporary lifetime-extended by the variable whose initializer we're
     // evaluating.
-    if (auto *BaseE = Base.dyn_cast<const Expr *>())
+    if (auto *BaseE = Base.dyn_cast<Expr const *>())
       if (auto *BaseMTE = dyn_cast<MaterializeTemporaryExpr>(BaseE))
         return Info.EvaluatingDecl == BaseMTE->getExtendingDecl();
     return false;
@@ -3569,7 +3549,7 @@
     // FIXME: Should we also allow this in C++11?
     if (!Info.getLangOpts().CPlusPlus14)
       return false;
-    return lifetimeStartedInEvaluation(Info, Base, /*MutableSubobject*/true);
+    return lifetimeStartedInEvaluation(Info, Base, /*MutableSubobject*/ true);
   }
 
   explicit operator bool() const { return !Type.isNull(); }
@@ -3591,10 +3571,10 @@
 }
 
 /// Find the designated sub-object of an rvalue.
-template<typename SubobjectHandler>
+template <typename SubobjectHandler>
 typename SubobjectHandler::result_type
-findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj,
-              const SubobjectDesignator &Sub, SubobjectHandler &handler) {
+findSubobject(EvalInfo &Info, Expr const *E, CompleteObject const &Obj,
+              SubobjectDesignator const &Sub, SubobjectHandler &handler) {
   if (Sub.Invalid)
     // A diagnostic will have already been produced.
     return handler.failed();
@@ -3611,12 +3591,13 @@
 
   APValue *O = Obj.Value;
   QualType ObjType = Obj.Type;
-  const FieldDecl *LastField = nullptr;
-  const FieldDecl *VolatileField = nullptr;
+  FieldDecl const *LastField = nullptr;
+  FieldDecl const *VolatileField = nullptr;
 
   // Walk the designator's path to find the subobject.
   for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {
-    // Reading an indeterminate value is undefined, but assigning over one is OK.
+    // Reading an indeterminate value is undefined, but assigning over one is
+    // OK.
     if ((O->isAbsent() && !(handler.AccessKind == AK_Construct && I == N)) ||
         (O->isIndeterminate() &&
          !isValidIndeterminateAccess(handler.AccessKind))) {
@@ -3632,9 +3613,9 @@
     if ((ObjType.isConstQualified() || ObjType.isVolatileQualified()) &&
         ObjType->isRecordType() &&
         Info.isEvaluatingCtorDtor(
-            Obj.Base, llvm::makeArrayRef(Sub.Entries.begin(),
-                                         Sub.Entries.begin() + I)) !=
-                          ConstructionPhase::None) {
+            Obj.Base,
+            llvm::makeArrayRef(Sub.Entries.begin(), Sub.Entries.begin() + I)) !=
+            ConstructionPhase::None) {
       ObjType = Info.Ctx.getCanonicalType(ObjType);
       ObjType.removeLocalConst();
       ObjType.removeLocalVolatile();
@@ -3647,18 +3628,18 @@
         if (Info.getLangOpts().CPlusPlus) {
           int DiagKind;
           SourceLocation Loc;
-          const NamedDecl *Decl = nullptr;
+          NamedDecl const *Decl = nullptr;
           if (VolatileField) {
             DiagKind = 2;
             Loc = VolatileField->getLocation();
             Decl = VolatileField;
-          } else if (auto *VD = Obj.Base.dyn_cast<const ValueDecl*>()) {
+          } else if (auto *VD = Obj.Base.dyn_cast<ValueDecl const *>()) {
             DiagKind = 1;
             Loc = VD->getLocation();
             Decl = VD;
           } else {
             DiagKind = 0;
-            if (auto *E = Obj.Base.dyn_cast<const Expr *>())
+            if (auto *E = Obj.Base.dyn_cast<Expr const *>())
               Loc = E->getExprLoc();
           }
           Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1)
@@ -3685,8 +3666,8 @@
         return false;
 
       // If we modified a bit-field, truncate it to the right width.
-      if (isModification(handler.AccessKind) &&
-          LastField && LastField->isBitField() &&
+      if (isModification(handler.AccessKind) && LastField &&
+          LastField->isBitField() &&
           !truncateBitfieldValue(Info, E, *O, LastField))
         return false;
 
@@ -3696,7 +3677,7 @@
     LastField = nullptr;
     if (ObjType->isArrayType()) {
       // Next subobject is an array element.
-      const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(ObjType);
+      ConstantArrayType const *CAT = Info.Ctx.getAsConstantArrayType(ObjType);
       assert(CAT && "vla in literal type?");
       uint64_t Index = Sub.Entries[I].getAsArrayIndex();
       if (CAT->getSize().ule(Index)) {
@@ -3704,7 +3685,7 @@
         // designator which points more than one past the end of the array.
         if (Info.getLangOpts().CPlusPlus11)
           Info.FFDiag(E, diag::note_constexpr_access_past_end)
-            << handler.AccessKind;
+              << handler.AccessKind;
         else
           Info.FFDiag(E);
         return handler.failed();
@@ -3725,7 +3706,7 @@
       if (Index > 1) {
         if (Info.getLangOpts().CPlusPlus11)
           Info.FFDiag(E, diag::note_constexpr_access_past_end)
-            << handler.AccessKind;
+              << handler.AccessKind;
         else
           Info.FFDiag(E);
         return handler.failed();
@@ -3736,18 +3717,19 @@
 
       assert(I == N - 1 && "extracting subobject of scalar?");
       if (O->isComplexInt()) {
-        return handler.found(Index ? O->getComplexIntImag()
-                                   : O->getComplexIntReal(), ObjType);
+        return handler.found(
+            Index ? O->getComplexIntImag() : O->getComplexIntReal(), ObjType);
       } else {
         assert(O->isComplexFloat());
         return handler.found(Index ? O->getComplexFloatImag()
-                                   : O->getComplexFloatReal(), ObjType);
+                                   : O->getComplexFloatReal(),
+                             ObjType);
       }
-    } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
+    } else if (FieldDecl const *Field = getAsField(Sub.Entries[I])) {
       if (Field->isMutable() &&
           !Obj.mayAccessMutableMembers(Info, handler.AccessKind)) {
         Info.FFDiag(E, diag::note_constexpr_access_mutable, 1)
-          << handler.AccessKind << Field;
+            << handler.AccessKind << Field;
         Info.Note(Field->getLocation(), diag::note_declared_at);
         return handler.failed();
       }
@@ -3755,7 +3737,7 @@
       // Next subobject is a class, struct or union field.
       RecordDecl *RD = ObjType->castAs<RecordType>()->getDecl();
       if (RD->isUnion()) {
-        const FieldDecl *UnionField = O->getUnionField();
+        FieldDecl const *UnionField = O->getUnionField();
         if (!UnionField ||
             UnionField->getCanonicalDecl() != Field->getCanonicalDecl()) {
           if (I == N - 1 && handler.AccessKind == AK_Construct) {
@@ -3781,8 +3763,8 @@
         VolatileField = Field;
     } else {
       // Next subobject is a base class.
-      const CXXRecordDecl *Derived = ObjType->getAsCXXRecordDecl();
-      const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]);
+      CXXRecordDecl const *Derived = ObjType->getAsCXXRecordDecl();
+      CXXRecordDecl const *Base = getAsBaseClass(Sub.Entries[I]);
       O = &O->getStructBase(getBaseIndex(Derived, Base));
 
       ObjType = getSubobjectType(ObjType, Info.Ctx.getRecordType(Base));
@@ -3793,7 +3775,7 @@
 namespace {
 struct ExtractSubobjectHandler {
   EvalInfo &Info;
-  const Expr *E;
+  Expr const *E;
   APValue &Result;
   const AccessKinds AccessKind;
 
@@ -3817,9 +3799,9 @@
 } // end anonymous namespace
 
 /// Extract the designated sub-object of an rvalue.
-static bool extractSubobject(EvalInfo &Info, const Expr *E,
-                             const CompleteObject &Obj,
-                             const SubobjectDesignator &Sub, APValue &Result,
+static bool extractSubobject(EvalInfo &Info, Expr const *E,
+                             CompleteObject const &Obj,
+                             SubobjectDesignator const &Sub, APValue &Result,
                              AccessKinds AK = AK_Read) {
   assert(AK == AK_Read || AK == AK_ReadObjectRepresentation);
   ExtractSubobjectHandler Handler = {Info, E, Result, AK};
@@ -3830,7 +3812,7 @@
 struct ModifySubobjectHandler {
   EvalInfo &Info;
   APValue &NewVal;
-  const Expr *E;
+  Expr const *E;
 
   typedef bool result_type;
   static const AccessKinds AccessKind = AK_Assign;
@@ -3875,19 +3857,18 @@
 const AccessKinds ModifySubobjectHandler::AccessKind;
 
 /// Update the designated sub-object of an rvalue to the given value.
-static bool modifySubobject(EvalInfo &Info, const Expr *E,
-                            const CompleteObject &Obj,
-                            const SubobjectDesignator &Sub,
-                            APValue &NewVal) {
-  ModifySubobjectHandler Handler = { Info, NewVal, E };
+static bool modifySubobject(EvalInfo &Info, Expr const *E,
+                            CompleteObject const &Obj,
+                            SubobjectDesignator const &Sub, APValue &NewVal) {
+  ModifySubobjectHandler Handler = {Info, NewVal, E};
   return findSubobject(Info, E, Obj, Sub, Handler);
 }
 
 /// Find the position where two subobject designators diverge, or equivalently
 /// the length of the common initial subsequence.
 static unsigned FindDesignatorMismatch(QualType ObjType,
-                                       const SubobjectDesignator &A,
-                                       const SubobjectDesignator &B,
+                                       SubobjectDesignator const &A,
+                                       SubobjectDesignator const &B,
                                        bool &WasArrayIndex) {
   unsigned I = 0, N = std::min(A.Entries.size(), B.Entries.size());
   for (/**/; I != N; ++I) {
@@ -3908,7 +3889,7 @@
         WasArrayIndex = false;
         return I;
       }
-      if (const FieldDecl *FD = getAsField(A.Entries[I]))
+      if (FieldDecl const *FD = getAsField(A.Entries[I]))
         // Next subobject is a field.
         ObjType = FD->getType();
       else
@@ -3923,8 +3904,8 @@
 /// Determine whether the given subobject designators refer to elements of the
 /// same array object.
 static bool AreElementsOfSameArray(QualType ObjType,
-                                   const SubobjectDesignator &A,
-                                   const SubobjectDesignator &B) {
+                                   SubobjectDesignator const &A,
+                                   SubobjectDesignator const &B) {
   if (A.Entries.size() != B.Entries.size())
     return false;
 
@@ -3942,8 +3923,8 @@
 }
 
 /// Find the complete object to which an LValue refers.
-static CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E,
-                                         AccessKinds AK, const LValue &LVal,
+static CompleteObject findCompleteObject(EvalInfo &Info, Expr const *E,
+                                         AccessKinds AK, LValue const &LVal,
                                          QualType LValType) {
   if (LVal.InvalidBase) {
     Info.FFDiag(E);
@@ -3962,7 +3943,7 @@
         Info.getCallFrameAndDepth(LVal.getLValueCallIndex());
     if (!Frame) {
       Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1)
-        << AK << LVal.Base.is<const ValueDecl*>();
+          << AK << LVal.Base.is<ValueDecl const *>();
       NoteLValueLocation(Info, LVal.Base);
       return CompleteObject();
     }
@@ -3977,7 +3958,7 @@
   if (isFormalAccess(AK) && LValType.isVolatileQualified()) {
     if (Info.getLangOpts().CPlusPlus)
       Info.FFDiag(E, diag::note_constexpr_access_volatile_type)
-        << AK << LValType;
+          << AK << LValType;
     else
       Info.FFDiag(E);
     return CompleteObject();
@@ -3992,7 +3973,7 @@
     // This is the object whose initializer we're evaluating, so its lifetime
     // started in the current evaluation.
     BaseVal = Info.EvaluatingDeclValue;
-  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {
+  } else if (ValueDecl const *D = LVal.Base.dyn_cast<ValueDecl const *>()) {
     // Allow reading from a GUID declaration.
     if (auto *GD = dyn_cast<MSGuidDecl>(D)) {
       if (isModification(AK)) {
@@ -4026,9 +4007,9 @@
     // In C++1y, objects local to a constant expression (those with a Frame) are
     // both readable and writable inside constant expressions.
     // In C, such things can also be folded, although they are not ICEs.
-    const VarDecl *VD = dyn_cast<VarDecl>(D);
+    VarDecl const *VD = dyn_cast<VarDecl>(D);
     if (VD) {
-      if (const VarDecl *VDef = VD->getDefinition(Info.Ctx))
+      if (VarDecl const *VDef = VD->getDefinition(Info.Ctx))
         VD = VDef;
     }
     if (!VD || VD->isInvalidDecl()) {
@@ -4078,9 +4059,11 @@
         // folding of const floating-point types, in order to make static const
         // data members of such types (supported as an extension) more useful.
         if (Info.getLangOpts().CPlusPlus) {
-          Info.CCEDiag(E, Info.getLangOpts().CPlusPlus11
-                              ? diag::note_constexpr_ltor_non_constexpr
-                              : diag::note_constexpr_ltor_non_integral, 1)
+          Info.CCEDiag(E,
+                       Info.getLangOpts().CPlusPlus11
+                           ? diag::note_constexpr_ltor_non_constexpr
+                           : diag::note_constexpr_ltor_non_integral,
+                       1)
               << VD << BaseType;
           Info.Note(VD->getLocation(), diag::note_declared_at);
         } else {
@@ -4089,9 +4072,11 @@
       } else {
         // Never allow reading a non-const value.
         if (Info.getLangOpts().CPlusPlus) {
-          Info.FFDiag(E, Info.getLangOpts().CPlusPlus11
-                             ? diag::note_constexpr_ltor_non_constexpr
-                             : diag::note_constexpr_ltor_non_integral, 1)
+          Info.FFDiag(E,
+                      Info.getLangOpts().CPlusPlus11
+                          ? diag::note_constexpr_ltor_non_constexpr
+                          : diag::note_constexpr_ltor_non_integral,
+                      1)
               << VD << BaseType;
           Info.Note(VD->getLocation(), diag::note_declared_at);
         } else {
@@ -4101,10 +4086,11 @@
       }
     }
 
-    if (!evaluateVarDeclInit(Info, E, VD, Frame, LVal.getLValueVersion(), BaseVal))
+    if (!evaluateVarDeclInit(Info, E, VD, Frame, LVal.getLValueVersion(),
+                             BaseVal))
       return CompleteObject();
   } else if (DynamicAllocLValue DA = LVal.Base.dyn_cast<DynamicAllocLValue>()) {
-    Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA);
+    Optional<DynAlloc *> Alloc = Info.lookupDynamicAlloc(DA);
     if (!Alloc) {
       Info.FFDiag(E, diag::note_constexpr_access_deleted_object) << AK;
       return CompleteObject();
@@ -4112,10 +4098,10 @@
     return CompleteObject(LVal.Base, &(*Alloc)->Value,
                           LVal.Base.getDynamicAllocType());
   } else {
-    const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
+    Expr const *Base = LVal.Base.dyn_cast<Expr const *>();
 
     if (!Frame) {
-      if (const MaterializeTemporaryExpr *MTE =
+      if (MaterializeTemporaryExpr const *MTE =
               dyn_cast_or_null<MaterializeTemporaryExpr>(Base)) {
         assert(MTE->getStorageDuration() == SD_Static &&
                "should have a frame for a non-global materialized temporary");
@@ -4183,7 +4169,7 @@
   // to be read here (but take care with 'mutable' fields).
   unsigned VisibleDepth = Depth;
   if (llvm::isa_and_nonnull<ParmVarDecl>(
-          LVal.Base.dyn_cast<const ValueDecl *>()))
+          LVal.Base.dyn_cast<ValueDecl const *>()))
     ++VisibleDepth;
   if ((Frame && Info.getLangOpts().CPlusPlus14 &&
        Info.EvalStatus.HasSideEffects) ||
@@ -4208,20 +4194,20 @@
 ///               representation rather than the value, and in particular,
 ///               there is no requirement that the result be fully initialized.
 static bool
-handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, QualType Type,
-                               const LValue &LVal, APValue &RVal,
+handleLValueToRValueConversion(EvalInfo &Info, Expr const *Conv, QualType Type,
+                               LValue const &LVal, APValue &RVal,
                                bool WantObjectRepresentation = false) {
   if (LVal.Designator.Invalid)
     return false;
 
   // Check for special cases where there is no existing APValue to look at.
-  const Expr *Base = LVal.Base.dyn_cast<const Expr*>();
+  Expr const *Base = LVal.Base.dyn_cast<Expr const *>();
 
   AccessKinds AK =
       WantObjectRepresentation ? AK_ReadObjectRepresentation : AK_Read;
 
   if (Base && !LVal.getLValueCallIndex() && !Type.isVolatileQualified()) {
-    if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
+    if (CompoundLiteralExpr const *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {
       // In C99, a CompoundLiteralExpr is an lvalue, and we defer evaluating the
       // initializer until now for such expressions. Such an expression can't be
       // an ICE in C, so this only matters for fold.
@@ -4264,7 +4250,7 @@
 }
 
 /// Perform an assignment of Val to LVal. Takes ownership of Val.
-static bool handleAssignment(EvalInfo &Info, const Expr *E, const LValue &LVal,
+static bool handleAssignment(EvalInfo &Info, Expr const *E, LValue const &LVal,
                              QualType LValType, APValue &Val) {
   if (LVal.Designator.Invalid)
     return false;
@@ -4281,10 +4267,10 @@
 namespace {
 struct CompoundAssignSubobjectHandler {
   EvalInfo &Info;
-  const CompoundAssignOperator *E;
+  CompoundAssignOperator const *E;
   QualType PromotedLHSType;
   BinaryOperatorKind Opcode;
-  const APValue &RHS;
+  APValue const &RHS;
 
   static const AccessKinds AccessKind = AK_Assign;
 
@@ -4352,8 +4338,7 @@
       Value = HandleIntToIntCast(Info, E, SubobjType, PromotedLHSType, LHS);
       return true;
     } else if (RHS.isFloat()) {
-      const FPOptions FPO = E->getFPFeaturesInEffect(
-                                    Info.Ctx.getLangOpts());
+      const FPOptions FPO = E->getFPFeaturesInEffect(Info.Ctx.getLangOpts());
       APFloat FValue(0.0);
       return HandleIntToFloatCast(Info, E, FPO, SubobjType, Value,
                                   PromotedLHSType, FValue) &&
@@ -4377,7 +4362,7 @@
       return false;
 
     QualType PointeeType;
-    if (const PointerType *PT = SubobjType->getAs<PointerType>())
+    if (PointerType const *PT = SubobjType->getAs<PointerType>())
       PointeeType = PT->getPointeeType();
 
     if (PointeeType.isNull() || !RHS.isInt() ||
@@ -4404,11 +4389,11 @@
 
 /// Perform a compound assignment of LVal <op>= RVal.
 static bool handleCompoundAssignment(EvalInfo &Info,
-                                     const CompoundAssignOperator *E,
-                                     const LValue &LVal, QualType LValType,
+                                     CompoundAssignOperator const *E,
+                                     LValue const &LVal, QualType LValType,
                                      QualType PromotedLValType,
                                      BinaryOperatorKind Opcode,
-                                     const APValue &RVal) {
+                                     APValue const &RVal) {
   if (LVal.Designator.Invalid)
     return false;
 
@@ -4418,15 +4403,15 @@
   }
 
   CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
-  CompoundAssignSubobjectHandler Handler = { Info, E, PromotedLValType, Opcode,
-                                             RVal };
+  CompoundAssignSubobjectHandler Handler = {Info, E, PromotedLValType, Opcode,
+                                            RVal};
   return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
 }
 
 namespace {
 struct IncDecSubobjectHandler {
   EvalInfo &Info;
-  const UnaryOperator *E;
+  UnaryOperator const *E;
   AccessKinds AccessKind;
   APValue *Old;
 
@@ -4456,13 +4441,15 @@
     case APValue::Float:
       return found(Subobj.getFloat(), SubobjType);
     case APValue::ComplexInt:
-      return found(Subobj.getComplexIntReal(),
-                   SubobjType->castAs<ComplexType>()->getElementType()
-                     .withCVRQualifiers(SubobjType.getCVRQualifiers()));
+      return found(
+          Subobj.getComplexIntReal(),
+          SubobjType->castAs<ComplexType>()->getElementType().withCVRQualifiers(
+              SubobjType.getCVRQualifiers()));
     case APValue::ComplexFloat:
-      return found(Subobj.getComplexFloatReal(),
-                   SubobjType->castAs<ComplexType>()->getElementType()
-                     .withCVRQualifiers(SubobjType.getCVRQualifiers()));
+      return found(
+          Subobj.getComplexFloatReal(),
+          SubobjType->castAs<ComplexType>()->getElementType().withCVRQualifiers(
+              SubobjType.getCVRQualifiers()));
     case APValue::LValue:
       return foundPointer(Subobj, SubobjType);
     default:
@@ -4482,7 +4469,8 @@
       return false;
     }
 
-    if (Old) *Old = APValue(Value);
+    if (Old)
+      *Old = APValue(Value);
 
     // bool arithmetic promotes to int, and the conversion back to bool
     // doesn't reduce mod 2^n, so special-case it.
@@ -4499,7 +4487,7 @@
       ++Value;
 
       if (!WasNegative && Value.isNegative() && E->canOverflow()) {
-        APSInt ActualValue(Value, /*IsUnsigned*/true);
+        APSInt ActualValue(Value, /*IsUnsigned*/ true);
         return HandleOverflow(Info, E, ActualValue, SubobjType);
       }
     } else {
@@ -4507,7 +4495,7 @@
 
       if (WasNegative && !Value.isNegative() && E->canOverflow()) {
         unsigned BitWidth = Value.getBitWidth();
-        APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false);
+        APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/ false);
         ActualValue.setBit(BitWidth);
         return HandleOverflow(Info, E, ActualValue, SubobjType);
       }
@@ -4518,7 +4506,8 @@
     if (!checkConst(SubobjType))
       return false;
 
-    if (Old) *Old = APValue(Value);
+    if (Old)
+      *Old = APValue(Value);
 
     APFloat One(Value.getSemantics(), 1);
     if (AccessKind == AK_Increment)
@@ -4532,7 +4521,7 @@
       return false;
 
     QualType PointeeType;
-    if (const PointerType *PT = SubobjType->getAs<PointerType>())
+    if (PointerType const *PT = SubobjType->getAs<PointerType>())
       PointeeType = PT->getPointeeType();
     else {
       Info.FFDiag(E);
@@ -4551,7 +4540,7 @@
 } // end anonymous namespace
 
 /// Perform an increment or decrement on LVal.
-static bool handleIncDec(EvalInfo &Info, const Expr *E, const LValue &LVal,
+static bool handleIncDec(EvalInfo &Info, Expr const *E, LValue const &LVal,
                          QualType LValType, bool IsIncrement, APValue *Old) {
   if (LVal.Designator.Invalid)
     return false;
@@ -4568,7 +4557,7 @@
 }
 
 /// Build an lvalue for the object argument of a member function call.
-static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
+static bool EvaluateObjectArgument(EvalInfo &Info, Expr const *Object,
                                    LValue &This) {
   if (Object->getType()->isPointerType() && Object->isPRValue())
     return EvaluatePointer(Object, This, Info);
@@ -4594,10 +4583,9 @@
 ///        creating a bound member function.
 /// \return The field or method declaration to which the member pointer refers,
 ///         or 0 if evaluation fails.
-static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
-                                                  QualType LVType,
-                                                  LValue &LV,
-                                                  const Expr *RHS,
+static ValueDecl const *HandleMemberPointerAccess(EvalInfo &Info,
+                                                  QualType LVType, LValue &LV,
+                                                  Expr const *RHS,
                                                   bool IncludeMember = true) {
   MemberPtr MemPtr;
   if (!EvaluateMemberPointer(RHS, MemPtr, Info))
@@ -4623,9 +4611,9 @@
     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 *MPDecl = MemPtr.Path[I];
+      CXXRecordDecl const *LVDecl =
+          getAsBaseClass(LV.Designator.Entries[PathLengthToMember + I]);
+      CXXRecordDecl const *MPDecl = MemPtr.Path[I];
       if (LVDecl->getCanonicalDecl() != MPDecl->getCanonicalDecl()) {
         Info.FFDiag(RHS);
         return nullptr;
@@ -4642,13 +4630,13 @@
                                   MemPtr.Path.size() + IncludeMember);
 
     // Walk down to the appropriate base class.
-    if (const PointerType *PT = LVType->getAs<PointerType>())
+    if (PointerType const *PT = LVType->getAs<PointerType>())
       LVType = PT->getPointeeType();
-    const CXXRecordDecl *RD = LVType->getAsCXXRecordDecl();
+    CXXRecordDecl const *RD = LVType->getAsCXXRecordDecl();
     assert(RD && "member pointer access on non-class-type expression");
     // The first class in the path is that of the lvalue.
     for (unsigned I = 1, N = MemPtr.Path.size(); I != N; ++I) {
-      const CXXRecordDecl *Base = MemPtr.Path[N - I - 1];
+      CXXRecordDecl const *Base = MemPtr.Path[N - I - 1];
       if (!HandleLValueDirectBase(Info, RHS, LV, RD, Base))
         return nullptr;
       RD = Base;
@@ -4661,11 +4649,11 @@
 
   // Add the member. Note that we cannot build bound member functions here.
   if (IncludeMember) {
-    if (const FieldDecl *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) {
+    if (FieldDecl const *FD = dyn_cast<FieldDecl>(MemPtr.getDecl())) {
       if (!HandleLValueMember(Info, RHS, LV, FD))
         return nullptr;
-    } else if (const IndirectFieldDecl *IFD =
-                 dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) {
+    } else if (IndirectFieldDecl const *IFD =
+                   dyn_cast<IndirectFieldDecl>(MemPtr.getDecl())) {
       if (!HandleLValueIndirectMember(Info, RHS, LV, IFD))
         return nullptr;
     } else {
@@ -4676,8 +4664,8 @@
   return MemPtr.getDecl();
 }
 
-static const ValueDecl *HandleMemberPointerAccess(EvalInfo &Info,
-                                                  const BinaryOperator *BO,
+static ValueDecl const *HandleMemberPointerAccess(EvalInfo &Info,
+                                                  BinaryOperator const *BO,
                                                   LValue &LV,
                                                   bool IncludeMember = true) {
   assert(BO->getOpcode() == BO_PtrMemD || BO->getOpcode() == BO_PtrMemI);
@@ -4696,35 +4684,35 @@
 
 /// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on
 /// the provided lvalue, which currently refers to the base object.
-static bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E,
+static bool HandleBaseToDerivedCast(EvalInfo &Info, CastExpr const *E,
                                     LValue &Result) {
   SubobjectDesignator &D = Result.Designator;
   if (D.Invalid || !Result.checkNullPointer(Info, E, CSK_Derived))
     return false;
 
   QualType TargetQT = E->getType();
-  if (const PointerType *PT = TargetQT->getAs<PointerType>())
+  if (PointerType const *PT = TargetQT->getAs<PointerType>())
     TargetQT = PT->getPointeeType();
 
   // Check this cast lands within the final derived-to-base subobject path.
   if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) {
     Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
-      << D.MostDerivedType << TargetQT;
+        << D.MostDerivedType << TargetQT;
     return false;
   }
 
   // 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;
+  CXXRecordDecl const *TargetType = TargetQT->getAsCXXRecordDecl();
+  CXXRecordDecl const *FinalType;
   if (NewEntriesSize == D.MostDerivedPathLength)
     FinalType = D.MostDerivedType->getAsCXXRecordDecl();
   else
     FinalType = getAsBaseClass(D.Entries[NewEntriesSize - 1]);
   if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) {
     Info.CCEDiag(E, diag::note_constexpr_invalid_downcast)
-      << D.MostDerivedType << TargetQT;
+        << D.MostDerivedType << TargetQT;
     return false;
   }
 
@@ -4742,7 +4730,7 @@
       return false;
     }
     if (RD->isUnion()) {
-      Result = APValue((const FieldDecl *)nullptr);
+      Result = APValue((FieldDecl const *)nullptr);
       return true;
     }
     Result = APValue(APValue::UninitStruct(), RD->getNumBases(),
@@ -4754,7 +4742,7 @@
          I != End; ++I, ++Index)
       Success &= getDefaultInitValue(I->getType(), Result.getStructBase(Index));
 
-    for (const auto *I : RD->fields()) {
+    for (auto const *I : RD->fields()) {
       if (I->isUnnamedBitfield())
         continue;
       Success &= getDefaultInitValue(I->getType(),
@@ -4794,7 +4782,7 @@
 };
 }
 
-static bool EvaluateVarDecl(EvalInfo &Info, const VarDecl *VD) {
+static bool EvaluateVarDecl(EvalInfo &Info, VarDecl const *VD) {
   // We don't need to evaluate the initializer for a static local.
   if (!VD->hasLocalStorage())
     return true;
@@ -4803,7 +4791,7 @@
   APValue &Val = Info.CurrentCall->createTemporary(VD, VD->getType(),
                                                    ScopeKind::Block, Result);
 
-  const Expr *InitE = VD->getInit();
+  Expr const *InitE = VD->getInit();
   if (!InitE) {
     if (VD->getType()->isDependentType())
       return Info.noteSideEffect();
@@ -4822,13 +4810,13 @@
   return true;
 }
 
-static bool EvaluateDecl(EvalInfo &Info, const Decl *D) {
+static bool EvaluateDecl(EvalInfo &Info, Decl const *D) {
   bool OK = true;
 
-  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
+  if (VarDecl const *VD = dyn_cast<VarDecl>(D))
     OK &= EvaluateVarDecl(Info, VD);
 
-  if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(D))
+  if (DecompositionDecl const *DD = dyn_cast<DecompositionDecl>(D))
     for (auto *BD : DD->bindings())
       if (auto *VD = BD->getHoldingVar())
         OK &= EvaluateDecl(Info, VD);
@@ -4836,7 +4824,7 @@
   return OK;
 }
 
-static bool EvaluateDependentExpr(const Expr *E, EvalInfo &Info) {
+static bool EvaluateDependentExpr(Expr const *E, EvalInfo &Info) {
   assert(E->isValueDependent());
   if (Info.noteSideEffect())
     return true;
@@ -4846,8 +4834,8 @@
 }
 
 /// Evaluate a condition (either a variable declaration or an expression).
-static bool EvaluateCond(EvalInfo &Info, const VarDecl *CondDecl,
-                         const Expr *Cond, bool &Result) {
+static bool EvaluateCond(EvalInfo &Info, VarDecl const *CondDecl,
+                         Expr const *Cond, bool &Result) {
   if (Cond->isValueDependent())
     return false;
   FullExpressionRAII Scope(Info);
@@ -4865,7 +4853,7 @@
   /// The APValue that should be filled in with the returned value.
   APValue &Value;
   /// The location containing the result, if any (used to support RVO).
-  const LValue *Slot;
+  LValue const *Slot;
 };
 
 struct TempVersionRAII {
@@ -4875,21 +4863,19 @@
     Frame.pushTempVersion();
   }
 
-  ~TempVersionRAII() {
-    Frame.popTempVersion();
-  }
+  ~TempVersionRAII() { Frame.popTempVersion(); }
 };
 
-}
+} // namespace
 
 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
-                                   const Stmt *S,
-                                   const SwitchCase *SC = nullptr);
+                                   Stmt const *S,
+                                   SwitchCase const *SC = nullptr);
 
 /// Evaluate the body of a loop, and translate the result as appropriate.
 static EvalStmtResult EvaluateLoopBody(StmtResult &Result, EvalInfo &Info,
-                                       const Stmt *Body,
-                                       const SwitchCase *Case = nullptr) {
+                                       Stmt const *Body,
+                                       SwitchCase const *Case = nullptr) {
   BlockScopeRAII Scope(Info);
 
   EvalStmtResult ESR = EvaluateStmt(Result, Info, Body, Case);
@@ -4912,13 +4898,13 @@
 
 /// Evaluate a switch statement.
 static EvalStmtResult EvaluateSwitch(StmtResult &Result, EvalInfo &Info,
-                                     const SwitchStmt *SS) {
+                                     SwitchStmt const *SS) {
   BlockScopeRAII Scope(Info);
 
   // Evaluate the switch condition.
   APSInt Value;
   {
-    if (const Stmt *Init = SS->getInit()) {
+    if (Stmt const *Init = SS->getInit()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
       if (ESR != ESR_Succeeded) {
         if (ESR != ESR_Failed && !Scope.destroy())
@@ -4939,18 +4925,18 @@
 
   // Find the switch case corresponding to the value of the condition.
   // FIXME: Cache this lookup.
-  const SwitchCase *Found = nullptr;
-  for (const SwitchCase *SC = SS->getSwitchCaseList(); SC;
+  SwitchCase const *Found = nullptr;
+  for (SwitchCase const *SC = SS->getSwitchCaseList(); SC;
        SC = SC->getNextSwitchCase()) {
     if (isa<DefaultStmt>(SC)) {
       Found = SC;
       continue;
     }
 
-    const CaseStmt *CS = cast<CaseStmt>(SC);
+    CaseStmt const *CS = cast<CaseStmt>(SC);
     APSInt LHS = CS->getLHS()->EvaluateKnownConstInt(Info.Ctx);
-    APSInt RHS = CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx)
-                              : LHS;
+    APSInt RHS =
+        CS->getRHS() ? CS->getRHS()->EvaluateKnownConstInt(Info.Ctx) : LHS;
     if (LHS <= Value && Value <= RHS) {
       Found = SC;
       break;
@@ -4985,7 +4971,7 @@
 
 // Evaluate a statement.
 static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
-                                   const Stmt *S, const SwitchCase *Case) {
+                                   Stmt const *S, SwitchCase const *Case) {
   if (!Info.nextStep(S))
     return ESR_Failed;
 
@@ -5011,7 +4997,7 @@
     case Stmt::IfStmtClass: {
       // FIXME: Precompute which side of an 'if' we would jump to, and go
       // straight there rather than scanning both sides.
-      const IfStmt *IS = cast<IfStmt>(S);
+      IfStmt const *IS = cast<IfStmt>(S);
 
       // Wrap the evaluation in a block scope, in case it's a DeclStmt
       // preceded by our switch label.
@@ -5019,7 +5005,7 @@
 
       // Step into the init statement in case it brings an (uninitialized)
       // variable into scope.
-      if (const Stmt *Init = IS->getInit()) {
+      if (Stmt const *Init = IS->getInit()) {
         EvalStmtResult ESR = EvaluateStmt(Result, Info, Init, Case);
         if (ESR != ESR_CaseNotFound) {
           assert(ESR != ESR_Succeeded);
@@ -5057,12 +5043,12 @@
     }
 
     case Stmt::ForStmtClass: {
-      const ForStmt *FS = cast<ForStmt>(S);
+      ForStmt const *FS = cast<ForStmt>(S);
       BlockScopeRAII Scope(Info);
 
       // Step into the init statement in case it brings an (uninitialized)
       // variable into scope.
-      if (const Stmt *Init = FS->getInit()) {
+      if (Stmt const *Init = FS->getInit()) {
         EvalStmtResult ESR = EvaluateStmt(Result, Info, Init, Case);
         if (ESR != ESR_CaseNotFound) {
           assert(ESR != ESR_Succeeded);
@@ -5070,11 +5056,10 @@
         }
       }
 
-      EvalStmtResult ESR =
-          EvaluateLoopBody(Result, Info, FS->getBody(), Case);
+      EvalStmtResult ESR = EvaluateLoopBody(Result, Info, FS->getBody(), Case);
       if (ESR != ESR_Continue)
         return ESR;
-      if (const auto *Inc = FS->getInc()) {
+      if (auto const *Inc = FS->getInc()) {
         if (Inc->isValueDependent()) {
           if (!EvaluateDependentExpr(Inc, Info))
             return ESR_Failed;
@@ -5090,9 +5075,9 @@
     case Stmt::DeclStmtClass: {
       // Start the lifetime of any uninitialized variables we encounter. They
       // might be used by the selected branch of the switch.
-      const DeclStmt *DS = cast<DeclStmt>(S);
-      for (const auto *D : DS->decls()) {
-        if (const auto *VD = dyn_cast<VarDecl>(D)) {
+      DeclStmt const *DS = cast<DeclStmt>(S);
+      for (auto const *D : DS->decls()) {
+        if (auto const *VD = dyn_cast<VarDecl>(D)) {
           if (VD->hasLocalStorage() && !VD->getInit())
             if (!EvaluateVarDecl(Info, VD))
               return ESR_Failed;
@@ -5111,7 +5096,7 @@
 
   switch (S->getStmtClass()) {
   default:
-    if (const Expr *E = dyn_cast<Expr>(S)) {
+    if (Expr const *E = dyn_cast<Expr>(S)) {
       if (E->isValueDependent()) {
         if (!EvaluateDependentExpr(E, Info))
           return ESR_Failed;
@@ -5134,8 +5119,8 @@
     return ESR_Succeeded;
 
   case Stmt::DeclStmtClass: {
-    const DeclStmt *DS = cast<DeclStmt>(S);
-    for (const auto *D : DS->decls()) {
+    DeclStmt const *DS = cast<DeclStmt>(S);
+    for (auto const *D : DS->decls()) {
       // Each declaration initialization is its own full-expression.
       FullExpressionRAII Scope(Info);
       if (!EvaluateDecl(Info, D) && !Info.noteFailure())
@@ -5147,17 +5132,16 @@
   }
 
   case Stmt::ReturnStmtClass: {
-    const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
+    Expr const *RetExpr = cast<ReturnStmt>(S)->getRetValue();
     FullExpressionRAII Scope(Info);
     if (RetExpr && RetExpr->isValueDependent()) {
       EvaluateDependentExpr(RetExpr, Info);
       // We know we returned, but we don't know what the value is.
       return ESR_Failed;
     }
-    if (RetExpr &&
-        !(Result.Slot
-              ? EvaluateInPlace(Result.Value, Info, *Result.Slot, RetExpr)
-              : Evaluate(Result.Value, Info, RetExpr)))
+    if (RetExpr && !(Result.Slot ? EvaluateInPlace(Result.Value, Info,
+                                                   *Result.Slot, RetExpr)
+                                 : Evaluate(Result.Value, Info, RetExpr)))
       return ESR_Failed;
     return Scope.destroy() ? ESR_Returned : ESR_Failed;
   }
@@ -5165,8 +5149,8 @@
   case Stmt::CompoundStmtClass: {
     BlockScopeRAII Scope(Info);
 
-    const CompoundStmt *CS = cast<CompoundStmt>(S);
-    for (const auto *BI : CS->body()) {
+    CompoundStmt const *CS = cast<CompoundStmt>(S);
+    for (auto const *BI : CS->body()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, BI, Case);
       if (ESR == ESR_Succeeded)
         Case = nullptr;
@@ -5182,11 +5166,11 @@
   }
 
   case Stmt::IfStmtClass: {
-    const IfStmt *IS = cast<IfStmt>(S);
+    IfStmt const *IS = cast<IfStmt>(S);
 
     // Evaluate the condition, as either a var decl or as an expression.
     BlockScopeRAII Scope(Info);
-    if (const Stmt *Init = IS->getInit()) {
+    if (Stmt const *Init = IS->getInit()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
       if (ESR != ESR_Succeeded) {
         if (ESR != ESR_Failed && !Scope.destroy())
@@ -5198,7 +5182,7 @@
     if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
       return ESR_Failed;
 
-    if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
+    if (Stmt const *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt);
       if (ESR != ESR_Succeeded) {
         if (ESR != ESR_Failed && !Scope.destroy())
@@ -5210,7 +5194,7 @@
   }
 
   case Stmt::WhileStmtClass: {
-    const WhileStmt *WS = cast<WhileStmt>(S);
+    WhileStmt const *WS = cast<WhileStmt>(S);
     while (true) {
       BlockScopeRAII Scope(Info);
       bool Continue;
@@ -5233,7 +5217,7 @@
   }
 
   case Stmt::DoStmtClass: {
-    const DoStmt *DS = cast<DoStmt>(S);
+    DoStmt const *DS = cast<DoStmt>(S);
     bool Continue;
     do {
       EvalStmtResult ESR = EvaluateLoopBody(Result, Info, DS->getBody(), Case);
@@ -5255,7 +5239,7 @@
   }
 
   case Stmt::ForStmtClass: {
-    const ForStmt *FS = cast<ForStmt>(S);
+    ForStmt const *FS = cast<ForStmt>(S);
     BlockScopeRAII ForScope(Info);
     if (FS->getInit()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, FS->getInit());
@@ -5281,7 +5265,7 @@
         return ESR;
       }
 
-      if (const auto *Inc = FS->getInc()) {
+      if (auto const *Inc = FS->getInc()) {
         if (Inc->isValueDependent()) {
           if (!EvaluateDependentExpr(Inc, Info))
             return ESR_Failed;
@@ -5299,7 +5283,7 @@
   }
 
   case Stmt::CXXForRangeStmtClass: {
-    const CXXForRangeStmt *FS = cast<CXXForRangeStmt>(S);
+    CXXForRangeStmt const *FS = cast<CXXForRangeStmt>(S);
     BlockScopeRAII Scope(Info);
 
     // Evaluate the init-statement if present.
@@ -5414,7 +5398,7 @@
 /// constexpr. If it is marked as constexpr, we will never implicitly define it,
 /// so we need special handling.
 static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,
-                                           const CXXConstructorDecl *CD,
+                                           CXXConstructorDecl const *CD,
                                            bool IsValueInitialization) {
   if (!CD->isTrivial() || !CD->isDefaultConstructor())
     return false;
@@ -5427,7 +5411,7 @@
       // FIXME: If DiagDecl is an implicitly-declared special member function,
       // we should be much more explicit about why it's not constexpr.
       Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
-        << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD;
+          << /*IsConstexpr*/ 0 << /*IsConstructor*/ 1 << CD;
       Info.Note(CD->getLocation(), diag::note_declared_at);
     } else {
       Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
@@ -5439,9 +5423,9 @@
 /// CheckConstexprFunction - Check that a function can be called in a constant
 /// expression.
 static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc,
-                                   const FunctionDecl *Declaration,
-                                   const FunctionDecl *Definition,
-                                   const Stmt *Body) {
+                                   FunctionDecl const *Declaration,
+                                   FunctionDecl const *Definition,
+                                   Stmt const *Body) {
   // Potential constant expressions can contain calls to declared, but not yet
   // defined, constexpr functions.
   if (Info.checkingPotentialConstantExpression() && !Definition &&
@@ -5473,7 +5457,7 @@
     return true;
 
   if (Info.getLangOpts().CPlusPlus11) {
-    const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;
+    FunctionDecl const *DiagDecl = Definition ? Definition : Declaration;
 
     // If this function is not constexpr because it is an inherited
     // non-constexpr constructor, diagnose that directly.
@@ -5489,10 +5473,10 @@
     // it's not constexpr.
     if (CD && CD->isInheritingConstructor())
       Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1)
-        << CD->getInheritedConstructor().getConstructor()->getParent();
+          << CD->getInheritedConstructor().getConstructor()->getParent();
     else
       Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1)
-        << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
+          << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
     Info.Note(DiagDecl->getLocation(), diag::note_declared_at);
   } else {
     Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
@@ -5513,7 +5497,7 @@
 
 /// Check that we can access the notional vptr of an object / determine its
 /// dynamic type.
-static bool checkDynamicType(EvalInfo &Info, const Expr *E, const LValue &This,
+static bool checkDynamicType(EvalInfo &Info, Expr const *E, LValue const &This,
                              AccessKinds AK, bool Polymorphic) {
   if (This.Designator.Invalid)
     return false;
@@ -5555,9 +5539,9 @@
 /// Check that the pointee of the 'this' pointer in a member function call is
 /// either within its lifetime or in its period of construction or destruction.
 static bool
-checkNonVirtualMemberCallThisPointer(EvalInfo &Info, const Expr *E,
-                                     const LValue &This,
-                                     const CXXMethodDecl *NamedMember) {
+checkNonVirtualMemberCallThisPointer(EvalInfo &Info, Expr const *E,
+                                     LValue const &This,
+                                     CXXMethodDecl const *NamedMember) {
   return checkDynamicType(
       Info, E, This,
       isa<CXXDestructorDecl>(NamedMember) ? AK_Destroy : AK_MemberCall, false);
@@ -5565,22 +5549,22 @@
 
 struct DynamicType {
   /// The dynamic class type of the object.
-  const CXXRecordDecl *Type;
+  CXXRecordDecl const *Type;
   /// The corresponding path length in the lvalue.
   unsigned PathLength;
 };
 
-static const CXXRecordDecl *getBaseClassType(SubobjectDesignator &Designator,
+static CXXRecordDecl const *getBaseClassType(SubobjectDesignator &Designator,
                                              unsigned PathLength) {
-  assert(PathLength >= Designator.MostDerivedPathLength && PathLength <=
-      Designator.Entries.size() && "invalid path length");
+  assert(PathLength >= Designator.MostDerivedPathLength &&
+         PathLength <= Designator.Entries.size() && "invalid path length");
   return (PathLength == Designator.MostDerivedPathLength)
              ? Designator.MostDerivedType->getAsCXXRecordDecl()
              : getAsBaseClass(Designator.Entries[PathLength - 1]);
 }
 
 /// Determine the dynamic type of an object.
-static Optional<DynamicType> ComputeDynamicType(EvalInfo &Info, const Expr *E,
+static Optional<DynamicType> ComputeDynamicType(EvalInfo &Info, Expr const *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
@@ -5594,7 +5578,7 @@
   //
   // Note that consumers of DynamicType assume that the type has no virtual
   // bases, and will need modifications if this restriction is relaxed.
-  const CXXRecordDecl *Class =
+  CXXRecordDecl const *Class =
       This.Designator.MostDerivedType->getAsCXXRecordDecl();
   if (!Class || Class->getNumVBases()) {
     Info.FFDiag(E);
@@ -5635,8 +5619,8 @@
 }
 
 /// Perform virtual dispatch.
-static const CXXMethodDecl *HandleVirtualDispatch(
-    EvalInfo &Info, const Expr *E, LValue &This, const CXXMethodDecl *Found,
+static CXXMethodDecl const *HandleVirtualDispatch(
+    EvalInfo &Info, Expr const *E, LValue &This, CXXMethodDecl const *Found,
     llvm::SmallVectorImpl<QualType> &CovariantAdjustmentPath) {
   Optional<DynamicType> DynType = ComputeDynamicType(
       Info, E, This,
@@ -5648,11 +5632,11 @@
   // path from the dynamic type to the static type.
   // FIXME: If we ever allow literal types to have virtual base classes, that
   // won't be true.
-  const CXXMethodDecl *Callee = Found;
+  CXXMethodDecl const *Callee = Found;
   unsigned PathLength = DynType->PathLength;
   for (/**/; PathLength <= This.Designator.Entries.size(); ++PathLength) {
-    const CXXRecordDecl *Class = getBaseClassType(This.Designator, PathLength);
-    const CXXMethodDecl *Overrider =
+    CXXRecordDecl const *Class = getBaseClassType(This.Designator, PathLength);
+    CXXMethodDecl const *Overrider =
         Found->getCorrespondingMethodDeclaredInClass(Class, false);
     if (Overrider) {
       Callee = Overrider;
@@ -5677,9 +5661,9 @@
     for (unsigned CovariantPathLength = PathLength + 1;
          CovariantPathLength != This.Designator.Entries.size();
          ++CovariantPathLength) {
-      const CXXRecordDecl *NextClass =
+      CXXRecordDecl const *NextClass =
           getBaseClassType(This.Designator, CovariantPathLength);
-      const CXXMethodDecl *Next =
+      CXXMethodDecl const *Next =
           Found->getCorrespondingMethodDeclaredInClass(NextClass, false);
       if (Next && !Info.Ctx.hasSameUnqualifiedType(
                       Next->getReturnType(), CovariantAdjustmentPath.back()))
@@ -5700,7 +5684,7 @@
 /// Perform the adjustment from a value returned by a virtual function to
 /// a value of the statically expected type, which may be a pointer or
 /// reference to a base class of the returned type.
-static bool HandleCovariantReturnAdjustment(EvalInfo &Info, const Expr *E,
+static bool HandleCovariantReturnAdjustment(EvalInfo &Info, Expr const *E,
                                             APValue &Result,
                                             ArrayRef<QualType> Path) {
   assert(Result.isLValue() &&
@@ -5711,9 +5695,9 @@
   LValue LVal;
   LVal.setFrom(Info.Ctx, Result);
 
-  const CXXRecordDecl *OldClass = Path[0]->getPointeeCXXRecordDecl();
+  CXXRecordDecl const *OldClass = Path[0]->getPointeeCXXRecordDecl();
   for (unsigned I = 1; I != Path.size(); ++I) {
-    const CXXRecordDecl *NewClass = Path[I]->getPointeeCXXRecordDecl();
+    CXXRecordDecl const *NewClass = Path[I]->getPointeeCXXRecordDecl();
     assert(OldClass && NewClass && "unexpected kind of covariant return");
     if (OldClass != NewClass &&
         !CastToBaseClass(Info, E, LVal, OldClass, NewClass))
@@ -5727,9 +5711,9 @@
 
 /// Determine whether \p Base, which is known to be a direct base class of
 /// \p Derived, is a public base class.
-static bool isBaseClassPublic(const CXXRecordDecl *Derived,
-                              const CXXRecordDecl *Base) {
-  for (const CXXBaseSpecifier &BaseSpec : Derived->bases()) {
+static bool isBaseClassPublic(CXXRecordDecl const *Derived,
+                              CXXRecordDecl const *Base) {
+  for (CXXBaseSpecifier const &BaseSpec : Derived->bases()) {
     auto *BaseClass = BaseSpec.getType()->getAsCXXRecordDecl();
     if (BaseClass && declaresSameEntity(BaseClass, Base))
       return BaseSpec.getAccessSpecifier() == AS_public;
@@ -5741,7 +5725,7 @@
 ///
 /// This implements the hard case of dynamic_cast, requiring a "runtime check"
 /// to find a suitable target subobject.
-static bool HandleDynamicCast(EvalInfo &Info, const ExplicitCastExpr *E,
+static bool HandleDynamicCast(EvalInfo &Info, ExplicitCastExpr const *E,
                               LValue &Ptr) {
   // We can't do anything with a non-symbolic pointer value.
   SubobjectDesignator &D = Ptr.Designator;
@@ -5767,11 +5751,11 @@
   if (E->getType()->isVoidPointerType())
     return CastToDerivedClass(Info, E, Ptr, DynType->Type, DynType->PathLength);
 
-  const CXXRecordDecl *C = E->getTypeAsWritten()->getPointeeCXXRecordDecl();
+  CXXRecordDecl const *C = E->getTypeAsWritten()->getPointeeCXXRecordDecl();
   assert(C && "dynamic_cast target is not void pointer nor class");
   CanQualType CQT = Info.Ctx.getCanonicalType(Info.Ctx.getRecordType(C));
 
-  auto RuntimeCheckFailed = [&] (CXXBasePaths *Paths) {
+  auto RuntimeCheckFailed = [&](CXXBasePaths *Paths) {
     // C++ [expr.dynamic.cast]p9:
     if (!E->isGLValue()) {
       //   The value of a failed cast to pointer type is the null pointer value
@@ -5805,7 +5789,7 @@
   //   target type.
   for (int PathLength = Ptr.Designator.Entries.size();
        PathLength >= (int)DynType->PathLength; --PathLength) {
-    const CXXRecordDecl *Class = getBaseClassType(Ptr.Designator, PathLength);
+    CXXRecordDecl const *Class = getBaseClassType(Ptr.Designator, PathLength);
     if (declaresSameEntity(Class, C))
       return CastToDerivedClass(Info, E, Ptr, Class, PathLength);
     // We can only walk across public inheritance edges.
@@ -5838,8 +5822,8 @@
 namespace {
 struct StartLifetimeOfUnionMemberHandler {
   EvalInfo &Info;
-  const Expr *LHSExpr;
-  const FieldDecl *Field;
+  Expr const *LHSExpr;
+  FieldDecl const *Field;
   bool DuringInit;
   bool Failed = false;
   static const AccessKinds AccessKind = AK_Assign;
@@ -5889,16 +5873,16 @@
 /// operator whose left-hand side might involve a union member access. If it
 /// does, implicitly start the lifetime of any accessed union elements per
 /// C++20 [class.union]5.
-static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *LHSExpr,
-                                          const LValue &LHS) {
+static bool HandleUnionActiveMemberChange(EvalInfo &Info, Expr const *LHSExpr,
+                                          LValue const &LHS) {
   if (LHS.InvalidBase || LHS.Designator.Invalid)
     return false;
 
-  llvm::SmallVector<std::pair<unsigned, const FieldDecl*>, 4> UnionPathLengths;
+  llvm::SmallVector<std::pair<unsigned, FieldDecl const *>, 4> UnionPathLengths;
   // C++ [class.union]p5:
   //   define the set S(E) of subexpressions of E as follows:
   unsigned PathLength = LHS.Designator.Entries.size();
-  for (const Expr *E = LHSExpr; E != nullptr;) {
+  for (Expr const *E = LHSExpr; E != nullptr;) {
     //   -- If E is of the form A.B, S(E) contains the elements of S(A)...
     if (auto *ME = dyn_cast<MemberExpr>(E)) {
       auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
@@ -5920,9 +5904,9 @@
 
       E = ME->getBase();
       --PathLength;
-      assert(declaresSameEntity(FD,
-                                LHS.Designator.Entries[PathLength]
-                                    .getAsBaseOrMember().getPointer()));
+      assert(declaresSameEntity(
+          FD,
+          LHS.Designator.Entries[PathLength].getAsBaseOrMember().getPointer()));
 
       //   -- 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)].
@@ -5944,15 +5928,16 @@
           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())) {
+      for (CXXBaseSpecifier const *Elt : llvm::reverse(ICE->path())) {
         --PathLength;
         (void)Elt;
         assert(declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(),
                                   LHS.Designator.Entries[PathLength]
-                                      .getAsBaseOrMember().getPointer()));
+                                      .getAsBaseOrMember()
+                                      .getPointer()));
       }
 
-    //   -- Otherwise, S(E) is empty.
+      //   -- Otherwise, S(E) is empty.
     } else {
       break;
     }
@@ -5968,8 +5953,8 @@
       findCompleteObject(Info, LHSExpr, AK_Assign, LHS, LHSExpr->getType());
   if (!Obj)
     return false;
-  for (std::pair<unsigned, const FieldDecl *> LengthAndField :
-           llvm::reverse(UnionPathLengths)) {
+  for (std::pair<unsigned, FieldDecl const *> LengthAndField :
+       llvm::reverse(UnionPathLengths)) {
     // Form a designator for the union object.
     SubobjectDesignator D = LHS.Designator;
     D.truncate(Info.Ctx, LHS.Base, LengthAndField.first);
@@ -5985,7 +5970,7 @@
   return true;
 }
 
-static bool EvaluateCallArg(const ParmVarDecl *PVD, const Expr *Arg,
+static bool EvaluateCallArg(ParmVarDecl const *PVD, Expr const *Arg,
                             CallRef Call, EvalInfo &Info,
                             bool NonNull = false) {
   LValue LV;
@@ -6011,14 +5996,14 @@
 }
 
 /// Evaluate the arguments to a function call.
-static bool EvaluateArgs(ArrayRef<const Expr *> Args, CallRef Call,
-                         EvalInfo &Info, const FunctionDecl *Callee,
+static bool EvaluateArgs(ArrayRef<Expr const *> Args, CallRef Call,
+                         EvalInfo &Info, FunctionDecl const *Callee,
                          bool RightToLeft = false) {
   bool Success = true;
   llvm::SmallBitVector ForbiddenNullArgs;
   if (Callee->hasAttr<NonNullAttr>()) {
     ForbiddenNullArgs.resize(Args.size());
-    for (const auto *Attr : Callee->specific_attrs<NonNullAttr>()) {
+    for (auto const *Attr : Callee->specific_attrs<NonNullAttr>()) {
       if (!Attr->args_size()) {
         ForbiddenNullArgs.set();
         break;
@@ -6033,7 +6018,7 @@
   }
   for (unsigned I = 0; I < Args.size(); I++) {
     unsigned Idx = RightToLeft ? Args.size() - I - 1 : I;
-    const ParmVarDecl *PVD =
+    ParmVarDecl const *PVD =
         Idx < Callee->getNumParams() ? Callee->getParamDecl(Idx) : nullptr;
     bool NonNull = !ForbiddenNullArgs.empty() && ForbiddenNullArgs[Idx];
     if (!EvaluateCallArg(PVD, Args[Idx], Call, Info, NonNull)) {
@@ -6049,8 +6034,8 @@
 
 /// Perform a trivial copy from Param, which is the parameter of a copy or move
 /// constructor or assignment operator.
-static bool handleTrivialCopy(EvalInfo &Info, const ParmVarDecl *Param,
-                              const Expr *E, APValue &Result,
+static bool handleTrivialCopy(EvalInfo &Info, ParmVarDecl const *Param,
+                              Expr const *E, APValue &Result,
                               bool CopyObjectRepresentation) {
   // Find the reference argument.
   CallStackFrame *Frame = Info.CurrentCall;
@@ -6070,10 +6055,10 @@
 
 /// Evaluate a function call.
 static bool HandleFunctionCall(SourceLocation CallLoc,
-                               const FunctionDecl *Callee, const LValue *This,
-                               ArrayRef<const Expr *> Args, CallRef Call,
-                               const Stmt *Body, EvalInfo &Info,
-                               APValue &Result, const LValue *ResultSlot) {
+                               FunctionDecl const *Callee, LValue const *This,
+                               ArrayRef<Expr const *> Args, CallRef Call,
+                               Stmt const *Body, EvalInfo &Info,
+                               APValue &Result, LValue const *ResultSlot) {
   if (!Info.CheckCallLimit(CallLoc))
     return false;
 
@@ -6085,7 +6070,7 @@
   //
   // Skip this for non-union classes with no fields; in that case, the defaulted
   // copy/move does not actually read the object.
-  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee);
+  CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(Callee);
   if (MD && MD->isDefaulted() &&
       (MD->getParent()->isUnion() ||
        (MD->isTrivial() &&
@@ -6099,8 +6084,7 @@
     if (Info.getLangOpts().CPlusPlus20 && MD->isTrivial() &&
         !HandleUnionActiveMemberChange(Info, Args[0], *This))
       return false;
-    if (!handleAssignment(Info, Args[0], *This, MD->getThisType(),
-                          RHSValue))
+    if (!handleAssignment(Info, Args[0], *This, MD->getThisType(), RHSValue))
       return false;
     This->moveInto(Result);
     return true;
@@ -6127,15 +6111,15 @@
 }
 
 /// Evaluate a constructor call.
-static bool HandleConstructorCall(const Expr *E, const LValue &This,
+static bool HandleConstructorCall(Expr const *E, LValue const &This,
                                   CallRef Call,
-                                  const CXXConstructorDecl *Definition,
+                                  CXXConstructorDecl const *Definition,
                                   EvalInfo &Info, APValue &Result) {
   SourceLocation CallLoc = E->getExprLoc();
   if (!Info.CheckCallLimit(CallLoc))
     return false;
 
-  const CXXRecordDecl *RD = Definition->getParent();
+  CXXRecordDecl const *RD = Definition->getParent();
   if (RD->getNumVBases()) {
     Info.FFDiag(CallLoc, diag::note_constexpr_virtual_base) << RD;
     return false;
@@ -6190,11 +6174,12 @@
                        std::distance(RD->field_begin(), RD->field_end()));
     else
       // A union starts with no active member.
-      Result = APValue((const FieldDecl*)nullptr);
+      Result = APValue((FieldDecl const *)nullptr);
   }
 
-  if (RD->isInvalidDecl()) return false;
-  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
+  if (RD->isInvalidDecl())
+    return false;
+  ASTRecordLayout const &Layout = Info.Ctx.getASTRecordLayout(RD);
 
   // A scope for temporaries lifetime-extended by reference members.
   BlockScopeRAII LifetimeExtendedScope(Info);
@@ -6224,7 +6209,7 @@
     }
     ++FieldIt;
   };
-  for (const auto *I : Definition->inits()) {
+  for (auto const *I : Definition->inits()) {
     LValue Subobject = This;
     LValue SubobjectParent = This;
     APValue *Value = &Result;
@@ -6298,7 +6283,7 @@
     // Need to override This for implicit field initializers as in this case
     // This refers to innermost anonymous struct/union containing initializer,
     // not to currently constructed class.
-    const Expr *Init = I->getInit();
+    Expr const *Init = I->getInit();
     if (Init->isValueDependent()) {
       if (!EvaluateDependentExpr(Init, Info))
         return false;
@@ -6340,9 +6325,9 @@
          LifetimeExtendedScope.destroy();
 }
 
-static bool HandleConstructorCall(const Expr *E, const LValue &This,
-                                  ArrayRef<const Expr*> Args,
-                                  const CXXConstructorDecl *Definition,
+static bool HandleConstructorCall(Expr const *E, LValue const &This,
+                                  ArrayRef<Expr const *> Args,
+                                  CXXConstructorDecl const *Definition,
                                   EvalInfo &Info, APValue &Result) {
   CallScopeRAII CallScope(Info);
   CallRef Call = Info.CurrentCall->createCall(Definition);
@@ -6354,7 +6339,7 @@
 }
 
 static bool HandleDestructionImpl(EvalInfo &Info, SourceLocation CallLoc,
-                                  const LValue &This, APValue &Value,
+                                  LValue const &This, APValue &Value,
                                   QualType T) {
   // Objects can only be destroyed while they're within their lifetimes.
   // FIXME: We have no representation for whether an object of type nullptr_t
@@ -6364,7 +6349,7 @@
     APValue Printable;
     This.moveInto(Printable);
     Info.FFDiag(CallLoc, diag::note_constexpr_destroy_out_of_lifetime)
-      << Printable.getAsString(Info.Ctx, Info.Ctx.getLValueReferenceType(T));
+        << Printable.getAsString(Info.Ctx, Info.Ctx.getLValueReferenceType(T));
     return false;
   }
 
@@ -6373,7 +6358,7 @@
   OpaqueValueExpr LocE(CallLoc, Info.Ctx.IntTy, VK_PRValue);
 
   // For arrays, destroy elements right-to-left.
-  if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(T)) {
+  if (ConstantArrayType const *CAT = Info.Ctx.getAsConstantArrayType(T)) {
     uint64_t Size = CAT->getSize().getZExtValue();
     QualType ElemT = CAT->getElementType();
 
@@ -6400,7 +6385,7 @@
     return true;
   }
 
-  const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
+  CXXRecordDecl const *RD = T->getAsCXXRecordDecl();
   if (!RD) {
     if (T.isDestructedType()) {
       Info.FFDiag(CallLoc, diag::note_constexpr_unsupported_destruction) << T;
@@ -6416,7 +6401,7 @@
     return false;
   }
 
-  const CXXDestructorDecl *DD = RD->getDestructor();
+  CXXDestructorDecl const *DD = RD->getDestructor();
   if (!DD && !RD->hasTrivialDestructor()) {
     Info.FFDiag(CallLoc);
     return false;
@@ -6440,8 +6425,8 @@
   if (!Info.CheckCallLimit(CallLoc))
     return false;
 
-  const FunctionDecl *Definition = nullptr;
-  const Stmt *Body = DD->getBody(Definition);
+  FunctionDecl const *Definition = nullptr;
+  Stmt const *Body = DD->getBody(Definition);
 
   if (!CheckConstexprFunction(Info, CallLoc, DD, Definition, Body))
     return false;
@@ -6475,12 +6460,12 @@
   if (RD->isUnion())
     return true;
 
-  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
+  ASTRecordLayout const &Layout = Info.Ctx.getASTRecordLayout(RD);
 
   // We don't have a good way to iterate fields in reverse, so collect all the
   // fields first and then walk them backwards.
-  SmallVector<FieldDecl*, 16> Fields(RD->field_begin(), RD->field_end());
-  for (const FieldDecl *FD : llvm::reverse(Fields)) {
+  SmallVector<FieldDecl *, 16> Fields(RD->field_begin(), RD->field_end());
+  for (FieldDecl const *FD : llvm::reverse(Fields)) {
     if (FD->isUnnamedBitfield())
       continue;
 
@@ -6498,7 +6483,7 @@
     EvalObj.startedDestroyingBases();
 
   // Destroy base classes in reverse order.
-  for (const CXXBaseSpecifier &Base : llvm::reverse(RD->bases())) {
+  for (CXXBaseSpecifier const &Base : llvm::reverse(RD->bases())) {
     --BasesLeft;
 
     QualType BaseType = Base.getType();
@@ -6522,8 +6507,8 @@
 namespace {
 struct DestroyObjectHandler {
   EvalInfo &Info;
-  const Expr *E;
-  const LValue &This;
+  Expr const *E;
+  LValue const &This;
   const AccessKinds AccessKind;
 
   typedef bool result_type;
@@ -6541,12 +6526,12 @@
     return false;
   }
 };
-}
+} // namespace
 
 /// Perform a destructor or pseudo-destructor call on the given object, which
 /// might in general not be a complete object.
-static bool HandleDestruction(EvalInfo &Info, const Expr *E,
-                              const LValue &This, QualType ThisType) {
+static bool HandleDestruction(EvalInfo &Info, Expr const *E, LValue const &This,
+                              QualType ThisType) {
   CompleteObject Obj = findCompleteObject(Info, E, AK_Destroy, This, ThisType);
   DestroyObjectHandler Handler = {Info, E, This, AK_Destroy};
   return Obj && findSubobject(Info, E, Obj, This.Designator, Handler);
@@ -6567,7 +6552,7 @@
 }
 
 /// Perform a call to 'perator new' or to `__builtin_operator_new'.
-static bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E,
+static bool HandleOperatorNewCall(EvalInfo &Info, CallExpr const *E,
                                   LValue &Result) {
   if (Info.checkingPotentialConstantExpression() ||
       Info.SpeculativeEvaluationDepth)
@@ -6637,7 +6622,7 @@
   return false;
 }
 
-static const FunctionDecl *getVirtualOperatorDelete(QualType T) {
+static FunctionDecl const *getVirtualOperatorDelete(QualType T) {
   if (CXXRecordDecl *RD = T->getAsCXXRecordDecl())
     if (CXXDestructorDecl *DD = RD->getDestructor())
       return DD->isVirtual() ? DD->getOperatorDelete() : nullptr;
@@ -6649,8 +6634,8 @@
 ///
 /// On success, returns the heap allocation to deallocate. On failure, produces
 /// a diagnostic and returns None.
-static Optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E,
-                                            const LValue &Pointer,
+static Optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, Expr const *E,
+                                            LValue const &Pointer,
                                             DynAlloc::Kind DeallocKind) {
   auto PointerAsString = [&] {
     return Pointer.toString(Info.Ctx, Info.Ctx.VoidPtrTy);
@@ -6697,7 +6682,7 @@
 }
 
 // Perform a call to 'operator delete' or '__builtin_operator_delete'.
-bool HandleOperatorDeleteCall(EvalInfo &Info, const CallExpr *E) {
+bool HandleOperatorDeleteCall(EvalInfo &Info, CallExpr const *E) {
   if (Info.checkingPotentialConstantExpression() ||
       Info.SpeculativeEvaluationDepth)
     return false;
@@ -6751,8 +6736,8 @@
 
 public:
   BitCastBuffer(CharUnits Width, bool TargetIsLittleEndian)
-      : Bytes(Width.getQuantity()),
-        TargetIsLittleEndian(TargetIsLittleEndian) {}
+      : Bytes(Width.getQuantity()), TargetIsLittleEndian(TargetIsLittleEndian) {
+  }
 
   LLVM_NODISCARD
   bool readObject(CharUnits Offset, CharUnits Width,
@@ -6789,20 +6774,20 @@
 class APValueToBufferConverter {
   EvalInfo &Info;
   BitCastBuffer Buffer;
-  const CastExpr *BCE;
+  CastExpr const *BCE;
 
   APValueToBufferConverter(EvalInfo &Info, CharUnits ObjectWidth,
-                           const CastExpr *BCE)
+                           CastExpr const *BCE)
       : Info(Info),
         Buffer(ObjectWidth, Info.Ctx.getTargetInfo().isLittleEndian()),
         BCE(BCE) {}
 
-  bool visit(const APValue &Val, QualType Ty) {
+  bool visit(APValue const &Val, QualType Ty) {
     return visit(Val, Ty, CharUnits::fromQuantity(0));
   }
 
   // Write out Val with type Ty into Buffer starting at Offset.
-  bool visit(const APValue &Val, QualType Ty, CharUnits Offset) {
+  bool visit(APValue const &Val, QualType Ty, CharUnits Offset) {
     assert((size_t)Offset.getQuantity() <= Buffer.size());
 
     // As a special case, nullptr_t has an indeterminate value.
@@ -6845,14 +6830,14 @@
     llvm_unreachable("Unhandled APValue::ValueKind");
   }
 
-  bool visitRecord(const APValue &Val, QualType Ty, CharUnits Offset) {
-    const RecordDecl *RD = Ty->getAsRecordDecl();
-    const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
+  bool visitRecord(APValue const &Val, QualType Ty, CharUnits Offset) {
+    RecordDecl const *RD = Ty->getAsRecordDecl();
+    ASTRecordLayout const &Layout = Info.Ctx.getASTRecordLayout(RD);
 
     // Visit the base classes.
     if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
       for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) {
-        const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I];
+        CXXBaseSpecifier const &BS = CXXRD->bases_begin()[I];
         CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
 
         if (!visitRecord(Val.getStructBase(I), BS.getType(),
@@ -6885,8 +6870,8 @@
     return true;
   }
 
-  bool visitArray(const APValue &Val, QualType Ty, CharUnits Offset) {
-    const auto *CAT =
+  bool visitArray(APValue const &Val, QualType Ty, CharUnits Offset) {
+    auto const *CAT =
         dyn_cast_or_null<ConstantArrayType>(Ty->getAsArrayTypeUnsafe());
     if (!CAT)
       return false;
@@ -6896,14 +6881,14 @@
     unsigned ArraySize = Val.getArraySize();
     // First, initialize the initialized elements.
     for (unsigned I = 0; I != NumInitializedElts; ++I) {
-      const APValue &SubObj = Val.getArrayInitializedElt(I);
+      APValue const &SubObj = Val.getArrayInitializedElt(I);
       if (!visit(SubObj, CAT->getElementType(), Offset + I * ElemWidth))
         return false;
     }
 
     // Next, initialize the rest of the array using the filler.
     if (Val.hasArrayFiller()) {
-      const APValue &Filler = Val.getArrayFiller();
+      APValue const &Filler = Val.getArrayFiller();
       for (unsigned I = NumInitializedElts; I != ArraySize; ++I) {
         if (!visit(Filler, CAT->getElementType(), Offset + I * ElemWidth))
           return false;
@@ -6913,7 +6898,7 @@
     return true;
   }
 
-  bool visitInt(const APSInt &Val, QualType Ty, CharUnits Offset) {
+  bool visitInt(APSInt const &Val, QualType Ty, CharUnits Offset) {
     APSInt AdjustedVal = Val;
     unsigned Width = AdjustedVal.getBitWidth();
     if (Ty->isBooleanType()) {
@@ -6927,14 +6912,14 @@
     return true;
   }
 
-  bool visitFloat(const APFloat &Val, QualType Ty, CharUnits Offset) {
+  bool visitFloat(APFloat const &Val, QualType Ty, CharUnits Offset) {
     APSInt AsInt(Val.bitcastToAPInt());
     return visitInt(AsInt, Ty, Offset);
   }
 
 public:
-  static Optional<BitCastBuffer> convert(EvalInfo &Info, const APValue &Src,
-                                         const CastExpr *BCE) {
+  static Optional<BitCastBuffer> convert(EvalInfo &Info, APValue const &Src,
+                                         CastExpr const *BCE) {
     CharUnits DstSize = Info.Ctx.getTypeSizeInChars(BCE->getType());
     APValueToBufferConverter Converter(Info, DstSize, BCE);
     if (!Converter.visit(Src, BCE->getSubExpr()->getType()))
@@ -6946,11 +6931,11 @@
 /// Write an BitCastBuffer into an APValue.
 class BufferToAPValueConverter {
   EvalInfo &Info;
-  const BitCastBuffer &Buffer;
-  const CastExpr *BCE;
+  BitCastBuffer const &Buffer;
+  CastExpr const *BCE;
 
-  BufferToAPValueConverter(EvalInfo &Info, const BitCastBuffer &Buffer,
-                           const CastExpr *BCE)
+  BufferToAPValueConverter(EvalInfo &Info, BitCastBuffer const &Buffer,
+                           CastExpr const *BCE)
       : Info(Info), Buffer(Buffer), BCE(BCE) {}
 
   // Emit an unsupported bit_cast type error. Sema refuses to build a bit_cast
@@ -6963,15 +6948,15 @@
     return None;
   }
 
-  llvm::NoneType unrepresentableValue(QualType Ty, const APSInt &Val) {
+  llvm::NoneType unrepresentableValue(QualType Ty, APSInt const &Val) {
     Info.FFDiag(BCE->getBeginLoc(),
                 diag::note_constexpr_bit_cast_unrepresentable_value)
         << Ty << toString(Val, /*Radix=*/10);
     return None;
   }
 
-  Optional<APValue> visit(const BuiltinType *T, CharUnits Offset,
-                          const EnumType *EnumSugar = nullptr) {
+  Optional<APValue> visit(BuiltinType const *T, CharUnits Offset,
+                          EnumType const *EnumSugar = nullptr) {
     if (T->isNullPtrType()) {
       uint64_t NullValue = Info.Ctx.getTargetNullPointerValue(QualType(T, 0));
       return APValue((Expr *)nullptr,
@@ -6985,7 +6970,7 @@
     // is really just `long double` on x86, which is the only fundamental type
     // with padding bytes.
     if (T->isRealFloatingType()) {
-      const llvm::fltSemantics &Semantics =
+      llvm::fltSemantics const &Semantics =
           Info.Ctx.getFloatTypeSemantics(QualType(T, 0));
       unsigned NumBits = llvm::APFloatBase::getSizeInBits(Semantics);
       assert(NumBits % 8 == 0);
@@ -7003,9 +6988,8 @@
           !EnumSugar && (T->isSpecificBuiltinType(BuiltinType::UChar) ||
                          T->isSpecificBuiltinType(BuiltinType::Char_U));
       if (!IsStdByte && !IsUChar) {
-        QualType DisplayType(EnumSugar ? (const Type *)EnumSugar : T, 0);
-        Info.FFDiag(BCE->getExprLoc(),
-                    diag::note_constexpr_bit_cast_indet_dest)
+        QualType DisplayType(EnumSugar ? (Type const *)EnumSugar : T, 0);
+        Info.FFDiag(BCE->getExprLoc(), diag::note_constexpr_bit_cast_indet_dest)
             << DisplayType << Info.Ctx.getLangOpts().CharIsSigned;
         return None;
       }
@@ -7031,7 +7015,7 @@
     }
 
     if (T->isRealFloatingType()) {
-      const llvm::fltSemantics &Semantics =
+      llvm::fltSemantics const &Semantics =
           Info.Ctx.getFloatTypeSemantics(QualType(T, 0));
       return APValue(APFloat(Semantics, Val));
     }
@@ -7039,9 +7023,9 @@
     return unsupportedType(QualType(T, 0));
   }
 
-  Optional<APValue> visit(const RecordType *RTy, CharUnits Offset) {
-    const RecordDecl *RD = RTy->getAsRecordDecl();
-    const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
+  Optional<APValue> visit(RecordType const *RTy, CharUnits Offset) {
+    RecordDecl const *RD = RTy->getAsRecordDecl();
+    ASTRecordLayout const &Layout = Info.Ctx.getASTRecordLayout(RD);
 
     unsigned NumBases = 0;
     if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
@@ -7053,7 +7037,7 @@
     // Visit the base classes.
     if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
       for (size_t I = 0, E = CXXRD->getNumBases(); I != E; ++I) {
-        const CXXBaseSpecifier &BS = CXXRD->bases_begin()[I];
+        CXXBaseSpecifier const &BS = CXXRD->bases_begin()[I];
         CXXRecordDecl *BaseDecl = BS.getType()->getAsCXXRecordDecl();
         if (BaseDecl->isEmpty() ||
             Info.Ctx.getASTRecordLayout(BaseDecl).getNonVirtualSize().isZero())
@@ -7095,18 +7079,18 @@
     return ResultVal;
   }
 
-  Optional<APValue> visit(const EnumType *Ty, CharUnits Offset) {
+  Optional<APValue> visit(EnumType const *Ty, CharUnits Offset) {
     QualType RepresentationType = Ty->getDecl()->getIntegerType();
     assert(!RepresentationType.isNull() &&
            "enum forward decl should be caught by Sema");
-    const auto *AsBuiltin =
+    auto const *AsBuiltin =
         RepresentationType.getCanonicalType()->castAs<BuiltinType>();
     // Recurse into the underlying type. Treat std::byte transparently as
     // unsigned char.
     return visit(AsBuiltin, Offset, /*EnumTy=*/Ty);
   }
 
-  Optional<APValue> visit(const ConstantArrayType *Ty, CharUnits Offset) {
+  Optional<APValue> visit(ConstantArrayType const *Ty, CharUnits Offset) {
     size_t Size = Ty->getSize().getLimitedValue();
     CharUnits ElementWidth = Info.Ctx.getTypeSizeInChars(Ty->getElementType());
 
@@ -7122,7 +7106,7 @@
     return ArrayValue;
   }
 
-  Optional<APValue> visit(const Type *Ty, CharUnits Offset) {
+  Optional<APValue> visit(Type const *Ty, CharUnits Offset) {
     return unsupportedType(QualType(Ty, 0));
   }
 
@@ -7152,7 +7136,7 @@
 public:
   // Pull out a full value of type DstType.
   static Optional<APValue> convert(EvalInfo &Info, BitCastBuffer &Buffer,
-                                   const CastExpr *BCE) {
+                                   CastExpr const *BCE) {
     BufferToAPValueConverter Converter(Info, Buffer, BCE);
     return Converter.visitType(BCE->getType(), CharUnits::fromQuantity(0));
   }
@@ -7160,7 +7144,7 @@
 
 static bool checkBitCastConstexprEligibilityType(SourceLocation Loc,
                                                  QualType Ty, EvalInfo *Info,
-                                                 const ASTContext &Ctx,
+                                                 ASTContext const &Ctx,
                                                  bool CheckingDest) {
   Ty = Ty.getCanonicalType();
 
@@ -7211,8 +7195,8 @@
 }
 
 static bool checkBitCastConstexprEligibility(EvalInfo *Info,
-                                             const ASTContext &Ctx,
-                                             const CastExpr *BCE) {
+                                             ASTContext const &Ctx,
+                                             CastExpr const *BCE) {
   bool DestOK = checkBitCastConstexprEligibilityType(
       BCE->getBeginLoc(), BCE->getType(), Info, Ctx, true);
   bool SourceOK = DestOK && checkBitCastConstexprEligibilityType(
@@ -7223,7 +7207,7 @@
 
 static bool handleLValueToRValueBitCast(EvalInfo &Info, APValue &DestValue,
                                         APValue &SourceValue,
-                                        const CastExpr *BCE) {
+                                        CastExpr const *BCE) {
   assert(CHAR_BIT == 8 && Info.Ctx.getTargetInfo().getCharWidth() == 8 &&
          "no host or target supports non 8-bit chars");
   assert(SourceValue.isLValue() &&
@@ -7257,22 +7241,21 @@
 }
 
 template <class Derived>
-class ExprEvaluatorBase
-  : public ConstStmtVisitor<Derived, bool> {
+class ExprEvaluatorBase : public ConstStmtVisitor<Derived, bool> {
 private:
-  Derived &getDerived() { return static_cast<Derived&>(*this); }
-  bool DerivedSuccess(const APValue &V, const Expr *E) {
+  Derived &getDerived() { return static_cast<Derived &>(*this); }
+  bool DerivedSuccess(APValue const &V, Expr const *E) {
     return getDerived().Success(V, E);
   }
-  bool DerivedZeroInitialization(const Expr *E) {
+  bool DerivedZeroInitialization(Expr const *E) {
     return getDerived().ZeroInitialization(E);
   }
 
   // Check whether a conditional operator with a non-constant condition is a
   // potential constant expression. If neither arm is a potential constant
   // expression, then the conditional operator is not either.
-  template<typename ConditionalOperator>
-  void CheckPotentialConstantConditional(const ConditionalOperator *E) {
+  template <typename ConditionalOperator>
+  void CheckPotentialConstantConditional(ConditionalOperator const *E) {
     assert(Info.checkingPotentialConstantExpression());
 
     // Speculatively evaluate both arms.
@@ -7295,9 +7278,8 @@
     Error(E, diag::note_constexpr_conditional_never_const);
   }
 
-
-  template<typename ConditionalOperator>
-  bool HandleConditionalOperator(const ConditionalOperator *E) {
+  template <typename ConditionalOperator>
+  bool HandleConditionalOperator(ConditionalOperator const *E) {
     bool BoolResult;
     if (!EvaluateAsBooleanCondition(E->getCond(), BoolResult, Info)) {
       if (Info.checkingPotentialConstantExpression() && Info.noteFailure()) {
@@ -7320,11 +7302,11 @@
   typedef ConstStmtVisitor<Derived, bool> StmtVisitorTy;
   typedef ExprEvaluatorBase ExprEvaluatorBaseTy;
 
-  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
+  OptionalDiagnostic CCEDiag(Expr const *E, diag::kind D) {
     return Info.CCEDiag(E, D);
   }
 
-  bool ZeroInitialization(const Expr *E) { return Error(E); }
+  bool ZeroInitialization(Expr const *E) { return Error(E); }
 
 public:
   ExprEvaluatorBase(EvalInfo &Info) : Info(Info) {}
@@ -7333,46 +7315,51 @@
 
   /// Report an evaluation error. This should only be called when an error is
   /// first discovered. When propagating an error, just return false.
-  bool Error(const Expr *E, diag::kind D) {
+  bool Error(Expr const *E, diag::kind D) {
     Info.FFDiag(E, D);
     return false;
   }
-  bool Error(const Expr *E) {
+  bool Error(Expr const *E) {
     return Error(E, diag::note_invalid_subexpr_in_const_expr);
   }
 
-  bool VisitStmt(const Stmt *) {
+  bool VisitStmt(Stmt const *) {
     llvm_unreachable("Expression evaluator should not be called on stmts");
   }
-  bool VisitExpr(const Expr *E) {
-    return Error(E);
-  }
+  bool VisitExpr(Expr const *E) { return Error(E); }
 
-  bool VisitConstantExpr(const ConstantExpr *E) {
+  bool VisitConstantExpr(ConstantExpr const *E) {
     if (E->hasAPValueResult())
       return DerivedSuccess(E->getAPValueResult(), E);
 
     return StmtVisitorTy::Visit(E->getSubExpr());
   }
 
-  bool VisitParenExpr(const ParenExpr *E)
-    { return StmtVisitorTy::Visit(E->getSubExpr()); }
-  bool VisitUnaryExtension(const UnaryOperator *E)
-    { return StmtVisitorTy::Visit(E->getSubExpr()); }
-  bool VisitUnaryPlus(const UnaryOperator *E)
-    { return StmtVisitorTy::Visit(E->getSubExpr()); }
-  bool VisitChooseExpr(const ChooseExpr *E)
-    { return StmtVisitorTy::Visit(E->getChosenSubExpr()); }
-  bool VisitGenericSelectionExpr(const GenericSelectionExpr *E)
-    { return StmtVisitorTy::Visit(E->getResultExpr()); }
-  bool VisitSubstNonTypeTemplateParmExpr(const SubstNonTypeTemplateParmExpr *E)
-    { return StmtVisitorTy::Visit(E->getReplacement()); }
-  bool VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *E) {
+  bool VisitParenExpr(ParenExpr const *E) {
+    return StmtVisitorTy::Visit(E->getSubExpr());
+  }
+  bool VisitUnaryExtension(UnaryOperator const *E) {
+    return StmtVisitorTy::Visit(E->getSubExpr());
+  }
+  bool VisitUnaryPlus(UnaryOperator const *E) {
+    return StmtVisitorTy::Visit(E->getSubExpr());
+  }
+  bool VisitChooseExpr(ChooseExpr const *E) {
+    return StmtVisitorTy::Visit(E->getChosenSubExpr());
+  }
+  bool VisitGenericSelectionExpr(GenericSelectionExpr const *E) {
+    return StmtVisitorTy::Visit(E->getResultExpr());
+  }
+  bool
+  VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr const *E) {
+    return StmtVisitorTy::Visit(E->getReplacement());
+  }
+  bool VisitCXXDefaultArgExpr(CXXDefaultArgExpr const *E) {
     TempVersionRAII RAII(*Info.CurrentCall);
     SourceLocExprScopeGuard Guard(E, Info.CurrentCall->CurSourceLocExprScope);
     return StmtVisitorTy::Visit(E->getExpr());
   }
-  bool VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *E) {
+  bool VisitCXXDefaultInitExpr(CXXDefaultInitExpr const *E) {
     TempVersionRAII RAII(*Info.CurrentCall);
     // The initializer may not have been parsed yet, or might be erroneous.
     if (!E->getExpr())
@@ -7381,31 +7368,31 @@
     return StmtVisitorTy::Visit(E->getExpr());
   }
 
-  bool VisitExprWithCleanups(const ExprWithCleanups *E) {
+  bool VisitExprWithCleanups(ExprWithCleanups const *E) {
     FullExpressionRAII Scope(Info);
     return StmtVisitorTy::Visit(E->getSubExpr()) && Scope.destroy();
   }
 
   // Temporaries are registered when created, so we don't care about
   // CXXBindTemporaryExpr.
-  bool VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E) {
+  bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr const *E) {
     return StmtVisitorTy::Visit(E->getSubExpr());
   }
 
-  bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {
+  bool VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr const *E) {
     CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;
-    return static_cast<Derived*>(this)->VisitCastExpr(E);
+    return static_cast<Derived *>(this)->VisitCastExpr(E);
   }
-  bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {
+  bool VisitCXXDynamicCastExpr(CXXDynamicCastExpr const *E) {
     if (!Info.Ctx.getLangOpts().CPlusPlus20)
       CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;
-    return static_cast<Derived*>(this)->VisitCastExpr(E);
+    return static_cast<Derived *>(this)->VisitCastExpr(E);
   }
-  bool VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *E) {
-    return static_cast<Derived*>(this)->VisitCastExpr(E);
+  bool VisitBuiltinBitCastExpr(BuiltinBitCastExpr const *E) {
+    return static_cast<Derived *>(this)->VisitCastExpr(E);
   }
 
-  bool VisitBinaryOperator(const BinaryOperator *E) {
+  bool VisitBinaryOperator(BinaryOperator const *E) {
     switch (E->getOpcode()) {
     default:
       return Error(E);
@@ -7427,11 +7414,11 @@
     }
   }
 
-  bool VisitCXXRewrittenBinaryOperator(const CXXRewrittenBinaryOperator *E) {
+  bool VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator const *E) {
     return StmtVisitorTy::Visit(E->getSemanticForm());
   }
 
-  bool VisitBinaryConditionalOperator(const BinaryConditionalOperator *E) {
+  bool VisitBinaryConditionalOperator(BinaryConditionalOperator const *E) {
     // Evaluate and cache the common expression. We treat it as a temporary,
     // even though it's not quite the same thing.
     LValue CommonLV;
@@ -7445,14 +7432,14 @@
     return HandleConditionalOperator(E);
   }
 
-  bool VisitConditionalOperator(const ConditionalOperator *E) {
+  bool VisitConditionalOperator(ConditionalOperator const *E) {
     bool IsBcpCall = false;
     // If the condition (ignoring parens) is a __builtin_constant_p call,
     // the result is a constant expression if it can be folded without
     // side-effects. This is an important GNU extension. See GCC PR38377
     // for discussion.
-    if (const CallExpr *CallCE =
-          dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
+    if (CallExpr const *CallCE =
+            dyn_cast<CallExpr>(E->getCond()->IgnoreParenCasts()))
       if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
         IsBcpCall = true;
 
@@ -7472,11 +7459,11 @@
     return true;
   }
 
-  bool VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
+  bool VisitOpaqueValueExpr(OpaqueValueExpr const *E) {
     if (APValue *Value = Info.CurrentCall->getCurrentTemporary(E))
       return DerivedSuccess(*Value, E);
 
-    const Expr *Source = E->getSourceExpr();
+    Expr const *Source = E->getSourceExpr();
     if (!Source)
       return Error(E);
     if (Source == E) { // sanity checking.
@@ -7486,8 +7473,8 @@
     return StmtVisitorTy::Visit(Source);
   }
 
-  bool VisitPseudoObjectExpr(const PseudoObjectExpr *E) {
-    for (const Expr *SemE : E->semantics()) {
+  bool VisitPseudoObjectExpr(PseudoObjectExpr const *E) {
+    for (Expr const *SemE : E->semantics()) {
       if (auto *OVE = dyn_cast<OpaqueValueExpr>(SemE)) {
         // FIXME: We can't handle the case where an OpaqueValueExpr is also the
         // result expression: there could be two different LValues that would
@@ -7517,21 +7504,21 @@
     return true;
   }
 
-  bool VisitCallExpr(const CallExpr *E) {
+  bool VisitCallExpr(CallExpr const *E) {
     APValue Result;
     if (!handleCallExpr(E, Result, nullptr))
       return false;
     return DerivedSuccess(Result, E);
   }
 
-  bool handleCallExpr(const CallExpr *E, APValue &Result,
-                     const LValue *ResultSlot) {
+  bool handleCallExpr(CallExpr const *E, APValue &Result,
+                      LValue const *ResultSlot) {
     CallScopeRAII CallScope(Info);
 
-    const Expr *Callee = E->getCallee()->IgnoreParens();
+    Expr const *Callee = E->getCallee()->IgnoreParens();
     QualType CalleeType = Callee->getType();
 
-    const FunctionDecl *FD = nullptr;
+    FunctionDecl const *FD = nullptr;
     LValue *This = nullptr, ThisVal;
     auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
     bool HasQualifier = false;
@@ -7540,8 +7527,8 @@
 
     // Extract function decl and 'this' pointer from the callee.
     if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) {
-      const CXXMethodDecl *Member = nullptr;
-      if (const MemberExpr *ME = dyn_cast<MemberExpr>(Callee)) {
+      CXXMethodDecl const *Member = nullptr;
+      if (MemberExpr const *ME = dyn_cast<MemberExpr>(Callee)) {
         // Explicit bound member calls, such as x.f() or p->g();
         if (!EvaluateObjectArgument(Info, ME->getBase(), ThisVal))
           return false;
@@ -7550,9 +7537,9 @@
           return Error(Callee);
         This = &ThisVal;
         HasQualifier = ME->hasQualifier();
-      } else if (const BinaryOperator *BE = dyn_cast<BinaryOperator>(Callee)) {
+      } else if (BinaryOperator const *BE = dyn_cast<BinaryOperator>(Callee)) {
         // Indirect bound member calls ('.*' or '->*').
-        const ValueDecl *D =
+        ValueDecl const *D =
             HandleMemberPointerAccess(Info, BE, ThisVal, false);
         if (!D)
           return false;
@@ -7560,7 +7547,7 @@
         if (!Member)
           return Error(Callee);
         This = &ThisVal;
-      } else if (const auto *PDE = dyn_cast<CXXPseudoDestructorExpr>(Callee)) {
+      } else if (auto const *PDE = dyn_cast<CXXPseudoDestructorExpr>(Callee)) {
         if (!Info.getLangOpts().CPlusPlus20)
           Info.CCEDiag(PDE, diag::note_constexpr_pseudo_destructor);
         return EvaluateObjectArgument(Info, PDE->getBase(), ThisVal) &&
@@ -7576,13 +7563,13 @@
       if (!CalleeLV.getLValueOffset().isZero())
         return Error(Callee);
       FD = dyn_cast_or_null<FunctionDecl>(
-          CalleeLV.getLValueBase().dyn_cast<const ValueDecl *>());
+          CalleeLV.getLValueBase().dyn_cast<ValueDecl const *>());
       if (!FD)
         return Error(Callee);
       // Don't call function pointers which have been cast to some other type.
       // Per DR (no number yet), the caller and callee can differ in noexcept.
       if (!Info.Ctx.hasSameFunctionTypeIgnoringExceptionSpec(
-        CalleeType->getPointeeType(), FD->getType())) {
+              CalleeType->getPointeeType(), FD->getType())) {
         return Error(E);
       }
 
@@ -7599,7 +7586,7 @@
 
       // Overloaded operator calls to member functions are represented as normal
       // calls with '*this' as the first argument.
-      const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
+      CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(FD);
       if (MD && !MD->isStatic()) {
         // FIXME: When selecting an implicit conversion for an overloaded
         // operator delete, we sometimes try to evaluate calls to conversion
@@ -7616,12 +7603,12 @@
         // Conveniently, we don't have to slice out the 'this' argument (as is
         // being done for the non-static case), since a static member function
         // doesn't have an implicit argument passed in.
-        const CXXRecordDecl *ClosureClass = MD->getParent();
+        CXXRecordDecl const *ClosureClass = MD->getParent();
         assert(
             ClosureClass->captures_begin() == ClosureClass->captures_end() &&
             "Number of captures must be zero for conversion to function-ptr");
 
-        const CXXMethodDecl *LambdaCallOp =
+        CXXMethodDecl const *LambdaCallOp =
             ClosureClass->getLambdaCallOperator();
 
         // Set 'FD', the function that will be called below, to the call
@@ -7632,7 +7619,7 @@
           assert(MD->isFunctionTemplateSpecialization() &&
                  "A generic lambda's static-invoker function must be a "
                  "template specialization");
-          const TemplateArgumentList *TAL = MD->getTemplateSpecializationArgs();
+          TemplateArgumentList const *TAL = MD->getTemplateSpecializationArgs();
           FunctionTemplateDecl *CallOpTemplate =
               LambdaCallOp->getDescribedFunctionTemplate();
           void *InsertPos = nullptr;
@@ -7692,12 +7679,12 @@
              CallScope.destroy();
     }
 
-    const FunctionDecl *Definition = nullptr;
+    FunctionDecl const *Definition = nullptr;
     Stmt *Body = FD->getBody(Definition);
 
     if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body) ||
-        !HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Call,
-                            Body, Info, Result, ResultSlot))
+        !HandleFunctionCall(E->getExprLoc(), Definition, This, Args, Call, Body,
+                            Info, Result, ResultSlot))
       return false;
 
     if (!CovariantAdjustmentPath.empty() &&
@@ -7708,28 +7695,28 @@
     return CallScope.destroy();
   }
 
-  bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
+  bool VisitCompoundLiteralExpr(CompoundLiteralExpr const *E) {
     return StmtVisitorTy::Visit(E->getInitializer());
   }
-  bool VisitInitListExpr(const InitListExpr *E) {
+  bool VisitInitListExpr(InitListExpr const *E) {
     if (E->getNumInits() == 0)
       return DerivedZeroInitialization(E);
     if (E->getNumInits() == 1)
       return StmtVisitorTy::Visit(E->getInit(0));
     return Error(E);
   }
-  bool VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
+  bool VisitImplicitValueInitExpr(ImplicitValueInitExpr const *E) {
     return DerivedZeroInitialization(E);
   }
-  bool VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
+  bool VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr const *E) {
     return DerivedZeroInitialization(E);
   }
-  bool VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
+  bool VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr const *E) {
     return DerivedZeroInitialization(E);
   }
 
   /// A member expression where the object is a prvalue is itself a prvalue.
-  bool VisitMemberExpr(const MemberExpr *E) {
+  bool VisitMemberExpr(MemberExpr const *E) {
     assert(!Info.Ctx.getLangOpts().CPlusPlus11 &&
            "missing temporary materialization conversion");
     assert(!E->isArrow() && "missing call to bound member function?");
@@ -7740,11 +7727,13 @@
 
     QualType BaseTy = E->getBase()->getType();
 
-    const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
-    if (!FD) return Error(E);
+    FieldDecl const *FD = dyn_cast<FieldDecl>(E->getMemberDecl());
+    if (!FD)
+      return Error(E);
     assert(!FD->getType()->isReferenceType() && "prvalue reference?");
     assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() ==
-           FD->getParent()->getCanonicalDecl() && "record / field mismatch");
+               FD->getParent()->getCanonicalDecl() &&
+           "record / field mismatch");
 
     // Note: there is no lvalue base here. But this case should only ever
     // happen in C or in C++98, where we cannot be evaluating a constexpr
@@ -7758,7 +7747,7 @@
            DerivedSuccess(Result, E);
   }
 
-  bool VisitExtVectorElementExpr(const ExtVectorElementExpr *E) {
+  bool VisitExtVectorElementExpr(ExtVectorElementExpr const *E) {
     APValue Val;
     if (!Evaluate(Val, Info, E->getBase()))
       return false;
@@ -7783,7 +7772,7 @@
     return false;
   }
 
-  bool VisitCastExpr(const CastExpr *E) {
+  bool VisitCastExpr(CastExpr const *E) {
     switch (E->getCastKind()) {
     default:
       break;
@@ -7833,13 +7822,13 @@
     return Error(E);
   }
 
-  bool VisitUnaryPostInc(const UnaryOperator *UO) {
+  bool VisitUnaryPostInc(UnaryOperator const *UO) {
     return VisitUnaryPostIncDec(UO);
   }
-  bool VisitUnaryPostDec(const UnaryOperator *UO) {
+  bool VisitUnaryPostDec(UnaryOperator const *UO) {
     return VisitUnaryPostIncDec(UO);
   }
-  bool VisitUnaryPostIncDec(const UnaryOperator *UO) {
+  bool VisitUnaryPostIncDec(UnaryOperator const *UO) {
     if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
       return Error(UO);
 
@@ -7853,13 +7842,13 @@
     return DerivedSuccess(RVal, UO);
   }
 
-  bool VisitStmtExpr(const StmtExpr *E) {
+  bool VisitStmtExpr(StmtExpr const *E) {
     // We will have checked the full-expressions inside the statement expression
     // when they were completed, and don't need to check them again now.
     llvm::SaveAndRestore<bool> NotCheckingForUB(
         Info.CheckingForUndefinedBehavior, false);
 
-    const CompoundStmt *CS = E->getSubStmt();
+    CompoundStmt const *CS = E->getSubStmt();
     if (CS->body_empty())
       return true;
 
@@ -7868,7 +7857,7 @@
                                            BE = CS->body_end();
          /**/; ++BI) {
       if (BI + 1 == BE) {
-        const Expr *FinalExpr = dyn_cast<Expr>(*BI);
+        Expr const *FinalExpr = dyn_cast<Expr>(*BI);
         if (!FinalExpr) {
           Info.FFDiag((*BI)->getBeginLoc(),
                       diag::note_constexpr_stmt_expr_unsupported);
@@ -7878,7 +7867,7 @@
       }
 
       APValue ReturnValue;
-      StmtResult Result = { ReturnValue, nullptr };
+      StmtResult Result = {ReturnValue, nullptr};
       EvalStmtResult ESR = EvaluateStmt(Result, Info, *BI);
       if (ESR != ESR_Succeeded) {
         // FIXME: If the statement-expression terminated due to 'return',
@@ -7895,12 +7884,10 @@
   }
 
   /// Visit a value which is evaluated, but whose value is ignored.
-  void VisitIgnoredValue(const Expr *E) {
-    EvaluateIgnoredValue(Info, E);
-  }
+  void VisitIgnoredValue(Expr const *E) { EvaluateIgnoredValue(Info, E); }
 
   /// Potentially visit a MemberExpr's base expression.
-  void VisitIgnoredBaseExpression(const Expr *E) {
+  void VisitIgnoredBaseExpression(Expr const *E) {
     // While MSVC doesn't evaluate the base expression, it does diagnose the
     // presence of side-effecting behavior.
     if (Info.getLangOpts().MSVCCompat && !E->HasSideEffects(Info.Ctx))
@@ -7915,9 +7902,8 @@
 // Common base class for lvalue and temporary evaluation.
 //===----------------------------------------------------------------------===//
 namespace {
-template<class Derived>
-class LValueExprEvaluatorBase
-  : public ExprEvaluatorBase<Derived> {
+template <class Derived>
+class LValueExprEvaluatorBase : public ExprEvaluatorBase<Derived> {
 protected:
   LValue &Result;
   bool InvalidBaseOK;
@@ -7929,7 +7915,7 @@
     return true;
   }
 
-  bool evaluatePointer(const Expr *E, LValue &Result) {
+  bool evaluatePointer(Expr const *E, LValue &Result) {
     return EvaluatePointer(E, Result, this->Info, InvalidBaseOK);
   }
 
@@ -7938,12 +7924,12 @@
       : ExprEvaluatorBaseTy(Info), Result(Result),
         InvalidBaseOK(InvalidBaseOK) {}
 
-  bool Success(const APValue &V, const Expr *E) {
+  bool Success(APValue const &V, Expr const *E) {
     Result.setFrom(this->Info.Ctx, V);
     return true;
   }
 
-  bool VisitMemberExpr(const MemberExpr *E) {
+  bool VisitMemberExpr(MemberExpr const *E) {
     // Handle non-static data members.
     QualType BaseTy;
     bool EvalOK;
@@ -7965,14 +7951,15 @@
       return true;
     }
 
-    const ValueDecl *MD = E->getMemberDecl();
-    if (const FieldDecl *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
+    ValueDecl const *MD = E->getMemberDecl();
+    if (FieldDecl const *FD = dyn_cast<FieldDecl>(E->getMemberDecl())) {
       assert(BaseTy->castAs<RecordType>()->getDecl()->getCanonicalDecl() ==
-             FD->getParent()->getCanonicalDecl() && "record / field mismatch");
+                 FD->getParent()->getCanonicalDecl() &&
+             "record / field mismatch");
       (void)BaseTy;
       if (!HandleLValueMember(this->Info, E, Result, FD))
         return false;
-    } else if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(MD)) {
+    } else if (IndirectFieldDecl const *IFD = dyn_cast<IndirectFieldDecl>(MD)) {
       if (!HandleLValueIndirectMember(this->Info, E, Result, IFD))
         return false;
     } else
@@ -7988,7 +7975,7 @@
     return true;
   }
 
-  bool VisitBinaryOperator(const BinaryOperator *E) {
+  bool VisitBinaryOperator(BinaryOperator const *E) {
     switch (E->getOpcode()) {
     default:
       return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
@@ -7999,7 +7986,7 @@
     }
   }
 
-  bool VisitCastExpr(const CastExpr *E) {
+  bool VisitCastExpr(CastExpr const *E) {
     switch (E->getCastKind()) {
     default:
       return ExprEvaluatorBaseTy::VisitCastExpr(E);
@@ -8016,7 +8003,7 @@
     }
   }
 };
-}
+} // namespace
 
 //===----------------------------------------------------------------------===//
 // LValue Evaluation
@@ -8053,37 +8040,37 @@
 //===----------------------------------------------------------------------===//
 namespace {
 class LValueExprEvaluator
-  : public LValueExprEvaluatorBase<LValueExprEvaluator> {
+    : public LValueExprEvaluatorBase<LValueExprEvaluator> {
 public:
-  LValueExprEvaluator(EvalInfo &Info, LValue &Result, bool InvalidBaseOK) :
-    LValueExprEvaluatorBaseTy(Info, Result, InvalidBaseOK) {}
-
-  bool VisitVarDecl(const Expr *E, const VarDecl *VD);
-  bool VisitUnaryPreIncDec(const UnaryOperator *UO);
-
-  bool VisitDeclRefExpr(const DeclRefExpr *E);
-  bool VisitPredefinedExpr(const PredefinedExpr *E) { return Success(E); }
-  bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
-  bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
-  bool VisitMemberExpr(const MemberExpr *E);
-  bool VisitStringLiteral(const StringLiteral *E) { return Success(E); }
-  bool VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { return Success(E); }
-  bool VisitCXXTypeidExpr(const CXXTypeidExpr *E);
-  bool VisitCXXUuidofExpr(const CXXUuidofExpr *E);
-  bool VisitArraySubscriptExpr(const ArraySubscriptExpr *E);
-  bool VisitUnaryDeref(const UnaryOperator *E);
-  bool VisitUnaryReal(const UnaryOperator *E);
-  bool VisitUnaryImag(const UnaryOperator *E);
-  bool VisitUnaryPreInc(const UnaryOperator *UO) {
+  LValueExprEvaluator(EvalInfo &Info, LValue &Result, bool InvalidBaseOK)
+      : LValueExprEvaluatorBaseTy(Info, Result, InvalidBaseOK) {}
+
+  bool VisitVarDecl(Expr const *E, VarDecl const *VD);
+  bool VisitUnaryPreIncDec(UnaryOperator const *UO);
+
+  bool VisitDeclRefExpr(DeclRefExpr const *E);
+  bool VisitPredefinedExpr(PredefinedExpr const *E) { return Success(E); }
+  bool VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr const *E);
+  bool VisitCompoundLiteralExpr(CompoundLiteralExpr const *E);
+  bool VisitMemberExpr(MemberExpr const *E);
+  bool VisitStringLiteral(StringLiteral const *E) { return Success(E); }
+  bool VisitObjCEncodeExpr(ObjCEncodeExpr const *E) { return Success(E); }
+  bool VisitCXXTypeidExpr(CXXTypeidExpr const *E);
+  bool VisitCXXUuidofExpr(CXXUuidofExpr const *E);
+  bool VisitArraySubscriptExpr(ArraySubscriptExpr const *E);
+  bool VisitUnaryDeref(UnaryOperator const *E);
+  bool VisitUnaryReal(UnaryOperator const *E);
+  bool VisitUnaryImag(UnaryOperator const *E);
+  bool VisitUnaryPreInc(UnaryOperator const *UO) {
     return VisitUnaryPreIncDec(UO);
   }
-  bool VisitUnaryPreDec(const UnaryOperator *UO) {
+  bool VisitUnaryPreDec(UnaryOperator const *UO) {
     return VisitUnaryPreIncDec(UO);
   }
-  bool VisitBinAssign(const BinaryOperator *BO);
-  bool VisitCompoundAssignOperator(const CompoundAssignOperator *CAO);
+  bool VisitBinAssign(BinaryOperator const *BO);
+  bool VisitCompoundAssignOperator(CompoundAssignOperator const *CAO);
 
-  bool VisitCastExpr(const CastExpr *E) {
+  bool VisitCastExpr(CastExpr const *E) {
     switch (E->getCastKind()) {
     default:
       return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
@@ -8114,7 +8101,7 @@
 ///  * function designators in C, and
 ///  * "extern void" objects
 ///  * @selector() expressions in Objective-C
-static bool EvaluateLValue(const Expr *E, LValue &Result, EvalInfo &Info,
+static bool EvaluateLValue(Expr const *E, LValue &Result, EvalInfo &Info,
                            bool InvalidBaseOK) {
   assert(!E->isValueDependent());
   assert(E->isGLValue() || E->getType()->isFunctionType() ||
@@ -8122,19 +8109,18 @@
   return LValueExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
 }
 
-bool LValueExprEvaluator::VisitDeclRefExpr(const DeclRefExpr *E) {
-  const NamedDecl *D = E->getDecl();
+bool LValueExprEvaluator::VisitDeclRefExpr(DeclRefExpr const *E) {
+  NamedDecl const *D = E->getDecl();
   if (isa<FunctionDecl, MSGuidDecl, TemplateParamObjectDecl>(D))
     return Success(cast<ValueDecl>(D));
-  if (const VarDecl *VD = dyn_cast<VarDecl>(D))
+  if (VarDecl const *VD = dyn_cast<VarDecl>(D))
     return VisitVarDecl(E, VD);
-  if (const BindingDecl *BD = dyn_cast<BindingDecl>(D))
+  if (BindingDecl const *BD = dyn_cast<BindingDecl>(D))
     return Visit(BD->getBinding());
   return Error(E);
 }
 
-
-bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
+bool LValueExprEvaluator::VisitVarDecl(Expr const *E, VarDecl const *VD) {
 
   // If we are within a lambda's call operator, check whether the 'VD' referred
   // to within 'E' actually represents a lambda-capture that maps to a
@@ -8226,11 +8212,11 @@
 }
 
 bool LValueExprEvaluator::VisitMaterializeTemporaryExpr(
-    const MaterializeTemporaryExpr *E) {
+    MaterializeTemporaryExpr const *E) {
   // Walk through the expression to find the materialized temporary itself.
-  SmallVector<const Expr *, 2> CommaLHSs;
+  SmallVector<Expr const *, 2> CommaLHSs;
   SmallVector<SubobjectAdjustment, 2> Adjustments;
-  const Expr *Inner =
+  Expr const *Inner =
       E->getSubExpr()->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments);
 
   // If we passed any comma operators, evaluate their LHSs.
@@ -8292,8 +8278,8 @@
   return true;
 }
 
-bool
-LValueExprEvaluator::VisitCompoundLiteralExpr(const CompoundLiteralExpr *E) {
+bool LValueExprEvaluator::VisitCompoundLiteralExpr(
+    CompoundLiteralExpr const *E) {
   assert((!Info.getLangOpts().CPlusPlus || E->isFileScope()) &&
          "lvalue compound literal in c++?");
   // Defer visiting the literal until the lvalue-to-rvalue conversion. We can
@@ -8301,7 +8287,7 @@
   return Success(E);
 }
 
-bool LValueExprEvaluator::VisitCXXTypeidExpr(const CXXTypeidExpr *E) {
+bool LValueExprEvaluator::VisitCXXTypeidExpr(CXXTypeidExpr const *E) {
   TypeInfoLValue TypeInfo;
 
   if (!E->isPotentiallyEvaluated()) {
@@ -8312,8 +8298,8 @@
   } else {
     if (!Info.Ctx.getLangOpts().CPlusPlus20) {
       Info.CCEDiag(E, diag::note_constexpr_typeid_polymorphic)
-        << E->getExprOperand()->getType()
-        << E->getExprOperand()->getSourceRange();
+          << E->getExprOperand()->getType()
+          << E->getExprOperand()->getSourceRange();
     }
 
     if (!Visit(E->getExprOperand()))
@@ -8331,19 +8317,19 @@
   return Success(APValue::LValueBase::getTypeInfo(TypeInfo, E->getType()));
 }
 
-bool LValueExprEvaluator::VisitCXXUuidofExpr(const CXXUuidofExpr *E) {
+bool LValueExprEvaluator::VisitCXXUuidofExpr(CXXUuidofExpr const *E) {
   return Success(E->getGuidDecl());
 }
 
-bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
+bool LValueExprEvaluator::VisitMemberExpr(MemberExpr const *E) {
   // Handle static data members.
-  if (const VarDecl *VD = dyn_cast<VarDecl>(E->getMemberDecl())) {
+  if (VarDecl const *VD = dyn_cast<VarDecl>(E->getMemberDecl())) {
     VisitIgnoredBaseExpression(E->getBase());
     return VisitVarDecl(E, VD);
   }
 
   // Handle static member functions.
-  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) {
+  if (CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl())) {
     if (MD->isStatic()) {
       VisitIgnoredBaseExpression(E->getBase());
       return Success(MD);
@@ -8354,7 +8340,7 @@
   return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
 }
 
-bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
+bool LValueExprEvaluator::VisitArraySubscriptExpr(ArraySubscriptExpr const *E) {
   // FIXME: Deal with vectors as array subscript bases.
   if (E->getBase()->getType()->isVectorType())
     return Error(E);
@@ -8364,7 +8350,7 @@
 
   // C++17's rules require us to evaluate the LHS first, regardless of which
   // side is the base.
-  for (const Expr *SubExpr : {E->getLHS(), E->getRHS()}) {
+  for (Expr const *SubExpr : {E->getLHS(), E->getRHS()}) {
     if (SubExpr == E->getBase() ? !evaluatePointer(SubExpr, Result)
                                 : !EvaluateInteger(SubExpr, Index, Info)) {
       if (!Info.noteFailure())
@@ -8377,11 +8363,11 @@
          HandleLValueArrayAdjustment(Info, E, Result, E->getType(), Index);
 }
 
-bool LValueExprEvaluator::VisitUnaryDeref(const UnaryOperator *E) {
+bool LValueExprEvaluator::VisitUnaryDeref(UnaryOperator const *E) {
   return evaluatePointer(E->getSubExpr(), Result);
 }
 
-bool LValueExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
+bool LValueExprEvaluator::VisitUnaryReal(UnaryOperator const *E) {
   if (!Visit(E->getSubExpr()))
     return false;
   // __real is a no-op on scalar lvalues.
@@ -8390,7 +8376,7 @@
   return true;
 }
 
-bool LValueExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
+bool LValueExprEvaluator::VisitUnaryImag(UnaryOperator const *E) {
   assert(E->getSubExpr()->getType()->isAnyComplexType() &&
          "lvalue __imag__ on scalar?");
   if (!Visit(E->getSubExpr()))
@@ -8399,20 +8385,19 @@
   return true;
 }
 
-bool LValueExprEvaluator::VisitUnaryPreIncDec(const UnaryOperator *UO) {
+bool LValueExprEvaluator::VisitUnaryPreIncDec(UnaryOperator const *UO) {
   if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
     return Error(UO);
 
   if (!this->Visit(UO->getSubExpr()))
     return false;
 
-  return handleIncDec(
-      this->Info, UO, Result, UO->getSubExpr()->getType(),
-      UO->isIncrementOp(), nullptr);
+  return handleIncDec(this->Info, UO, Result, UO->getSubExpr()->getType(),
+                      UO->isIncrementOp(), nullptr);
 }
 
 bool LValueExprEvaluator::VisitCompoundAssignOperator(
-    const CompoundAssignOperator *CAO) {
+    CompoundAssignOperator const *CAO) {
   if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
     return Error(CAO);
 
@@ -8431,12 +8416,12 @@
     return false;
 
   return handleCompoundAssignment(
-      this->Info, CAO,
-      Result, CAO->getLHS()->getType(), CAO->getComputationLHSType(),
+      this->Info, CAO, Result, CAO->getLHS()->getType(),
+      CAO->getComputationLHSType(),
       CAO->getOpForCompoundAssignment(CAO->getOpcode()), RHS);
 }
 
-bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) {
+bool LValueExprEvaluator::VisitBinAssign(BinaryOperator const *E) {
   if (!Info.getLangOpts().CPlusPlus14 && !Info.keepEvaluatingAfterFailure())
     return Error(E);
 
@@ -8471,10 +8456,10 @@
 ///
 /// This expects the given CallExpr to be a call to a function with an
 /// alloc_size attribute.
-static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx,
-                                            const CallExpr *Call,
+static bool getBytesReturnedByAllocSizeCall(ASTContext const &Ctx,
+                                            CallExpr const *Call,
                                             llvm::APInt &Result) {
-  const AllocSizeAttr *AllocSize = getAllocSizeAttr(Call);
+  AllocSizeAttr const *AllocSize = getAllocSizeAttr(Call);
 
   assert(AllocSize && AllocSize->getElemSizeParam().isValid());
   unsigned SizeArgNo = AllocSize->getElemSizeParam().getASTIndex();
@@ -8482,7 +8467,7 @@
   if (Call->getNumArgs() <= SizeArgNo)
     return false;
 
-  auto EvaluateAsSizeT = [&](const Expr *E, APSInt &Into) {
+  auto EvaluateAsSizeT = [&](Expr const *E, APSInt &Into) {
     Expr::EvalResult ExprResult;
     if (!E->EvaluateAsInt(ExprResult, Ctx, Expr::SE_AllowSideEffects))
       return false;
@@ -8518,13 +8503,13 @@
 
 /// Convenience function. LVal's base must be a call to an alloc_size
 /// function.
-static bool getBytesReturnedByAllocSizeCall(const ASTContext &Ctx,
-                                            const LValue &LVal,
+static bool getBytesReturnedByAllocSizeCall(ASTContext const &Ctx,
+                                            LValue const &LVal,
                                             llvm::APInt &Result) {
   assert(isBaseAnAllocSizeCall(LVal.getLValueBase()) &&
          "Can't get the size of a non alloc_size function");
-  const auto *Base = LVal.getLValueBase().get<const Expr *>();
-  const CallExpr *CE = tryUnwrapAllocSizeCall(Base);
+  auto const *Base = LVal.getLValueBase().get<Expr const *>();
+  CallExpr const *CE = tryUnwrapAllocSizeCall(Base);
   return getBytesReturnedByAllocSizeCall(Ctx, CE, Result);
 }
 
@@ -8542,16 +8527,16 @@
   // Additionally, we can't support parameters, nor can we support static
   // variables (in the latter case, use-before-assign isn't UB; in the former,
   // we have no clue what they'll be assigned to).
-  const auto *VD =
-      dyn_cast_or_null<VarDecl>(Base.dyn_cast<const ValueDecl *>());
+  auto const *VD =
+      dyn_cast_or_null<VarDecl>(Base.dyn_cast<ValueDecl const *>());
   if (!VD || !VD->isLocalVarDecl() || !VD->getType().isConstQualified())
     return false;
 
-  const Expr *Init = VD->getAnyInitializer();
+  Expr const *Init = VD->getAnyInitializer();
   if (!Init)
     return false;
 
-  const Expr *E = Init->IgnoreParens();
+  Expr const *E = Init->IgnoreParens();
   if (!tryUnwrapAllocSizeCall(E))
     return false;
 
@@ -8565,62 +8550,59 @@
 }
 
 namespace {
-class PointerExprEvaluator
-  : public ExprEvaluatorBase<PointerExprEvaluator> {
+class PointerExprEvaluator : public ExprEvaluatorBase<PointerExprEvaluator> {
   LValue &Result;
   bool InvalidBaseOK;
 
-  bool Success(const Expr *E) {
+  bool Success(Expr const *E) {
     Result.set(E);
     return true;
   }
 
-  bool evaluateLValue(const Expr *E, LValue &Result) {
+  bool evaluateLValue(Expr const *E, LValue &Result) {
     return EvaluateLValue(E, Result, Info, InvalidBaseOK);
   }
 
-  bool evaluatePointer(const Expr *E, LValue &Result) {
+  bool evaluatePointer(Expr const *E, LValue &Result) {
     return EvaluatePointer(E, Result, Info, InvalidBaseOK);
   }
 
-  bool visitNonBuiltinCallExpr(const CallExpr *E);
-public:
+  bool visitNonBuiltinCallExpr(CallExpr const *E);
 
+public:
   PointerExprEvaluator(EvalInfo &info, LValue &Result, bool InvalidBaseOK)
       : ExprEvaluatorBaseTy(info), Result(Result),
         InvalidBaseOK(InvalidBaseOK) {}
 
-  bool Success(const APValue &V, const Expr *E) {
+  bool Success(APValue const &V, Expr const *E) {
     Result.setFrom(Info.Ctx, V);
     return true;
   }
-  bool ZeroInitialization(const Expr *E) {
+  bool ZeroInitialization(Expr const *E) {
     Result.setNull(Info.Ctx, E->getType());
     return true;
   }
 
-  bool VisitBinaryOperator(const BinaryOperator *E);
-  bool VisitCastExpr(const CastExpr* E);
-  bool VisitUnaryAddrOf(const UnaryOperator *E);
-  bool VisitObjCStringLiteral(const ObjCStringLiteral *E)
-      { return Success(E); }
-  bool VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
+  bool VisitBinaryOperator(BinaryOperator const *E);
+  bool VisitCastExpr(CastExpr const *E);
+  bool VisitUnaryAddrOf(UnaryOperator const *E);
+  bool VisitObjCStringLiteral(ObjCStringLiteral const *E) { return Success(E); }
+  bool VisitObjCBoxedExpr(ObjCBoxedExpr const *E) {
     if (E->isExpressibleAsConstantInitializer())
       return Success(E);
     if (Info.noteFailure())
       EvaluateIgnoredValue(Info, E->getSubExpr());
     return Error(E);
   }
-  bool VisitAddrLabelExpr(const AddrLabelExpr *E)
-      { return Success(E); }
-  bool VisitCallExpr(const CallExpr *E);
-  bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
-  bool VisitBlockExpr(const BlockExpr *E) {
+  bool VisitAddrLabelExpr(AddrLabelExpr const *E) { return Success(E); }
+  bool VisitCallExpr(CallExpr const *E);
+  bool VisitBuiltinCallExpr(CallExpr const *E, unsigned BuiltinOp);
+  bool VisitBlockExpr(BlockExpr const *E) {
     if (!E->getBlockDecl()->hasCaptures())
       return Success(E);
     return Error(E);
   }
-  bool VisitCXXThisExpr(const CXXThisExpr *E) {
+  bool VisitCXXThisExpr(CXXThisExpr const *E) {
     // Can't look at 'this' when checking a potential constant expression.
     if (Info.checkingPotentialConstantExpression())
       return false;
@@ -8645,9 +8627,10 @@
       // Update 'Result' to refer to the data member/field of the closure object
       // that represents the '*this' capture.
       if (!HandleLValueMember(Info, E, Result,
-                             Info.CurrentCall->LambdaThisCaptureField))
+                              Info.CurrentCall->LambdaThisCaptureField))
         return false;
-      // If we captured '*this' by reference, replace the field with its referent.
+      // If we captured '*this' by reference, replace the field with its
+      // referent.
       if (Info.CurrentCall->LambdaThisCaptureField->getType()
               ->isPointerType()) {
         APValue RVal;
@@ -8661,9 +8644,9 @@
     return true;
   }
 
-  bool VisitCXXNewExpr(const CXXNewExpr *E);
+  bool VisitCXXNewExpr(CXXNewExpr const *E);
 
-  bool VisitSourceLocExpr(const SourceLocExpr *E) {
+  bool VisitSourceLocExpr(SourceLocExpr const *E) {
     assert(E->isStringType() && "SourceLocExpr isn't a pointer type?");
     APValue LValResult = E->EvaluateInContext(
         Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr());
@@ -8671,7 +8654,7 @@
     return true;
   }
 
-  bool VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *E) {
+  bool VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr const *E) {
     std::string ResultStr = E->ComputeName(Info.Ctx);
 
     Info.Ctx.SYCLUniqueStableNameEvaluatedValues[E] = ResultStr;
@@ -8695,20 +8678,19 @@
 };
 } // end anonymous namespace
 
-static bool EvaluatePointer(const Expr* E, LValue& Result, EvalInfo &Info,
+static bool EvaluatePointer(Expr const *E, LValue &Result, EvalInfo &Info,
                             bool InvalidBaseOK) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->hasPointerRepresentation());
   return PointerExprEvaluator(Info, Result, InvalidBaseOK).Visit(E);
 }
 
-bool PointerExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
-  if (E->getOpcode() != BO_Add &&
-      E->getOpcode() != BO_Sub)
+bool PointerExprEvaluator::VisitBinaryOperator(BinaryOperator const *E) {
+  if (E->getOpcode() != BO_Add && E->getOpcode() != BO_Sub)
     return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
 
-  const Expr *PExp = E->getLHS();
-  const Expr *IExp = E->getRHS();
+  Expr const *PExp = E->getLHS();
+  Expr const *IExp = E->getRHS();
   if (IExp->getType()->isPointerType())
     std::swap(PExp, IExp);
 
@@ -8727,12 +8709,12 @@
   return HandleLValueArrayAdjustment(Info, E, Result, Pointee, Offset);
 }
 
-bool PointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
+bool PointerExprEvaluator::VisitUnaryAddrOf(UnaryOperator const *E) {
   return evaluateLValue(E->getSubExpr(), Result);
 }
 
-bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
-  const Expr *SubExpr = E->getSubExpr();
+bool PointerExprEvaluator::VisitCastExpr(CastExpr const *E) {
+  Expr const *SubExpr = E->getSubExpr();
 
   switch (E->getCastKind()) {
   default:
@@ -8760,7 +8742,7 @@
         Result.Designator.setInvalid();
         if (SubExpr->getType()->isVoidPointerType())
           CCEDiag(E, diag::note_constexpr_invalid_cast)
-            << 3 << SubExpr->getType();
+              << 3 << SubExpr->getType();
         else
           CCEDiag(E, diag::note_constexpr_invalid_cast) << 2;
       }
@@ -8778,9 +8760,10 @@
 
     // Now figure out the necessary offset to add to the base LV to get from
     // the derived class to the base class.
-    return HandleLValueBasePath(Info, E, E->getSubExpr()->getType()->
-                                  castAs<PointerType>()->getPointeeType(),
-                                Result);
+    return HandleLValueBasePath(
+        Info, E,
+        E->getSubExpr()->getType()->castAs<PointerType>()->getPointeeType(),
+        Result);
 
   case CK_BaseToDerived:
     if (!Visit(E->getSubExpr()))
@@ -8808,7 +8791,7 @@
     if (Value.isInt()) {
       unsigned Size = Info.Ctx.getTypeSize(E->getType());
       uint64_t N = Value.getInt().extOrTrunc(Size).getZExtValue();
-      Result.Base = (Expr*)nullptr;
+      Result.Base = (Expr *)nullptr;
       Result.InvalidBase = false;
       Result.Offset = CharUnits::fromQuantity(N);
       Result.Designator.setInvalid();
@@ -8866,13 +8849,13 @@
   // C++ [expr.alignof]p3:
   //     When alignof is applied to a reference type, the result is the
   //     alignment of the referenced type.
-  if (const ReferenceType *Ref = T->getAs<ReferenceType>())
+  if (ReferenceType const *Ref = T->getAs<ReferenceType>())
     T = Ref->getPointeeType();
 
   if (T.getQualifiers().hasUnaligned())
     return CharUnits::One();
 
-  const bool AlignOfReturnsPreferred =
+  bool const AlignOfReturnsPreferred =
       Info.Ctx.getLangOpts().getClangABICompat() <= LangOptions::ClangABI::Ver7;
 
   // __alignof is defined to return the preferred alignment.
@@ -8880,7 +8863,7 @@
   // as well.
   if (ExprKind == UETT_PreferredAlignOf || AlignOfReturnsPreferred)
     return Info.Ctx.toCharUnitsFromBits(
-      Info.Ctx.getPreferredTypeAlign(T.getTypePtr()));
+        Info.Ctx.getPreferredTypeAlign(T.getTypePtr()));
   // alignof and _Alignof are defined to return the ABI alignment.
   else if (ExprKind == UETT_AlignOf)
     return Info.Ctx.getTypeAlignInChars(T.getTypePtr());
@@ -8888,7 +8871,7 @@
     llvm_unreachable("GetAlignOfType on a non-alignment ExprKind");
 }
 
-static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E,
+static CharUnits GetAlignOfExpr(EvalInfo &Info, Expr const *E,
                                 UnaryExprOrTypeTrait ExprKind) {
   E = E->IgnoreParens();
 
@@ -8898,28 +8881,28 @@
 
   // alignof decl is always accepted, even if it doesn't make sense: we default
   // to 1 in those cases.
-  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
+  if (DeclRefExpr const *DRE = dyn_cast<DeclRefExpr>(E))
     return Info.Ctx.getDeclAlign(DRE->getDecl(),
-                                 /*RefAsPointee*/true);
+                                 /*RefAsPointee*/ true);
 
-  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E))
+  if (MemberExpr const *ME = dyn_cast<MemberExpr>(E))
     return Info.Ctx.getDeclAlign(ME->getMemberDecl(),
-                                 /*RefAsPointee*/true);
+                                 /*RefAsPointee*/ true);
 
   return GetAlignOfType(Info, E->getType(), ExprKind);
 }
 
-static CharUnits getBaseAlignment(EvalInfo &Info, const LValue &Value) {
-  if (const auto *VD = Value.Base.dyn_cast<const ValueDecl *>())
+static CharUnits getBaseAlignment(EvalInfo &Info, LValue const &Value) {
+  if (auto const *VD = Value.Base.dyn_cast<ValueDecl const *>())
     return Info.Ctx.getDeclAlign(VD);
-  if (const auto *E = Value.Base.dyn_cast<const Expr *>())
+  if (auto const *E = Value.Base.dyn_cast<Expr const *>())
     return GetAlignOfExpr(Info, E, UETT_AlignOf);
   return GetAlignOfType(Info, Value.Base.getTypeInfoType(), UETT_AlignOf);
 }
 
 /// Evaluate the value of the alignment argument to __builtin_align_{up,down},
 /// __builtin_is_aligned and __builtin_assume_aligned.
-static bool getAlignmentArgument(const Expr *E, QualType ForType,
+static bool getAlignmentArgument(Expr const *E, QualType ForType,
                                  EvalInfo &Info, APSInt &Alignment) {
   if (!EvaluateInteger(E, Alignment, Info))
     return false;
@@ -8946,7 +8929,7 @@
 }
 
 // To be clear: this happily visits unsupported builtins. Better name welcomed.
-bool PointerExprEvaluator::visitNonBuiltinCallExpr(const CallExpr *E) {
+bool PointerExprEvaluator::visitNonBuiltinCallExpr(CallExpr const *E) {
   if (ExprEvaluatorBaseTy::VisitCallExpr(E))
     return true;
 
@@ -8959,7 +8942,7 @@
   return true;
 }
 
-bool PointerExprEvaluator::VisitCallExpr(const CallExpr *E) {
+bool PointerExprEvaluator::VisitCallExpr(CallExpr const *E) {
   if (IsStringLiteralCall(E))
     return Success(E);
 
@@ -8975,7 +8958,7 @@
   return T->isCharType() || T->isChar8Type();
 }
 
-bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
+bool PointerExprEvaluator::VisitBuiltinCallExpr(CallExpr const *E,
                                                 unsigned BuiltinOp) {
   switch (BuiltinOp) {
   case Builtin::BI__builtin_addressof:
@@ -9010,10 +8993,9 @@
       if (BaseAlignment < Align) {
         Result.Designator.setInvalid();
         // FIXME: Add support to Diagnostic for long / long long.
-        CCEDiag(E->getArg(0),
-                diag::note_constexpr_baa_insufficient_alignment) << 0
-          << (unsigned)BaseAlignment.getQuantity()
-          << (unsigned)Align.getQuantity();
+        CCEDiag(E->getArg(0), diag::note_constexpr_baa_insufficient_alignment)
+            << 0 << (unsigned)BaseAlignment.getQuantity()
+            << (unsigned)Align.getQuantity();
         return false;
       }
     }
@@ -9024,11 +9006,12 @@
 
       (OffsetResult.Base
            ? CCEDiag(E->getArg(0),
-                     diag::note_constexpr_baa_insufficient_alignment) << 1
+                     diag::note_constexpr_baa_insufficient_alignment)
+                 << 1
            : CCEDiag(E->getArg(0),
                      diag::note_constexpr_baa_value_insufficient_alignment))
-        << (int)OffsetResult.Offset.getQuantity()
-        << (unsigned)Align.getQuantity();
+          << (int)OffsetResult.Offset.getQuantity()
+          << (unsigned)Align.getQuantity();
       return false;
     }
 
@@ -9081,8 +9064,8 @@
   case Builtin::BIwmemchr:
     if (Info.getLangOpts().CPlusPlus11)
       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
-        << /*isConstexpr*/0 << /*isConstructor*/0
-        << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
+          << /*isConstexpr*/ 0 << /*isConstructor*/ 0
+          << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
     else
       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
     LLVM_FALLTHROUGH;
@@ -9097,8 +9080,7 @@
     if (!EvaluateInteger(E->getArg(1), Desired, Info))
       return false;
     uint64_t MaxLength = uint64_t(-1);
-    if (BuiltinOp != Builtin::BIstrchr &&
-        BuiltinOp != Builtin::BIwcschr &&
+    if (BuiltinOp != Builtin::BIstrchr && BuiltinOp != Builtin::BIwcschr &&
         BuiltinOp != Builtin::BI__builtin_strchr &&
         BuiltinOp != Builtin::BI__builtin_wcschr) {
       APSInt N;
@@ -9115,9 +9097,8 @@
     QualType CharTy = Result.Designator.getType(Info.Ctx);
     bool IsRawByte = BuiltinOp == Builtin::BImemchr ||
                      BuiltinOp == Builtin::BI__builtin_memchr;
-    assert(IsRawByte ||
-           Info.Ctx.hasSameUnqualifiedType(
-               CharTy, E->getArg(0)->getType()->getPointeeType()));
+    assert(IsRawByte || Info.Ctx.hasSameUnqualifiedType(
+                            CharTy, E->getArg(0)->getType()->getPointeeType()));
     // Pointers to const void may point to objects of incomplete type.
     if (IsRawByte && CharTy->isIncompleteType()) {
       Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy;
@@ -9189,8 +9170,8 @@
   case Builtin::BIwmemmove:
     if (Info.getLangOpts().CPlusPlus11)
       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
-        << /*isConstexpr*/0 << /*isConstructor*/0
-        << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
+          << /*isConstexpr*/ 0 << /*isConstructor*/ 0
+          << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
     else
       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
     LLVM_FALLTHROUGH;
@@ -9267,7 +9248,7 @@
       llvm::APInt::udivrem(OrigN, TSize, N, Remainder);
       if (Remainder) {
         Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported)
-            << Move << WChar << 0 << T << toString(OrigN, 10, /*Signed*/false)
+            << Move << WChar << 0 << T << toString(OrigN, 10, /*Signed*/ false)
             << (unsigned)TSize;
         return false;
       }
@@ -9281,7 +9262,7 @@
     if (N.ugt(RemainingSrcSize) || N.ugt(RemainingDestSize)) {
       Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported)
           << Move << WChar << (N.ugt(RemainingSrcSize) ? 1 : 2) << T
-          << toString(N, 10, /*Signed*/false);
+          << toString(N, 10, /*Signed*/ false);
       return false;
     }
     uint64_t NElems = N.getZExtValue();
@@ -9336,14 +9317,14 @@
 }
 
 static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This,
-                                     APValue &Result, const InitListExpr *ILE,
+                                     APValue &Result, InitListExpr const *ILE,
                                      QualType AllocType);
 static bool EvaluateArrayNewConstructExpr(EvalInfo &Info, LValue &This,
                                           APValue &Result,
-                                          const CXXConstructExpr *CCE,
+                                          CXXConstructExpr const *CCE,
                                           QualType AllocType);
 
-bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {
+bool PointerExprEvaluator::VisitCXXNewExpr(CXXNewExpr const *E) {
   if (!Info.getLangOpts().CPlusPlus20)
     Info.CCEDiag(E, diag::note_constexpr_new);
 
@@ -9389,14 +9370,14 @@
     IsNothrow = true;
   }
 
-  const Expr *Init = E->getInitializer();
-  const InitListExpr *ResizedArrayILE = nullptr;
-  const CXXConstructExpr *ResizedArrayCCE = nullptr;
+  Expr const *Init = E->getInitializer();
+  InitListExpr const *ResizedArrayILE = nullptr;
+  CXXConstructExpr const *ResizedArrayCCE = nullptr;
   bool ValueInit = false;
 
   QualType AllocType = E->getAllocatedType();
-  if (Optional<const Expr*> ArraySize = E->getArraySize()) {
-    const Expr *Stripped = *ArraySize;
+  if (Optional<Expr const *> ArraySize = E->getArraySize()) {
+    Expr const *Stripped = *ArraySize;
     for (; auto *ICE = dyn_cast<ImplicitCastExpr>(Stripped);
          Stripped = ICE->getSubExpr())
       if (ICE->getCastKind() != CK_NoOp &&
@@ -9429,7 +9410,7 @@
         return ZeroInitialization(E);
 
       Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_large)
-        << ArrayBound << (*ArraySize)->getSourceRange();
+          << ArrayBound << (*ArraySize)->getSourceRange();
       return false;
     }
 
@@ -9471,8 +9452,7 @@
     AllocType = Info.Ctx.getConstantArrayType(AllocType, ArrayBound, nullptr,
                                               ArrayType::Normal, 0);
   } else {
-    assert(!AllocType->isArrayType() &&
-           "array allocation with non-array new");
+    assert(!AllocType->isArrayType() && "array allocation with non-array new");
   }
 
   APValue *Val;
@@ -9480,7 +9460,7 @@
     AccessKinds AK = AK_Construct;
     struct FindObjectHandler {
       EvalInfo &Info;
-      const Expr *E;
+      Expr const *E;
       QualType AllocType;
       const AccessKinds AccessKind;
       APValue *Value;
@@ -9491,8 +9471,8 @@
         // FIXME: Reject the cases where [basic.life]p8 would not permit the
         // old name of the object to be used to name the new object.
         if (!Info.Ctx.hasSameUnqualifiedType(SubobjType, AllocType)) {
-          Info.FFDiag(E, diag::note_constexpr_placement_new_wrong_type) <<
-            SubobjType << AllocType;
+          Info.FFDiag(E, diag::note_constexpr_placement_new_wrong_type)
+              << SubobjType << AllocType;
           return false;
         }
         Value = &Subobj;
@@ -9558,39 +9538,39 @@
 
 namespace {
 class MemberPointerExprEvaluator
-  : public ExprEvaluatorBase<MemberPointerExprEvaluator> {
+    : public ExprEvaluatorBase<MemberPointerExprEvaluator> {
   MemberPtr &Result;
 
-  bool Success(const ValueDecl *D) {
+  bool Success(ValueDecl const *D) {
     Result = MemberPtr(D);
     return true;
   }
-public:
 
+public:
   MemberPointerExprEvaluator(EvalInfo &Info, MemberPtr &Result)
-    : ExprEvaluatorBaseTy(Info), Result(Result) {}
+      : ExprEvaluatorBaseTy(Info), Result(Result) {}
 
-  bool Success(const APValue &V, const Expr *E) {
+  bool Success(APValue const &V, Expr const *E) {
     Result.setFrom(V);
     return true;
   }
-  bool ZeroInitialization(const Expr *E) {
-    return Success((const ValueDecl*)nullptr);
+  bool ZeroInitialization(Expr const *E) {
+    return Success((ValueDecl const *)nullptr);
   }
 
-  bool VisitCastExpr(const CastExpr *E);
-  bool VisitUnaryAddrOf(const UnaryOperator *E);
+  bool VisitCastExpr(CastExpr const *E);
+  bool VisitUnaryAddrOf(UnaryOperator const *E);
 };
 } // end anonymous namespace
 
-static bool EvaluateMemberPointer(const Expr *E, MemberPtr &Result,
+static bool EvaluateMemberPointer(Expr const *E, MemberPtr &Result,
                                   EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isMemberPointerType());
   return MemberPointerExprEvaluator(Info, Result).Visit(E);
 }
 
-bool MemberPointerExprEvaluator::VisitCastExpr(const CastExpr *E) {
+bool MemberPointerExprEvaluator::VisitCastExpr(CastExpr const *E) {
   switch (E->getCastKind()) {
   default:
     return ExprEvaluatorBaseTy::VisitCastExpr(E);
@@ -9611,11 +9591,11 @@
     for (ReverseIter PathI(E->path_end() - 1), PathE(E->path_begin());
          PathI != PathE; ++PathI) {
       assert(!(*PathI)->isVirtual() && "memptr cast through vbase");
-      const CXXRecordDecl *Derived = (*PathI)->getType()->getAsCXXRecordDecl();
+      CXXRecordDecl const *Derived = (*PathI)->getType()->getAsCXXRecordDecl();
       if (!Result.castToDerived(Derived))
         return Error(E);
     }
-    const Type *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass();
+    Type const *FinalTy = E->getType()->castAs<MemberPointerType>()->getClass();
     if (!Result.castToDerived(FinalTy->getAsCXXRecordDecl()))
       return Error(E);
     return true;
@@ -9625,9 +9605,10 @@
     if (!Visit(E->getSubExpr()))
       return false;
     for (CastExpr::path_const_iterator PathI = E->path_begin(),
-         PathE = E->path_end(); PathI != PathE; ++PathI) {
+                                       PathE = E->path_end();
+         PathI != PathE; ++PathI) {
       assert(!(*PathI)->isVirtual() && "memptr cast through vbase");
-      const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
+      CXXRecordDecl const *Base = (*PathI)->getType()->getAsCXXRecordDecl();
       if (!Result.castToBase(Base))
         return Error(E);
     }
@@ -9635,7 +9616,7 @@
   }
 }
 
-bool MemberPointerExprEvaluator::VisitUnaryAddrOf(const UnaryOperator *E) {
+bool MemberPointerExprEvaluator::VisitUnaryAddrOf(UnaryOperator const *E) {
   // C++11 [expr.unary.op]p3 has very strict rules on how the address of a
   // member can be formed.
   return Success(cast<DeclRefExpr>(E->getSubExpr())->getDecl());
@@ -9646,39 +9627,38 @@
 //===----------------------------------------------------------------------===//
 
 namespace {
-  class RecordExprEvaluator
-  : public ExprEvaluatorBase<RecordExprEvaluator> {
-    const LValue &This;
-    APValue &Result;
-  public:
+class RecordExprEvaluator : public ExprEvaluatorBase<RecordExprEvaluator> {
+  LValue const &This;
+  APValue &Result;
 
-    RecordExprEvaluator(EvalInfo &info, const LValue &This, APValue &Result)
+public:
+  RecordExprEvaluator(EvalInfo &info, LValue const &This, APValue &Result)
       : ExprEvaluatorBaseTy(info), This(This), Result(Result) {}
 
-    bool Success(const APValue &V, const Expr *E) {
-      Result = V;
-      return true;
-    }
-    bool ZeroInitialization(const Expr *E) {
-      return ZeroInitialization(E, E->getType());
-    }
-    bool ZeroInitialization(const Expr *E, QualType T);
+  bool Success(APValue const &V, Expr const *E) {
+    Result = V;
+    return true;
+  }
+  bool ZeroInitialization(Expr const *E) {
+    return ZeroInitialization(E, E->getType());
+  }
+  bool ZeroInitialization(Expr const *E, QualType T);
 
-    bool VisitCallExpr(const CallExpr *E) {
-      return handleCallExpr(E, Result, &This);
-    }
-    bool VisitCastExpr(const CastExpr *E);
-    bool VisitInitListExpr(const InitListExpr *E);
-    bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
-      return VisitCXXConstructExpr(E, E->getType());
-    }
-    bool VisitLambdaExpr(const LambdaExpr *E);
-    bool VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
-    bool VisitCXXConstructExpr(const CXXConstructExpr *E, QualType T);
-    bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E);
-    bool VisitBinCmp(const BinaryOperator *E);
-  };
-}
+  bool VisitCallExpr(CallExpr const *E) {
+    return handleCallExpr(E, Result, &This);
+  }
+  bool VisitCastExpr(CastExpr const *E);
+  bool VisitInitListExpr(InitListExpr const *E);
+  bool VisitCXXConstructExpr(CXXConstructExpr const *E) {
+    return VisitCXXConstructExpr(E, E->getType());
+  }
+  bool VisitLambdaExpr(LambdaExpr const *E);
+  bool VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr const *E);
+  bool VisitCXXConstructExpr(CXXConstructExpr const *E, QualType T);
+  bool VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr const *E);
+  bool VisitBinCmp(BinaryOperator const *E);
+};
+} // namespace
 
 /// Perform zero-initialization on an object of non-union class type.
 /// C++11 [dcl.init]p5:
@@ -9687,22 +9667,24 @@
 ///    -- if T is a (possibly cv-qualified) non-union class type,
 ///       each non-static data member and each base-class subobject is
 ///       zero-initialized
-static bool HandleClassZeroInitialization(EvalInfo &Info, const Expr *E,
-                                          const RecordDecl *RD,
-                                          const LValue &This, APValue &Result) {
+static bool HandleClassZeroInitialization(EvalInfo &Info, Expr const *E,
+                                          RecordDecl const *RD,
+                                          LValue const &This, APValue &Result) {
   assert(!RD->isUnion() && "Expected non-union class type");
-  const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
+  CXXRecordDecl const *CD = dyn_cast<CXXRecordDecl>(RD);
   Result = APValue(APValue::UninitStruct(), CD ? CD->getNumBases() : 0,
                    std::distance(RD->field_begin(), RD->field_end()));
 
-  if (RD->isInvalidDecl()) return false;
-  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
+  if (RD->isInvalidDecl())
+    return false;
+  ASTRecordLayout const &Layout = Info.Ctx.getASTRecordLayout(RD);
 
   if (CD) {
     unsigned Index = 0;
     for (CXXRecordDecl::base_class_const_iterator I = CD->bases_begin(),
-           End = CD->bases_end(); I != End; ++I, ++Index) {
-      const CXXRecordDecl *Base = I->getType()->getAsCXXRecordDecl();
+                                                  End = CD->bases_end();
+         I != End; ++I, ++Index) {
+      CXXRecordDecl const *Base = I->getType()->getAsCXXRecordDecl();
       LValue Subobject = This;
       if (!HandleLValueDirectBase(Info, E, Subobject, CD, Base, &Layout))
         return false;
@@ -9712,7 +9694,7 @@
     }
   }
 
-  for (const auto *I : RD->fields()) {
+  for (auto const *I : RD->fields()) {
     // -- if T is a reference type, no initialization is performed.
     if (I->isUnnamedBitfield() || I->getType()->isReferenceType())
       continue;
@@ -9722,17 +9704,18 @@
       return false;
 
     ImplicitValueInitExpr VIE(I->getType());
-    if (!EvaluateInPlace(
-          Result.getStructField(I->getFieldIndex()), Info, Subobject, &VIE))
+    if (!EvaluateInPlace(Result.getStructField(I->getFieldIndex()), Info,
+                         Subobject, &VIE))
       return false;
   }
 
   return true;
 }
 
-bool RecordExprEvaluator::ZeroInitialization(const Expr *E, QualType T) {
-  const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
-  if (RD->isInvalidDecl()) return false;
+bool RecordExprEvaluator::ZeroInitialization(Expr const *E, QualType T) {
+  RecordDecl const *RD = T->castAs<RecordType>()->getDecl();
+  if (RD->isInvalidDecl())
+    return false;
   if (RD->isUnion()) {
     // C++11 [dcl.init]p5: If T is a (possibly cv-qualified) union type, the
     // object's first non-static named data member is zero-initialized
@@ -9740,7 +9723,7 @@
     while (I != RD->field_end() && (*I)->isUnnamedBitfield())
       ++I;
     if (I == RD->field_end()) {
-      Result = APValue((const FieldDecl*)nullptr);
+      Result = APValue((FieldDecl const *)nullptr);
       return true;
     }
 
@@ -9760,7 +9743,7 @@
   return HandleClassZeroInitialization(Info, E, RD, This, Result);
 }
 
-bool RecordExprEvaluator::VisitCastExpr(const CastExpr *E) {
+bool RecordExprEvaluator::VisitCastExpr(CastExpr const *E) {
   switch (E->getCastKind()) {
   default:
     return ExprEvaluatorBaseTy::VisitCastExpr(E);
@@ -9778,11 +9761,12 @@
 
     // Derived-to-base rvalue conversion: just slice off the derived part.
     APValue *Value = &DerivedObject;
-    const CXXRecordDecl *RD = E->getSubExpr()->getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *RD = E->getSubExpr()->getType()->getAsCXXRecordDecl();
     for (CastExpr::path_const_iterator PathI = E->path_begin(),
-         PathE = E->path_end(); PathI != PathE; ++PathI) {
+                                       PathE = E->path_end();
+         PathI != PathE; ++PathI) {
       assert(!(*PathI)->isVirtual() && "record rvalue with virtual base");
-      const CXXRecordDecl *Base = (*PathI)->getType()->getAsCXXRecordDecl();
+      CXXRecordDecl const *Base = (*PathI)->getType()->getAsCXXRecordDecl();
       Value = &Value->getStructBase(getBaseIndex(RD, Base));
       RD = Base;
     }
@@ -9792,13 +9776,14 @@
   }
 }
 
-bool RecordExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
+bool RecordExprEvaluator::VisitInitListExpr(InitListExpr const *E) {
   if (E->isTransparent())
     return Visit(E->getInit(0));
 
-  const RecordDecl *RD = E->getType()->castAs<RecordType>()->getDecl();
-  if (RD->isInvalidDecl()) return false;
-  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
+  RecordDecl const *RD = E->getType()->castAs<RecordType>()->getDecl();
+  if (RD->isInvalidDecl())
+    return false;
+  ASTRecordLayout const &Layout = Info.Ctx.getASTRecordLayout(RD);
   auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
 
   EvalInfo::EvaluatingConstructorRAII EvalObj(
@@ -9807,7 +9792,7 @@
       CXXRD && CXXRD->getNumBases());
 
   if (RD->isUnion()) {
-    const FieldDecl *Field = E->getInitializedFieldInUnion();
+    FieldDecl const *Field = E->getInitializedFieldInUnion();
     Result = APValue(Field);
     if (!Field)
       return true;
@@ -9818,7 +9803,7 @@
     //        Is this difference ever observable for initializer lists which
     //        we don't build?
     ImplicitValueInitExpr VIE(Field->getType());
-    const Expr *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE;
+    Expr const *InitExpr = E->getNumInits() ? E->getInit(0) : &VIE;
 
     LValue Subobject = This;
     if (!HandleLValueMember(Info, InitExpr, Subobject, Field, &Layout))
@@ -9846,9 +9831,9 @@
 
   // Initialize base classes.
   if (CXXRD && CXXRD->getNumBases()) {
-    for (const auto &Base : CXXRD->bases()) {
+    for (auto const &Base : CXXRD->bases()) {
       assert(ElementNo < E->getNumInits() && "missing init for base class");
-      const Expr *Init = E->getInit(ElementNo);
+      Expr const *Init = E->getInit(ElementNo);
 
       LValue Subobject = This;
       if (!HandleLValueBase(Info, Init, Subobject, CXXRD, &Base))
@@ -9867,7 +9852,7 @@
   }
 
   // Initialize members.
-  for (const auto *Field : RD->fields()) {
+  for (auto const *Field : RD->fields()) {
     // Anonymous bit-fields are not considered members of the class for
     // purposes of aggregate initialization.
     if (Field->isUnnamedBitfield())
@@ -9886,7 +9871,7 @@
     // Perform an implicit value-initialization for members beyond the end of
     // the initializer list.
     ImplicitValueInitExpr VIE(HaveInit ? Info.Ctx.IntTy : Field->getType());
-    const Expr *Init = HaveInit ? E->getInit(ElementNo++) : &VIE;
+    Expr const *Init = HaveInit ? E->getInit(ElementNo++) : &VIE;
 
     // Temporarily override This, in case there's a CXXDefaultInitExpr in here.
     ThisOverrideRAII ThisOverride(*Info.CurrentCall, &This,
@@ -9894,8 +9879,8 @@
 
     APValue &FieldVal = Result.getStructField(Field->getFieldIndex());
     if (!EvaluateInPlace(FieldVal, Info, Subobject, Init) ||
-        (Field->isBitField() && !truncateBitfieldValue(Info, Init,
-                                                       FieldVal, Field))) {
+        (Field->isBitField() &&
+         !truncateBitfieldValue(Info, Init, FieldVal, Field))) {
       if (!Info.noteFailure())
         return false;
       Success = false;
@@ -9907,12 +9892,13 @@
   return Success;
 }
 
-bool RecordExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
+bool RecordExprEvaluator::VisitCXXConstructExpr(CXXConstructExpr const *E,
                                                 QualType T) {
   // Note that E's type is not necessarily the type of our class here; we might
   // be initializing an array element instead.
-  const CXXConstructorDecl *FD = E->getConstructor();
-  if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl()) return false;
+  CXXConstructorDecl const *FD = E->getConstructor();
+  if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl())
+    return false;
 
   bool ZeroInit = E->requiresZeroInitialization();
   if (CheckTrivialDefaultConstructor(Info, E->getExprLoc(), FD, ZeroInit)) {
@@ -9926,7 +9912,7 @@
     return getDefaultInitValue(T, Result);
   }
 
-  const FunctionDecl *Definition = nullptr;
+  FunctionDecl const *Definition = nullptr;
   auto Body = FD->getBody(Definition);
 
   if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
@@ -9934,31 +9920,30 @@
 
   // Avoid materializing a temporary for an elidable copy/move constructor.
   if (E->isElidable() && !ZeroInit)
-    if (const MaterializeTemporaryExpr *ME
-          = dyn_cast<MaterializeTemporaryExpr>(E->getArg(0)))
+    if (MaterializeTemporaryExpr const *ME =
+            dyn_cast<MaterializeTemporaryExpr>(E->getArg(0)))
       return Visit(ME->getSubExpr());
 
   if (ZeroInit && !ZeroInitialization(E, T))
     return false;
 
   auto Args = llvm::makeArrayRef(E->getArgs(), E->getNumArgs());
-  return HandleConstructorCall(E, This, Args,
-                               cast<CXXConstructorDecl>(Definition), Info,
-                               Result);
+  return HandleConstructorCall(
+      E, This, Args, cast<CXXConstructorDecl>(Definition), Info, Result);
 }
 
 bool RecordExprEvaluator::VisitCXXInheritedCtorInitExpr(
-    const CXXInheritedCtorInitExpr *E) {
+    CXXInheritedCtorInitExpr const *E) {
   if (!Info.CurrentCall) {
     assert(Info.checkingPotentialConstantExpression());
     return false;
   }
 
-  const CXXConstructorDecl *FD = E->getConstructor();
+  CXXConstructorDecl const *FD = E->getConstructor();
   if (FD->isInvalidDecl() || FD->getParent()->isInvalidDecl())
     return false;
 
-  const FunctionDecl *Definition = nullptr;
+  FunctionDecl const *Definition = nullptr;
   auto Body = FD->getBody(Definition);
 
   if (!CheckConstexprFunction(Info, E->getExprLoc(), FD, Definition, Body))
@@ -9970,8 +9955,8 @@
 }
 
 bool RecordExprEvaluator::VisitCXXStdInitializerListExpr(
-    const CXXStdInitializerListExpr *E) {
-  const ConstantArrayType *ArrayType =
+    CXXStdInitializerListExpr const *E) {
+  ConstantArrayType const *ArrayType =
       Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
 
   LValue Array;
@@ -9982,8 +9967,7 @@
   Array.addArray(Info, E, ArrayType);
 
   auto InvalidType = [&] {
-    Info.FFDiag(E, diag::note_constexpr_unsupported_layout)
-      << E->getType();
+    Info.FFDiag(E, diag::note_constexpr_unsupported_layout) << E->getType();
     return false;
   };
 
@@ -10027,8 +10011,8 @@
   return true;
 }
 
-bool RecordExprEvaluator::VisitLambdaExpr(const LambdaExpr *E) {
-  const CXXRecordDecl *ClosureClass = E->getLambdaClass();
+bool RecordExprEvaluator::VisitLambdaExpr(LambdaExpr const *E) {
+  CXXRecordDecl const *ClosureClass = E->getLambdaClass();
   if (ClosureClass->isInvalidDecl())
     return false;
 
@@ -10040,14 +10024,14 @@
          "The number of lambda capture initializers should equal the number of "
          "fields within the closure type");
 
-  Result = APValue(APValue::UninitStruct(), /*NumBases*/0, NumFields);
+  Result = APValue(APValue::UninitStruct(), /*NumBases*/ 0, NumFields);
   // Iterate through all the lambda's closure object's fields and initialize
   // them.
   auto *CaptureInitIt = E->capture_init_begin();
-  const LambdaCapture *CaptureIt = ClosureClass->captures_begin();
+  LambdaCapture const *CaptureIt = ClosureClass->captures_begin();
   bool Success = true;
-  const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(ClosureClass);
-  for (const auto *Field : ClosureClass->fields()) {
+  ASTRecordLayout const &Layout = Info.Ctx.getASTRecordLayout(ClosureClass);
+  for (auto const *Field : ClosureClass->fields()) {
     assert(CaptureInitIt != E->capture_init_end());
     // Get the initializer for this field
     Expr *const CurFieldInit = *CaptureInitIt++;
@@ -10073,8 +10057,8 @@
   return Success;
 }
 
-static bool EvaluateRecord(const Expr *E, const LValue &This,
-                           APValue &Result, EvalInfo &Info) {
+static bool EvaluateRecord(Expr const *E, LValue const &This, APValue &Result,
+                           EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isRecordType() &&
          "can't evaluate expression as a record rvalue");
@@ -10090,19 +10074,19 @@
 //===----------------------------------------------------------------------===//
 namespace {
 class TemporaryExprEvaluator
-  : public LValueExprEvaluatorBase<TemporaryExprEvaluator> {
+    : public LValueExprEvaluatorBase<TemporaryExprEvaluator> {
 public:
-  TemporaryExprEvaluator(EvalInfo &Info, LValue &Result) :
-    LValueExprEvaluatorBaseTy(Info, Result, false) {}
+  TemporaryExprEvaluator(EvalInfo &Info, LValue &Result)
+      : LValueExprEvaluatorBaseTy(Info, Result, false) {}
 
   /// Visit an expression which constructs the value of this temporary.
-  bool VisitConstructExpr(const Expr *E) {
+  bool VisitConstructExpr(Expr const *E) {
     APValue &Value = Info.CurrentCall->createTemporary(
         E, E->getType(), ScopeKind::FullExpression, Result);
     return EvaluateInPlace(Value, Info, Result, E);
   }
 
-  bool VisitCastExpr(const CastExpr *E) {
+  bool VisitCastExpr(CastExpr const *E) {
     switch (E->getCastKind()) {
     default:
       return LValueExprEvaluatorBaseTy::VisitCastExpr(E);
@@ -10111,26 +10095,22 @@
       return VisitConstructExpr(E->getSubExpr());
     }
   }
-  bool VisitInitListExpr(const InitListExpr *E) {
+  bool VisitInitListExpr(InitListExpr const *E) {
     return VisitConstructExpr(E);
   }
-  bool VisitCXXConstructExpr(const CXXConstructExpr *E) {
+  bool VisitCXXConstructExpr(CXXConstructExpr const *E) {
     return VisitConstructExpr(E);
   }
-  bool VisitCallExpr(const CallExpr *E) {
-    return VisitConstructExpr(E);
-  }
-  bool VisitCXXStdInitializerListExpr(const CXXStdInitializerListExpr *E) {
-    return VisitConstructExpr(E);
-  }
-  bool VisitLambdaExpr(const LambdaExpr *E) {
+  bool VisitCallExpr(CallExpr const *E) { return VisitConstructExpr(E); }
+  bool VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr const *E) {
     return VisitConstructExpr(E);
   }
+  bool VisitLambdaExpr(LambdaExpr const *E) { return VisitConstructExpr(E); }
 };
 } // end anonymous namespace
 
 /// Evaluate an expression of record type as a temporary.
-static bool EvaluateTemporary(const Expr *E, LValue &Result, EvalInfo &Info) {
+static bool EvaluateTemporary(Expr const *E, LValue &Result, EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isRecordType());
   return TemporaryExprEvaluator(Info, Result).Visit(E);
@@ -10141,49 +10121,47 @@
 //===----------------------------------------------------------------------===//
 
 namespace {
-  class VectorExprEvaluator
-  : public ExprEvaluatorBase<VectorExprEvaluator> {
-    APValue &Result;
-  public:
+class VectorExprEvaluator : public ExprEvaluatorBase<VectorExprEvaluator> {
+  APValue &Result;
 
-    VectorExprEvaluator(EvalInfo &info, APValue &Result)
+public:
+  VectorExprEvaluator(EvalInfo &info, APValue &Result)
       : ExprEvaluatorBaseTy(info), Result(Result) {}
 
-    bool Success(ArrayRef<APValue> V, const Expr *E) {
-      assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements());
-      // FIXME: remove this APValue copy.
-      Result = APValue(V.data(), V.size());
-      return true;
-    }
-    bool Success(const APValue &V, const Expr *E) {
-      assert(V.isVector());
-      Result = V;
-      return true;
-    }
-    bool ZeroInitialization(const Expr *E);
+  bool Success(ArrayRef<APValue> V, Expr const *E) {
+    assert(V.size() == E->getType()->castAs<VectorType>()->getNumElements());
+    // FIXME: remove this APValue copy.
+    Result = APValue(V.data(), V.size());
+    return true;
+  }
+  bool Success(APValue const &V, Expr const *E) {
+    assert(V.isVector());
+    Result = V;
+    return true;
+  }
+  bool ZeroInitialization(Expr const *E);
 
-    bool VisitUnaryReal(const UnaryOperator *E)
-      { return Visit(E->getSubExpr()); }
-    bool VisitCastExpr(const CastExpr* E);
-    bool VisitInitListExpr(const InitListExpr *E);
-    bool VisitUnaryImag(const UnaryOperator *E);
-    bool VisitBinaryOperator(const BinaryOperator *E);
-    // FIXME: Missing: unary -, unary ~, conditional operator (for GNU
-    //                 conditional select), shufflevector, ExtVectorElementExpr
-  };
+  bool VisitUnaryReal(UnaryOperator const *E) { return Visit(E->getSubExpr()); }
+  bool VisitCastExpr(CastExpr const *E);
+  bool VisitInitListExpr(InitListExpr const *E);
+  bool VisitUnaryImag(UnaryOperator const *E);
+  bool VisitBinaryOperator(BinaryOperator const *E);
+  // FIXME: Missing: unary -, unary ~, conditional operator (for GNU
+  //                 conditional select), shufflevector, ExtVectorElementExpr
+};
 } // end anonymous namespace
 
-static bool EvaluateVector(const Expr* E, APValue& Result, EvalInfo &Info) {
+static bool EvaluateVector(Expr const *E, APValue &Result, EvalInfo &Info) {
   assert(E->isPRValue() && E->getType()->isVectorType() &&
          "not a vector prvalue");
   return VectorExprEvaluator(Info, Result).Visit(E);
 }
 
-bool VectorExprEvaluator::VisitCastExpr(const CastExpr *E) {
-  const VectorType *VTy = E->getType()->castAs<VectorType>();
+bool VectorExprEvaluator::VisitCastExpr(CastExpr const *E) {
+  VectorType const *VTy = E->getType()->castAs<VectorType>();
   unsigned NElts = VTy->getNumElements();
 
-  const Expr *SE = E->getSubExpr();
+  Expr const *SE = E->getSubExpr();
   QualType SETy = SE->getType();
 
   switch (E->getCastKind()) {
@@ -10218,25 +10196,25 @@
     bool BigEndian = Info.Ctx.getTargetInfo().isBigEndian();
     SmallVector<APValue, 4> Elts;
     if (EltTy->isRealFloatingType()) {
-      const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(EltTy);
+      llvm::fltSemantics const &Sem = Info.Ctx.getFloatTypeSemantics(EltTy);
       unsigned FloatEltSize = EltSize;
       if (&Sem == &APFloat::x87DoubleExtended())
         FloatEltSize = 80;
       for (unsigned i = 0; i < NElts; i++) {
         llvm::APInt Elt;
         if (BigEndian)
-          Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize);
+          Elt = SValInt.rotl(i * EltSize + FloatEltSize).trunc(FloatEltSize);
         else
-          Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize);
+          Elt = SValInt.rotr(i * EltSize).trunc(FloatEltSize);
         Elts.push_back(APValue(APFloat(Sem, Elt)));
       }
     } else if (EltTy->isIntegerType()) {
       for (unsigned i = 0; i < NElts; i++) {
         llvm::APInt Elt;
         if (BigEndian)
-          Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize);
+          Elt = SValInt.rotl(i * EltSize + EltSize).zextOrTrunc(EltSize);
         else
-          Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize);
+          Elt = SValInt.rotr(i * EltSize).zextOrTrunc(EltSize);
         Elts.push_back(APValue(APSInt(Elt, !EltTy->isSignedIntegerType())));
       }
     } else {
@@ -10249,9 +10227,8 @@
   }
 }
 
-bool
-VectorExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
-  const VectorType *VT = E->getType()->castAs<VectorType>();
+bool VectorExprEvaluator::VisitInitListExpr(InitListExpr const *E) {
+  VectorType const *VT = E->getType()->castAs<VectorType>();
   unsigned NumInits = E->getNumInits();
   unsigned NumElements = VT->getNumElements();
 
@@ -10265,8 +10242,8 @@
   unsigned CountInits = 0, CountElts = 0;
   while (CountElts < NumElements) {
     // Handle nested vector initialization.
-    if (CountInits < NumInits
-        && E->getInit(CountInits)->getType()->isVectorType()) {
+    if (CountInits < NumInits &&
+        E->getInit(CountInits)->getType()->isVectorType()) {
       APValue v;
       if (!EvaluateVector(E->getInit(CountInits), v, Info))
         return Error(E);
@@ -10298,9 +10275,8 @@
   return Success(Elements, E);
 }
 
-bool
-VectorExprEvaluator::ZeroInitialization(const Expr *E) {
-  const auto *VT = E->getType()->castAs<VectorType>();
+bool VectorExprEvaluator::ZeroInitialization(Expr const *E) {
+  auto const *VT = E->getType()->castAs<VectorType>();
   QualType EltTy = VT->getElementType();
   APValue ZeroElement;
   if (EltTy->isIntegerType())
@@ -10313,12 +10289,12 @@
   return Success(Elements, E);
 }
 
-bool VectorExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
+bool VectorExprEvaluator::VisitUnaryImag(UnaryOperator const *E) {
   VisitIgnoredValue(E->getSubExpr());
   return ZeroInitialization(E);
 }
 
-bool VectorExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
+bool VectorExprEvaluator::VisitBinaryOperator(BinaryOperator const *E) {
   BinaryOperatorKind Op = E->getOpcode();
   assert(Op != BO_PtrMemD && Op != BO_PtrMemI && Op != BO_Cmp &&
          "Operation not supported on vector types");
@@ -10358,68 +10334,65 @@
 //===----------------------------------------------------------------------===//
 
 namespace {
-  class ArrayExprEvaluator
-  : public ExprEvaluatorBase<ArrayExprEvaluator> {
-    const LValue &This;
-    APValue &Result;
-  public:
+class ArrayExprEvaluator : public ExprEvaluatorBase<ArrayExprEvaluator> {
+  LValue const &This;
+  APValue &Result;
 
-    ArrayExprEvaluator(EvalInfo &Info, const LValue &This, APValue &Result)
+public:
+  ArrayExprEvaluator(EvalInfo &Info, LValue const &This, APValue &Result)
       : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
 
-    bool Success(const APValue &V, const Expr *E) {
-      assert(V.isArray() && "expected array");
-      Result = V;
-      return true;
-    }
-
-    bool ZeroInitialization(const Expr *E) {
-      const ConstantArrayType *CAT =
-          Info.Ctx.getAsConstantArrayType(E->getType());
-      if (!CAT) {
-        if (E->getType()->isIncompleteArrayType()) {
-          // We can be asked to zero-initialize a flexible array member; this
-          // is represented as an ImplicitValueInitExpr of incomplete array
-          // type. In this case, the array has zero elements.
-          Result = APValue(APValue::UninitArray(), 0, 0);
-          return true;
-        }
-        // FIXME: We could handle VLAs here.
-        return Error(E);
-      }
+  bool Success(APValue const &V, Expr const *E) {
+    assert(V.isArray() && "expected array");
+    Result = V;
+    return true;
+  }
 
-      Result = APValue(APValue::UninitArray(), 0,
-                       CAT->getSize().getZExtValue());
-      if (!Result.hasArrayFiller())
+  bool ZeroInitialization(Expr const *E) {
+    ConstantArrayType const *CAT =
+        Info.Ctx.getAsConstantArrayType(E->getType());
+    if (!CAT) {
+      if (E->getType()->isIncompleteArrayType()) {
+        // We can be asked to zero-initialize a flexible array member; this
+        // is represented as an ImplicitValueInitExpr of incomplete array
+        // type. In this case, the array has zero elements.
+        Result = APValue(APValue::UninitArray(), 0, 0);
         return true;
+      }
+      // FIXME: We could handle VLAs here.
+      return Error(E);
+    }
 
-      // Zero-initialize all elements.
-      LValue Subobject = This;
-      Subobject.addArray(Info, E, CAT);
-      ImplicitValueInitExpr VIE(CAT->getElementType());
-      return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
-    }
-
-    bool VisitCallExpr(const CallExpr *E) {
-      return handleCallExpr(E, Result, &This);
-    }
-    bool VisitInitListExpr(const InitListExpr *E,
-                           QualType AllocType = QualType());
-    bool VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E);
-    bool VisitCXXConstructExpr(const CXXConstructExpr *E);
-    bool VisitCXXConstructExpr(const CXXConstructExpr *E,
-                               const LValue &Subobject,
-                               APValue *Value, QualType Type);
-    bool VisitStringLiteral(const StringLiteral *E,
-                            QualType AllocType = QualType()) {
-      expandStringLiteral(Info, E, Result, AllocType);
+    Result = APValue(APValue::UninitArray(), 0, CAT->getSize().getZExtValue());
+    if (!Result.hasArrayFiller())
       return true;
-    }
-  };
+
+    // Zero-initialize all elements.
+    LValue Subobject = This;
+    Subobject.addArray(Info, E, CAT);
+    ImplicitValueInitExpr VIE(CAT->getElementType());
+    return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject, &VIE);
+  }
+
+  bool VisitCallExpr(CallExpr const *E) {
+    return handleCallExpr(E, Result, &This);
+  }
+  bool VisitInitListExpr(InitListExpr const *E,
+                         QualType AllocType = QualType());
+  bool VisitArrayInitLoopExpr(ArrayInitLoopExpr const *E);
+  bool VisitCXXConstructExpr(CXXConstructExpr const *E);
+  bool VisitCXXConstructExpr(CXXConstructExpr const *E, LValue const &Subobject,
+                             APValue *Value, QualType Type);
+  bool VisitStringLiteral(StringLiteral const *E,
+                          QualType AllocType = QualType()) {
+    expandStringLiteral(Info, E, Result, AllocType);
+    return true;
+  }
+};
 } // end anonymous namespace
 
-static bool EvaluateArray(const Expr *E, const LValue &This,
-                          APValue &Result, EvalInfo &Info) {
+static bool EvaluateArray(Expr const *E, LValue const &This, APValue &Result,
+                          EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isArrayType() &&
          "not an array prvalue");
@@ -10427,7 +10400,7 @@
 }
 
 static bool EvaluateArrayNewInitList(EvalInfo &Info, LValue &This,
-                                     APValue &Result, const InitListExpr *ILE,
+                                     APValue &Result, InitListExpr const *ILE,
                                      QualType AllocType) {
   assert(!ILE->isValueDependent());
   assert(ILE->isPRValue() && ILE->getType()->isArrayType() &&
@@ -10438,7 +10411,7 @@
 
 static bool EvaluateArrayNewConstructExpr(EvalInfo &Info, LValue &This,
                                           APValue &Result,
-                                          const CXXConstructExpr *CCE,
+                                          CXXConstructExpr const *CCE,
                                           QualType AllocType) {
   assert(!CCE->isValueDependent());
   assert(CCE->isPRValue() && CCE->getType()->isArrayType() &&
@@ -10448,12 +10421,12 @@
 }
 
 // Return true iff the given array filler may depend on the element index.
-static bool MaybeElementDependentArrayFiller(const Expr *FillerExpr) {
+static bool MaybeElementDependentArrayFiller(Expr const *FillerExpr) {
   // For now, just allow non-class value-initialization and initialization
   // lists comprised of them.
   if (isa<ImplicitValueInitExpr>(FillerExpr))
     return false;
-  if (const InitListExpr *ILE = dyn_cast<InitListExpr>(FillerExpr)) {
+  if (InitListExpr const *ILE = dyn_cast<InitListExpr>(FillerExpr)) {
     for (unsigned I = 0, E = ILE->getNumInits(); I != E; ++I) {
       if (MaybeElementDependentArrayFiller(ILE->getInit(I)))
         return true;
@@ -10463,9 +10436,9 @@
   return true;
 }
 
-bool ArrayExprEvaluator::VisitInitListExpr(const InitListExpr *E,
+bool ArrayExprEvaluator::VisitInitListExpr(InitListExpr const *E,
                                            QualType AllocType) {
-  const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(
+  ConstantArrayType const *CAT = Info.Ctx.getAsConstantArrayType(
       AllocType.isNull() ? E->getType() : AllocType);
   if (!CAT)
     return Error(E);
@@ -10495,7 +10468,7 @@
 
   unsigned NumEltsToInit = E->getNumInits();
   unsigned NumElts = CAT->getSize().getZExtValue();
-  const Expr *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : nullptr;
+  Expr const *FillerExpr = E->hasArrayFiller() ? E->getArrayFiller() : nullptr;
 
   // If the initializer might depend on the array index, run it for each
   // array element.
@@ -10519,10 +10492,10 @@
   LValue Subobject = This;
   Subobject.addArray(Info, E, CAT);
   for (unsigned Index = 0; Index != NumEltsToInit; ++Index) {
-    const Expr *Init =
+    Expr const *Init =
         Index < E->getNumInits() ? E->getInit(Index) : FillerExpr;
-    if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
-                         Info, Subobject, Init) ||
+    if (!EvaluateInPlace(Result.getArrayInitializedElt(Index), Info, Subobject,
+                         Init) ||
         !HandleLValueArrayAdjustment(Info, Init, Subobject,
                                      CAT->getElementType(), 1)) {
       if (!Info.noteFailure())
@@ -10538,10 +10511,11 @@
   // once and splat over the rest of the array elements.
   assert(FillerExpr && "no array filler for incomplete init list");
   return EvaluateInPlace(Result.getArrayFiller(), Info, Subobject,
-                         FillerExpr) && Success;
+                         FillerExpr) &&
+         Success;
 }
 
-bool ArrayExprEvaluator::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E) {
+bool ArrayExprEvaluator::VisitArrayInitLoopExpr(ArrayInitLoopExpr const *E) {
   LValue CommonLV;
   if (E->getCommonExpr() &&
       !Evaluate(Info.CurrentCall->createTemporary(
@@ -10561,10 +10535,10 @@
 
   bool Success = true;
   for (EvalInfo::ArrayInitLoopIndex Index(Info); Index != Elements; ++Index) {
-    if (!EvaluateInPlace(Result.getArrayInitializedElt(Index),
-                         Info, Subobject, E->getSubExpr()) ||
-        !HandleLValueArrayAdjustment(Info, E, Subobject,
-                                     CAT->getElementType(), 1)) {
+    if (!EvaluateInPlace(Result.getArrayInitializedElt(Index), Info, Subobject,
+                         E->getSubExpr()) ||
+        !HandleLValueArrayAdjustment(Info, E, Subobject, CAT->getElementType(),
+                                     1)) {
       if (!Info.noteFailure())
         return false;
       Success = false;
@@ -10574,23 +10548,22 @@
   return Success;
 }
 
-bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E) {
+bool ArrayExprEvaluator::VisitCXXConstructExpr(CXXConstructExpr const *E) {
   return VisitCXXConstructExpr(E, This, &Result, E->getType());
 }
 
-bool ArrayExprEvaluator::VisitCXXConstructExpr(const CXXConstructExpr *E,
-                                               const LValue &Subobject,
-                                               APValue *Value,
-                                               QualType Type) {
+bool ArrayExprEvaluator::VisitCXXConstructExpr(CXXConstructExpr const *E,
+                                               LValue const &Subobject,
+                                               APValue *Value, QualType Type) {
   bool HadZeroInit = Value->hasValue();
 
-  if (const ConstantArrayType *CAT = Info.Ctx.getAsConstantArrayType(Type)) {
+  if (ConstantArrayType const *CAT = Info.Ctx.getAsConstantArrayType(Type)) {
     unsigned N = CAT->getSize().getZExtValue();
 
     // Preserve the array filler if we had prior zero-initialization.
-    APValue Filler =
-      HadZeroInit && Value->hasArrayFiller() ? Value->getArrayFiller()
-                                             : APValue();
+    APValue Filler = HadZeroInit && Value->hasArrayFiller()
+                         ? Value->getArrayFiller()
+                         : APValue();
 
     *Value = APValue(APValue::UninitArray(), N, N);
 
@@ -10604,8 +10577,8 @@
     for (unsigned I = 0; I != N; ++I)
       if (!VisitCXXConstructExpr(E, ArrayElt, &Value->getArrayInitializedElt(I),
                                  CAT->getElementType()) ||
-          !HandleLValueArrayAdjustment(Info, E, ArrayElt,
-                                       CAT->getElementType(), 1))
+          !HandleLValueArrayAdjustment(Info, E, ArrayElt, CAT->getElementType(),
+                                       1))
         return false;
 
     return true;
@@ -10615,7 +10588,7 @@
     return Error(E);
 
   return RecordExprEvaluator(Info, Subobject, *Value)
-             .VisitCXXConstructExpr(E, Type);
+      .VisitCXXConstructExpr(E, Type);
 }
 
 //===----------------------------------------------------------------------===//
@@ -10627,14 +10600,14 @@
 //===----------------------------------------------------------------------===//
 
 namespace {
-class IntExprEvaluator
-        : public ExprEvaluatorBase<IntExprEvaluator> {
+class IntExprEvaluator : public ExprEvaluatorBase<IntExprEvaluator> {
   APValue &Result;
+
 public:
   IntExprEvaluator(EvalInfo &info, APValue &result)
       : ExprEvaluatorBaseTy(info), Result(result) {}
 
-  bool Success(const llvm::APSInt &SI, const Expr *E, APValue &Result) {
+  bool Success(llvm::APSInt const &SI, Expr const *E, APValue &Result) {
     assert(E->getType()->isIntegralOrEnumerationType() &&
            "Invalid evaluation result.");
     assert(SI.isSigned() == E->getType()->isSignedIntegerOrEnumerationType() &&
@@ -10644,39 +10617,39 @@
     Result = APValue(SI);
     return true;
   }
-  bool Success(const llvm::APSInt &SI, const Expr *E) {
+  bool Success(llvm::APSInt const &SI, Expr const *E) {
     return Success(SI, E, Result);
   }
 
-  bool Success(const llvm::APInt &I, const Expr *E, APValue &Result) {
+  bool Success(llvm::APInt const &I, Expr const *E, APValue &Result) {
     assert(E->getType()->isIntegralOrEnumerationType() &&
            "Invalid evaluation result.");
     assert(I.getBitWidth() == Info.Ctx.getIntWidth(E->getType()) &&
            "Invalid evaluation result.");
     Result = APValue(APSInt(I));
     Result.getInt().setIsUnsigned(
-                            E->getType()->isUnsignedIntegerOrEnumerationType());
+        E->getType()->isUnsignedIntegerOrEnumerationType());
     return true;
   }
-  bool Success(const llvm::APInt &I, const Expr *E) {
+  bool Success(llvm::APInt const &I, Expr const *E) {
     return Success(I, E, Result);
   }
 
-  bool Success(uint64_t Value, const Expr *E, APValue &Result) {
+  bool Success(uint64_t Value, Expr const *E, APValue &Result) {
     assert(E->getType()->isIntegralOrEnumerationType() &&
            "Invalid evaluation result.");
     Result = APValue(Info.Ctx.MakeIntValue(Value, E->getType()));
     return true;
   }
-  bool Success(uint64_t Value, const Expr *E) {
+  bool Success(uint64_t Value, Expr const *E) {
     return Success(Value, E, Result);
   }
 
-  bool Success(CharUnits Size, const Expr *E) {
+  bool Success(CharUnits Size, Expr const *E) {
     return Success(Size.getQuantity(), E);
   }
 
-  bool Success(const APValue &V, const Expr *E) {
+  bool Success(APValue const &V, Expr const *E) {
     if (V.isLValue() || V.isAddrLabelDiff() || V.isIndeterminate()) {
       Result = V;
       return true;
@@ -10684,27 +10657,27 @@
     return Success(V.getInt(), E);
   }
 
-  bool ZeroInitialization(const Expr *E) { return Success(0, E); }
+  bool ZeroInitialization(Expr const *E) { return Success(0, E); }
 
   //===--------------------------------------------------------------------===//
   //                            Visitor Methods
   //===--------------------------------------------------------------------===//
 
-  bool VisitIntegerLiteral(const IntegerLiteral *E) {
+  bool VisitIntegerLiteral(IntegerLiteral const *E) {
     return Success(E->getValue(), E);
   }
-  bool VisitCharacterLiteral(const CharacterLiteral *E) {
+  bool VisitCharacterLiteral(CharacterLiteral const *E) {
     return Success(E->getValue(), E);
   }
 
-  bool CheckReferencedDecl(const Expr *E, const Decl *D);
-  bool VisitDeclRefExpr(const DeclRefExpr *E) {
+  bool CheckReferencedDecl(Expr const *E, Decl const *D);
+  bool VisitDeclRefExpr(DeclRefExpr const *E) {
     if (CheckReferencedDecl(E, E->getDecl()))
       return true;
 
     return ExprEvaluatorBaseTy::VisitDeclRefExpr(E);
   }
-  bool VisitMemberExpr(const MemberExpr *E) {
+  bool VisitMemberExpr(MemberExpr const *E) {
     if (CheckReferencedDecl(E, E->getMemberDecl())) {
       VisitIgnoredBaseExpression(E->getBase());
       return true;
@@ -10713,24 +10686,24 @@
     return ExprEvaluatorBaseTy::VisitMemberExpr(E);
   }
 
-  bool VisitCallExpr(const CallExpr *E);
-  bool VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp);
-  bool VisitBinaryOperator(const BinaryOperator *E);
-  bool VisitOffsetOfExpr(const OffsetOfExpr *E);
-  bool VisitUnaryOperator(const UnaryOperator *E);
+  bool VisitCallExpr(CallExpr const *E);
+  bool VisitBuiltinCallExpr(CallExpr const *E, unsigned BuiltinOp);
+  bool VisitBinaryOperator(BinaryOperator const *E);
+  bool VisitOffsetOfExpr(OffsetOfExpr const *E);
+  bool VisitUnaryOperator(UnaryOperator const *E);
 
-  bool VisitCastExpr(const CastExpr* E);
-  bool VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
+  bool VisitCastExpr(CastExpr const *E);
+  bool VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr const *E);
 
-  bool VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
+  bool VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr const *E) {
     return Success(E->getValue(), E);
   }
 
-  bool VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
+  bool VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr const *E) {
     return Success(E->getValue(), E);
   }
 
-  bool VisitArrayInitIndexExpr(const ArrayInitIndexExpr *E) {
+  bool VisitArrayInitIndexExpr(ArrayInitIndexExpr const *E) {
     if (Info.ArrayInitIndex == uint64_t(-1)) {
       // We were asked to evaluate this subexpression independent of the
       // enclosing ArrayInitLoopExpr. We can't do that.
@@ -10741,30 +10714,28 @@
   }
 
   // Note, GNU defines __null as an integer, not a pointer.
-  bool VisitGNUNullExpr(const GNUNullExpr *E) {
-    return ZeroInitialization(E);
-  }
+  bool VisitGNUNullExpr(GNUNullExpr const *E) { return ZeroInitialization(E); }
 
-  bool VisitTypeTraitExpr(const TypeTraitExpr *E) {
+  bool VisitTypeTraitExpr(TypeTraitExpr const *E) {
     return Success(E->getValue(), E);
   }
 
-  bool VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
+  bool VisitArrayTypeTraitExpr(ArrayTypeTraitExpr const *E) {
     return Success(E->getValue(), E);
   }
 
-  bool VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
+  bool VisitExpressionTraitExpr(ExpressionTraitExpr const *E) {
     return Success(E->getValue(), E);
   }
 
-  bool VisitUnaryReal(const UnaryOperator *E);
-  bool VisitUnaryImag(const UnaryOperator *E);
+  bool VisitUnaryReal(UnaryOperator const *E);
+  bool VisitUnaryImag(UnaryOperator const *E);
 
-  bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E);
-  bool VisitSizeOfPackExpr(const SizeOfPackExpr *E);
-  bool VisitSourceLocExpr(const SourceLocExpr *E);
-  bool VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E);
-  bool VisitRequiresExpr(const RequiresExpr *E);
+  bool VisitCXXNoexceptExpr(CXXNoexceptExpr const *E);
+  bool VisitSizeOfPackExpr(SizeOfPackExpr const *E);
+  bool VisitSourceLocExpr(SourceLocExpr const *E);
+  bool VisitConceptSpecializationExpr(ConceptSpecializationExpr const *E);
+  bool VisitRequiresExpr(RequiresExpr const *E);
   // FIXME: Missing: array subscript of vector, member of vector
 };
 
@@ -10772,25 +10743,25 @@
     : public ExprEvaluatorBase<FixedPointExprEvaluator> {
   APValue &Result;
 
- public:
+public:
   FixedPointExprEvaluator(EvalInfo &info, APValue &result)
       : ExprEvaluatorBaseTy(info), Result(result) {}
 
-  bool Success(const llvm::APInt &I, const Expr *E) {
+  bool Success(llvm::APInt const &I, Expr const *E) {
     return Success(
         APFixedPoint(I, Info.Ctx.getFixedPointSemantics(E->getType())), E);
   }
 
-  bool Success(uint64_t Value, const Expr *E) {
+  bool Success(uint64_t Value, Expr const *E) {
     return Success(
         APFixedPoint(Value, Info.Ctx.getFixedPointSemantics(E->getType())), E);
   }
 
-  bool Success(const APValue &V, const Expr *E) {
+  bool Success(APValue const &V, Expr const *E) {
     return Success(V.getFixedPoint(), E);
   }
 
-  bool Success(const APFixedPoint &V, const Expr *E) {
+  bool Success(APFixedPoint const &V, Expr const *E) {
     assert(E->getType()->isFixedPointType() && "Invalid evaluation result.");
     assert(V.getWidth() == Info.Ctx.getIntWidth(E->getType()) &&
            "Invalid evaluation result.");
@@ -10802,13 +10773,13 @@
   //                            Visitor Methods
   //===--------------------------------------------------------------------===//
 
-  bool VisitFixedPointLiteral(const FixedPointLiteral *E) {
+  bool VisitFixedPointLiteral(FixedPointLiteral const *E) {
     return Success(E->getValue(), E);
   }
 
-  bool VisitCastExpr(const CastExpr *E);
-  bool VisitUnaryOperator(const UnaryOperator *E);
-  bool VisitBinaryOperator(const BinaryOperator *E);
+  bool VisitCastExpr(CastExpr const *E);
+  bool VisitUnaryOperator(UnaryOperator const *E);
+  bool VisitBinaryOperator(BinaryOperator const *E);
 };
 } // end anonymous namespace
 
@@ -10820,14 +10791,14 @@
 /// an integer rvalue to produce a pointer (represented as an lvalue) instead.
 /// Some simple arithmetic on such values is supported (they are treated much
 /// like char*).
-static bool EvaluateIntegerOrLValue(const Expr *E, APValue &Result,
+static bool EvaluateIntegerOrLValue(Expr const *E, APValue &Result,
                                     EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isIntegralOrEnumerationType());
   return IntExprEvaluator(Info, Result).Visit(E);
 }
 
-static bool EvaluateInteger(const Expr *E, APSInt &Result, EvalInfo &Info) {
+static bool EvaluateInteger(Expr const *E, APSInt &Result, EvalInfo &Info) {
   assert(!E->isValueDependent());
   APValue Val;
   if (!EvaluateIntegerOrLValue(E, Val, Info))
@@ -10842,13 +10813,13 @@
   return true;
 }
 
-bool IntExprEvaluator::VisitSourceLocExpr(const SourceLocExpr *E) {
+bool IntExprEvaluator::VisitSourceLocExpr(SourceLocExpr const *E) {
   APValue Evaluated = E->EvaluateInContext(
       Info.Ctx, Info.CurrentCall->CurSourceLocExprScope.getDefaultExpr());
   return Success(Evaluated, E);
 }
 
-static bool EvaluateFixedPoint(const Expr *E, APFixedPoint &Result,
+static bool EvaluateFixedPoint(Expr const *E, APFixedPoint &Result,
                                EvalInfo &Info) {
   assert(!E->isValueDependent());
   if (E->getType()->isFixedPointType()) {
@@ -10864,7 +10835,7 @@
   return false;
 }
 
-static bool EvaluateFixedPointOrInteger(const Expr *E, APFixedPoint &Result,
+static bool EvaluateFixedPointOrInteger(Expr const *E, APFixedPoint &Result,
                                         EvalInfo &Info) {
   assert(!E->isValueDependent());
   if (E->getType()->isIntegerType()) {
@@ -10883,14 +10854,14 @@
 /// Check whether the given declaration can be directly converted to an integral
 /// rvalue. If not, no diagnostic is produced; there are other things we can
 /// try.
-bool IntExprEvaluator::CheckReferencedDecl(const Expr* E, const Decl* D) {
+bool IntExprEvaluator::CheckReferencedDecl(Expr const *E, Decl const *D) {
   // Enums are integer constant exprs.
-  if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) {
+  if (EnumConstantDecl const *ECD = dyn_cast<EnumConstantDecl>(D)) {
     // Check for signedness/width mismatches between E type and ECD value.
-    bool SameSign = (ECD->getInitVal().isSigned()
-                     == E->getType()->isSignedIntegerOrEnumerationType());
-    bool SameWidth = (ECD->getInitVal().getBitWidth()
-                      == Info.Ctx.getIntWidth(E->getType()));
+    bool SameSign = (ECD->getInitVal().isSigned() ==
+                     E->getType()->isSignedIntegerOrEnumerationType());
+    bool SameWidth =
+        (ECD->getInitVal().getBitWidth() == Info.Ctx.getIntWidth(E->getType()));
     if (SameSign && SameWidth)
       return Success(ECD->getInitVal(), E);
     else {
@@ -10939,12 +10910,12 @@
 
 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
 /// as GCC.
-static GCCTypeClass
-EvaluateBuiltinClassifyType(QualType T, const LangOptions &LangOpts) {
+static GCCTypeClass EvaluateBuiltinClassifyType(QualType T,
+                                                LangOptions const &LangOpts) {
   assert(!T->isDependentType() && "unexpected dependent type");
 
   QualType CanTy = T.getCanonicalType();
-  const BuiltinType *BT = dyn_cast<BuiltinType>(CanTy);
+  BuiltinType const *BT = dyn_cast<BuiltinType>(CanTy);
 
   switch (CanTy->getTypeClass()) {
 #define TYPE(ID, BASE)
@@ -10954,17 +10925,20 @@
 #include "clang/AST/TypeNodes.inc"
   case Type::Auto:
   case Type::DeducedTemplateSpecialization:
-      llvm_unreachable("unexpected non-canonical or dependent type");
+    llvm_unreachable("unexpected non-canonical or dependent type");
 
   case Type::Builtin:
     switch (BT->getKind()) {
 #define BUILTIN_TYPE(ID, SINGLETON_ID)
-#define SIGNED_TYPE(ID, SINGLETON_ID) \
-    case BuiltinType::ID: return GCCTypeClass::Integer;
-#define FLOATING_TYPE(ID, SINGLETON_ID) \
-    case BuiltinType::ID: return GCCTypeClass::RealFloat;
-#define PLACEHOLDER_TYPE(ID, SINGLETON_ID) \
-    case BuiltinType::ID: break;
+#define SIGNED_TYPE(ID, SINGLETON_ID)                                          \
+  case BuiltinType::ID:                                                        \
+    return GCCTypeClass::Integer;
+#define FLOATING_TYPE(ID, SINGLETON_ID)                                        \
+  case BuiltinType::ID:                                                        \
+    return GCCTypeClass::RealFloat;
+#define PLACEHOLDER_TYPE(ID, SINGLETON_ID)                                     \
+  case BuiltinType::ID:                                                        \
+    break;
 #include "clang/AST/BuiltinTypes.def"
     case BuiltinType::Void:
       return GCCTypeClass::Void;
@@ -11004,22 +10978,19 @@
     case BuiltinType::ObjCId:
     case BuiltinType::ObjCClass:
     case BuiltinType::ObjCSel:
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-    case BuiltinType::Id:
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
+  case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-    case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
 #include "clang/Basic/OpenCLExtensionTypes.def"
     case BuiltinType::OCLSampler:
     case BuiltinType::OCLEvent:
     case BuiltinType::OCLClkEvent:
     case BuiltinType::OCLQueue:
     case BuiltinType::OCLReserveID:
-#define SVE_TYPE(Name, Id, SingletonId) \
-    case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-    case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
@@ -11081,8 +11052,8 @@
 
 /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way
 /// as GCC.
-static GCCTypeClass
-EvaluateBuiltinClassifyType(const CallExpr *E, const LangOptions &LangOpts) {
+static GCCTypeClass EvaluateBuiltinClassifyType(CallExpr const *E,
+                                                LangOptions const &LangOpts) {
   // If no argument was supplied, default to None. This isn't
   // ideal, however it is what gcc does.
   if (E->getNumArgs() == 0)
@@ -11099,12 +11070,12 @@
 ///
 /// A pointer is only "constant" if it is null (or a pointer cast to integer)
 /// or it points to the first character of a string literal.
-static bool EvaluateBuiltinConstantPForLValue(const APValue &LV) {
+static bool EvaluateBuiltinConstantPForLValue(APValue const &LV) {
   APValue::LValueBase Base = LV.getLValueBase();
   if (Base.isNull()) {
     // A null base is acceptable.
     return true;
-  } else if (const Expr *E = Base.dyn_cast<const Expr *>()) {
+  } else if (Expr const *E = Base.dyn_cast<Expr const *>()) {
     if (!isa<StringLiteral>(E))
       return false;
     return LV.getLValueOffset().isZero();
@@ -11120,7 +11091,7 @@
 
 /// EvaluateBuiltinConstantP - Evaluate __builtin_constant_p as similarly to
 /// GCC as we can manage.
-static bool EvaluateBuiltinConstantP(EvalInfo &Info, const Expr *Arg) {
+static bool EvaluateBuiltinConstantP(EvalInfo &Info, Expr const *Arg) {
   // This evaluation is not permitted to have side-effects, so evaluate it in
   // a speculative evaluation context.
   SpeculativeEvaluationRAII SpeculativeEval(Info);
@@ -11170,10 +11141,10 @@
 /// Retrieves the "underlying object type" of the given expression,
 /// as used by __builtin_object_size.
 static QualType getObjectType(APValue::LValueBase B) {
-  if (const ValueDecl *D = B.dyn_cast<const ValueDecl*>()) {
-    if (const VarDecl *VD = dyn_cast<VarDecl>(D))
+  if (ValueDecl const *D = B.dyn_cast<ValueDecl const *>()) {
+    if (VarDecl const *VD = dyn_cast<VarDecl>(D))
       return VD->getType();
-  } else if (const Expr *E = B.dyn_cast<const Expr*>()) {
+  } else if (Expr const *E = B.dyn_cast<Expr const *>()) {
     if (isa<CompoundLiteralExpr>(E))
       return E->getType();
   } else if (B.is<TypeInfoLValue>()) {
@@ -11191,7 +11162,7 @@
 /// Ex. For E = `(short*)((char*)(&foo))`, returns `&foo`
 ///
 /// Always returns an RValue with a pointer representation.
-static const Expr *ignorePointerCastsAndParens(const Expr *E) {
+static Expr const *ignorePointerCastsAndParens(Expr const *E) {
   assert(E->isPRValue() && E->getType()->hasPointerRepresentation());
 
   auto *NoParens = E->IgnoreParens();
@@ -11227,10 +11198,10 @@
 ///
 /// If this encounters an invalid RecordDecl or otherwise cannot determine the
 /// correct result, it will always return true.
-static bool isDesignatorAtObjectEnd(const ASTContext &Ctx, const LValue &LVal) {
+static bool isDesignatorAtObjectEnd(ASTContext const &Ctx, LValue const &LVal) {
   assert(!LVal.Designator.Invalid);
 
-  auto IsLastOrInvalidFieldDecl = [&Ctx](const FieldDecl *FD, bool &Invalid) {
+  auto IsLastOrInvalidFieldDecl = [&Ctx](FieldDecl const *FD, bool &Invalid) {
     const RecordDecl *Parent = FD->getParent();
     Invalid = Parent->isInvalidDecl();
     if (Invalid || Parent->isUnion())
@@ -11240,7 +11211,7 @@
   };
 
   auto &Base = LVal.getLValueBase();
-  if (auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<const Expr *>())) {
+  if (auto *ME = dyn_cast_or_null<MemberExpr>(Base.dyn_cast<Expr const *>())) {
     if (auto *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
       bool Invalid;
       if (!IsLastOrInvalidFieldDecl(FD, Invalid))
@@ -11267,19 +11238,19 @@
   }
 
   for (unsigned E = LVal.Designator.Entries.size(); I != E; ++I) {
-    const auto &Entry = LVal.Designator.Entries[I];
+    auto const &Entry = LVal.Designator.Entries[I];
     if (BaseType->isArrayType()) {
       // Because __builtin_object_size treats arrays as objects, we can ignore
       // the index iff this is the last array in the Designator.
       if (I + 1 == E)
         return true;
-      const auto *CAT = cast<ConstantArrayType>(Ctx.getAsArrayType(BaseType));
+      auto const *CAT = cast<ConstantArrayType>(Ctx.getAsArrayType(BaseType));
       uint64_t Index = Entry.getAsArrayIndex();
       if (Index + 1 != CAT->getSize())
         return false;
       BaseType = CAT->getElementType();
     } else if (BaseType->isAnyComplexType()) {
-      const auto *CT = BaseType->castAs<ComplexType>();
+      auto const *CT = BaseType->castAs<ComplexType>();
       uint64_t Index = Entry.getAsArrayIndex();
       if (Index != 1)
         return false;
@@ -11301,7 +11272,7 @@
 /// necessarily valid). Note that this always returns 'true' if the LValue has
 /// an unsized array as its first designator entry, because there's currently no
 /// way to tell if the user typed *foo or foo[0].
-static bool refersToCompleteObject(const LValue &LVal) {
+static bool refersToCompleteObject(LValue const &LVal) {
   if (LVal.Designator.Invalid)
     return false;
 
@@ -11313,14 +11284,14 @@
 
   // If `E` is a MemberExpr, then the first part of the designator is hiding in
   // the LValueBase.
-  const auto *E = LVal.Base.dyn_cast<const Expr *>();
+  auto const *E = LVal.Base.dyn_cast<Expr const *>();
   return !E || !isa<MemberExpr>(E);
 }
 
 /// Attempts to detect a user writing into a piece of memory that's impossible
 /// to figure out the size of by just using types.
-static bool isUserWritingOffTheEnd(const ASTContext &Ctx, const LValue &LVal) {
-  const SubobjectDesignator &Designator = LVal.Designator;
+static bool isUserWritingOffTheEnd(ASTContext const &Ctx, LValue const &LVal) {
+  SubobjectDesignator const &Designator = LVal.Designator;
   // Notes:
   // - Users can only write off of the end when we have an invalid base. Invalid
   //   bases imply we don't know where the memory came from.
@@ -11340,7 +11311,7 @@
 
 /// Converts the given APInt to CharUnits, assuming the APInt is unsigned.
 /// Fails if the conversion would cause loss of precision.
-static bool convertUnsignedAPIntToCharUnits(const llvm::APInt &Int,
+static bool convertUnsignedAPIntToCharUnits(llvm::APInt const &Int,
                                             CharUnits &Result) {
   auto CharUnitsMax = std::numeric_limits<CharUnits::QuantityType>::max();
   if (Int.ugt(CharUnitsMax))
@@ -11356,7 +11327,7 @@
 ///
 /// If this returns false, the value of Result is undefined.
 static bool determineEndOffset(EvalInfo &Info, SourceLocation ExprLoc,
-                               unsigned Type, const LValue &LVal,
+                               unsigned Type, LValue const &LVal,
                                CharUnits &EndOffset) {
   bool DetermineForCompleteObject = refersToCompleteObject(LVal);
 
@@ -11387,7 +11358,7 @@
   }
 
   // We want to evaluate the size of a subobject.
-  const SubobjectDesignator &Designator = LVal.Designator;
+  SubobjectDesignator const &Designator = LVal.Designator;
 
   // The following is a moderately common idiom in C:
   //
@@ -11437,7 +11408,7 @@
 ///
 /// If @p WasError is non-null, this will report whether the failure to evaluate
 /// is to be treated as an Error in IntExprEvaluator.
-static bool tryEvaluateBuiltinObjectSize(const Expr *E, unsigned Type,
+static bool tryEvaluateBuiltinObjectSize(Expr const *E, unsigned Type,
                                          EvalInfo &Info, uint64_t &Size) {
   // Determine the denoted object.
   LValue LVal;
@@ -11480,14 +11451,14 @@
   return true;
 }
 
-bool IntExprEvaluator::VisitCallExpr(const CallExpr *E) {
+bool IntExprEvaluator::VisitCallExpr(CallExpr const *E) {
   if (unsigned BuiltinOp = E->getBuiltinCallee())
     return VisitBuiltinCallExpr(E, BuiltinOp);
 
   return ExprEvaluatorBaseTy::VisitCallExpr(E);
 }
 
-static bool getBuiltinAlignArguments(const CallExpr *E, EvalInfo &Info,
+static bool getBuiltinAlignArguments(CallExpr const *E, EvalInfo &Info,
                                      APValue &Val, APSInt &Alignment) {
   QualType SrcTy = E->getArg(0)->getType();
   if (!getAlignmentArgument(E->getArg(1), SrcTy, Info, Alignment))
@@ -11514,7 +11485,7 @@
   return true;
 }
 
-bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
+bool IntExprEvaluator::VisitBuiltinCallExpr(CallExpr const *E,
                                             unsigned BuiltinOp) {
   switch (BuiltinOp) {
   default:
@@ -11664,7 +11635,7 @@
   }
 
   case Builtin::BI__builtin_constant_p: {
-    const Expr *Arg = E->getArg(0);
+    Expr const *Arg = E->getArg(0);
     if (EvaluateBuiltinConstantP(Info, Arg))
       return Success(true, E);
     if (Info.InConstantContext || Arg->HasSideEffects(Info.Ctx)) {
@@ -11678,7 +11649,7 @@
   }
 
   case Builtin::BI__builtin_is_constant_evaluated: {
-    const auto *Callee = Info.CurrentCall->getCallee();
+    auto const *Callee = Info.CurrentCall->getCallee();
     if (Info.InConstantContext && !Info.CheckingPotentialConstantExpression &&
         (Info.CallStackDepth == 1 ||
          (Info.CallStackDepth == 2 && Callee->isInStdNamespace() &&
@@ -11736,10 +11707,18 @@
       return false;
     unsigned Arg;
     switch (Val.getCategory()) {
-    case APFloat::fcNaN: Arg = 0; break;
-    case APFloat::fcInfinity: Arg = 1; break;
-    case APFloat::fcNormal: Arg = Val.isDenormal() ? 3 : 2; break;
-    case APFloat::fcZero: Arg = 4; break;
+    case APFloat::fcNaN:
+      Arg = 0;
+      break;
+    case APFloat::fcInfinity:
+      Arg = 1;
+      break;
+    case APFloat::fcNormal:
+      Arg = Val.isDenormal() ? 3 : 2;
+      break;
+    case APFloat::fcZero:
+      Arg = 4;
+      break;
     }
     return Visit(E->getArg(Arg));
   }
@@ -11833,8 +11812,8 @@
     // A call to strlen is not a constant expression.
     if (Info.getLangOpts().CPlusPlus11)
       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
-        << /*isConstexpr*/0 << /*isConstructor*/0
-        << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
+          << /*isConstexpr*/ 0 << /*isConstructor*/ 0
+          << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
     else
       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
     LLVM_FALLTHROUGH;
@@ -11858,8 +11837,8 @@
     // A call to strlen is not a constant expression.
     if (Info.getLangOpts().CPlusPlus11)
       Info.CCEDiag(E, diag::note_constexpr_invalid_function)
-        << /*isConstexpr*/0 << /*isConstructor*/0
-        << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
+          << /*isConstexpr*/ 0 << /*isConstructor*/ 0
+          << (std::string("'") + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + "'");
     else
       Info.CCEDiag(E, diag::note_invalid_subexpr_in_const_expr);
     LLVM_FALLTHROUGH;
@@ -11876,8 +11855,7 @@
       return false;
 
     uint64_t MaxLength = uint64_t(-1);
-    if (BuiltinOp != Builtin::BIstrcmp &&
-        BuiltinOp != Builtin::BIwcscmp &&
+    if (BuiltinOp != Builtin::BIstrcmp && BuiltinOp != Builtin::BIwcscmp &&
         BuiltinOp != Builtin::BI__builtin_strcmp &&
         BuiltinOp != Builtin::BI__builtin_wcscmp) {
       APSInt N;
@@ -11919,12 +11897,12 @@
       return false;
     }
 
-    const auto &ReadCurElems = [&](APValue &Char1, APValue &Char2) {
+    auto const &ReadCurElems = [&](APValue &Char1, APValue &Char2) {
       return handleLValueToRValueConversion(Info, E, CharTy1, String1, Char1) &&
              handleLValueToRValueConversion(Info, E, CharTy2, String2, Char2) &&
              Char1.isInt() && Char2.isInt();
     };
-    const auto &AdvanceElems = [&] {
+    auto const &AdvanceElems = [&] {
       return HandleLValueArrayAdjustment(Info, E, String1, CharTy1, 1) &&
              HandleLValueArrayAdjustment(Info, E, String2, CharTy2, 1);
     };
@@ -11993,8 +11971,11 @@
           // and _Atomic(T) is appropriately-aligned.
           return Success(1, E);
 
-        QualType PointeeType = E->getArg(1)->IgnoreImpCasts()->getType()->
-          castAs<PointerType>()->getPointeeType();
+        QualType PointeeType = E->getArg(1)
+                                   ->IgnoreImpCasts()
+                                   ->getType()
+                                   ->castAs<PointerType>()
+                                   ->getPointeeType();
         if (!PointeeType->isIncompleteType() &&
             Info.Ctx.getTypeAlignInChars(PointeeType) >= Size) {
           // OK, we will inline operations on this object.
@@ -12003,8 +11984,8 @@
       }
     }
 
-    return BuiltinOp == Builtin::BI__atomic_always_lock_free ?
-        Success(0, E) : Error(E);
+    return BuiltinOp == Builtin::BI__atomic_always_lock_free ? Success(0, E)
+                                                             : Error(E);
   }
   case Builtin::BI__builtin_add_overflow:
   case Builtin::BI__builtin_sub_overflow:
@@ -12046,7 +12027,7 @@
       bool IsSigned = LHS.isSigned() || RHS.isSigned() ||
                       ResultType->isSignedIntegerOrEnumerationType();
       bool AllSigned = LHS.isSigned() && RHS.isSigned() &&
-                      ResultType->isSignedIntegerOrEnumerationType();
+                       ResultType->isSignedIntegerOrEnumerationType();
       uint64_t LHSSize = LHS.getBitWidth();
       uint64_t RHSSize = RHS.getBitWidth();
       uint64_t ResultSize = Info.Ctx.getTypeSize(ResultType);
@@ -12128,8 +12109,8 @@
 
 /// Determine whether this is a pointer past the end of the complete
 /// object referred to by the lvalue.
-static bool isOnePastTheEndOfCompleteObject(const ASTContext &Ctx,
-                                            const LValue &LV) {
+static bool isOnePastTheEndOfCompleteObject(ASTContext const &Ctx,
+                                            LValue const &LV) {
   // A null pointer can be viewed as being "past the end" but we don't
   // choose to look at it that way here.
   if (!LV.getLValueBase())
@@ -12165,7 +12146,7 @@
     APValue Val;
     bool Failed;
 
-    EvalResult() : Failed(false) { }
+    EvalResult() : Failed(false) {}
 
     void swap(EvalResult &RHS) {
       Val.swap(RHS.Val);
@@ -12175,7 +12156,7 @@
   };
 
   struct Job {
-    const Expr *E;
+    Expr const *E;
     EvalResult LHSResult; // meaningful only for binary operator expression.
     enum { AnyExprKind, BinOpKind, BinOpVisitedLHSKind } Kind;
 
@@ -12198,57 +12179,54 @@
 
 public:
   DataRecursiveIntBinOpEvaluator(IntExprEvaluator &IntEval, APValue &Result)
-    : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) { }
+      : IntEval(IntEval), Info(IntEval.getEvalInfo()), FinalResult(Result) {}
 
   /// True if \param E is a binary operator that we are going to handle
   /// data recursively.
   /// We handle binary operators that are comma, logical, or that have operands
   /// with integral or enumeration type.
-  static bool shouldEnqueue(const BinaryOperator *E) {
+  static bool shouldEnqueue(BinaryOperator const *E) {
     return E->getOpcode() == BO_Comma || E->isLogicalOp() ||
            (E->isPRValue() && E->getType()->isIntegralOrEnumerationType() &&
             E->getLHS()->getType()->isIntegralOrEnumerationType() &&
             E->getRHS()->getType()->isIntegralOrEnumerationType());
   }
 
-  bool Traverse(const BinaryOperator *E) {
+  bool Traverse(BinaryOperator const *E) {
     enqueue(E);
     EvalResult PrevResult;
     while (!Queue.empty())
       process(PrevResult);
 
-    if (PrevResult.Failed) return false;
+    if (PrevResult.Failed)
+      return false;
 
     FinalResult.swap(PrevResult.Val);
     return true;
   }
 
 private:
-  bool Success(uint64_t Value, const Expr *E, APValue &Result) {
+  bool Success(uint64_t Value, Expr const *E, APValue &Result) {
     return IntEval.Success(Value, E, Result);
   }
-  bool Success(const APSInt &Value, const Expr *E, APValue &Result) {
+  bool Success(APSInt const &Value, Expr const *E, APValue &Result) {
     return IntEval.Success(Value, E, Result);
   }
-  bool Error(const Expr *E) {
-    return IntEval.Error(E);
-  }
-  bool Error(const Expr *E, diag::kind D) {
-    return IntEval.Error(E, D);
-  }
+  bool Error(Expr const *E) { return IntEval.Error(E); }
+  bool Error(Expr const *E, diag::kind D) { return IntEval.Error(E, D); }
 
-  OptionalDiagnostic CCEDiag(const Expr *E, diag::kind D) {
+  OptionalDiagnostic CCEDiag(Expr const *E, diag::kind D) {
     return Info.CCEDiag(E, D);
   }
 
   // Returns true if visiting the RHS is necessary, false otherwise.
-  bool VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
+  bool VisitBinOpLHSOnly(EvalResult &LHSResult, BinaryOperator const *E,
                          bool &SuppressRHSDiags);
 
-  bool VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
-                  const BinaryOperator *E, APValue &Result);
+  bool VisitBinOp(EvalResult const &LHSResult, EvalResult const &RHSResult,
+                  BinaryOperator const *E, APValue &Result);
 
-  void EvaluateExpr(const Expr *E, EvalResult &Result) {
+  void EvaluateExpr(Expr const *E, EvalResult &Result) {
     Result.Failed = !Evaluate(Result.Val, Info, E);
     if (Result.Failed)
       Result.Val = APValue();
@@ -12256,19 +12234,19 @@
 
   void process(EvalResult &Result);
 
-  void enqueue(const Expr *E) {
+  void enqueue(Expr const *E) {
     E = E->IgnoreParens();
-    Queue.resize(Queue.size()+1);
+    Queue.resize(Queue.size() + 1);
     Queue.back().E = E;
     Queue.back().Kind = Job::AnyExprKind;
   }
 };
 
-}
+} // namespace
 
-bool DataRecursiveIntBinOpEvaluator::
-       VisitBinOpLHSOnly(EvalResult &LHSResult, const BinaryOperator *E,
-                         bool &SuppressRHSDiags) {
+bool DataRecursiveIntBinOpEvaluator::VisitBinOpLHSOnly(EvalResult &LHSResult,
+                                                       BinaryOperator const *E,
+                                                       bool &SuppressRHSDiags) {
   if (E->getOpcode() == BO_Comma) {
     // Ignore LHS but note if we could not evaluate it.
     if (LHSResult.Failed)
@@ -12311,7 +12289,7 @@
   return true;
 }
 
-static void addOrSubLValueAsInteger(APValue &LVal, const APSInt &Index,
+static void addOrSubLValueAsInteger(APValue &LVal, APSInt const &Index,
                                     bool IsSub) {
   // Compute the new offset in the appropriate width, wrapping at 64 bits.
   // FIXME: When compiling for a 32-bit target, we should use 32-bit
@@ -12320,13 +12298,14 @@
   CharUnits &Offset = LVal.getLValueOffset();
   uint64_t Offset64 = Offset.getQuantity();
   uint64_t Index64 = Index.extOrTrunc(64).getZExtValue();
-  Offset = CharUnits::fromQuantity(IsSub ? Offset64 - Index64
-                                         : Offset64 + Index64);
+  Offset =
+      CharUnits::fromQuantity(IsSub ? Offset64 - Index64 : Offset64 + Index64);
 }
 
-bool DataRecursiveIntBinOpEvaluator::
-       VisitBinOp(const EvalResult &LHSResult, const EvalResult &RHSResult,
-                  const BinaryOperator *E, APValue &Result) {
+bool DataRecursiveIntBinOpEvaluator::VisitBinOp(EvalResult const &LHSResult,
+                                                EvalResult const &RHSResult,
+                                                BinaryOperator const *E,
+                                                APValue &Result) {
   if (E->getOpcode() == BO_Comma) {
     if (RHSResult.Failed)
       return false;
@@ -12364,8 +12343,8 @@
   if (LHSResult.Failed || RHSResult.Failed)
     return false;
 
-  const APValue &LHSVal = LHSResult.Val;
-  const APValue &RHSVal = RHSResult.Val;
+  APValue const &LHSVal = LHSResult.Val;
+  APValue const &RHSVal = RHSResult.Val;
 
   // Handle cases like (unsigned long)&a + 4.
   if (E->isAdditiveOp() && LHSVal.isLValue() && RHSVal.isInt()) {
@@ -12375,10 +12354,9 @@
   }
 
   // Handle cases like 4 + (unsigned long)&a
-  if (E->getOpcode() == BO_Add &&
-      RHSVal.isLValue() && LHSVal.isInt()) {
+  if (E->getOpcode() == BO_Add && RHSVal.isLValue() && LHSVal.isInt()) {
     Result = RHSVal;
-    addOrSubLValueAsInteger(Result, LHSVal.getInt(), /*IsSub*/false);
+    addOrSubLValueAsInteger(Result, LHSVal.getInt(), /*IsSub*/ false);
     return true;
   }
 
@@ -12387,12 +12365,12 @@
     if (!LHSVal.getLValueOffset().isZero() ||
         !RHSVal.getLValueOffset().isZero())
       return false;
-    const Expr *LHSExpr = LHSVal.getLValueBase().dyn_cast<const Expr*>();
-    const Expr *RHSExpr = RHSVal.getLValueBase().dyn_cast<const Expr*>();
+    Expr const *LHSExpr = LHSVal.getLValueBase().dyn_cast<Expr const *>();
+    Expr const *RHSExpr = RHSVal.getLValueBase().dyn_cast<Expr const *>();
     if (!LHSExpr || !RHSExpr)
       return false;
-    const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
-    const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
+    AddrLabelExpr const *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
+    AddrLabelExpr const *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
     if (!LHSAddrExpr || !RHSAddrExpr)
       return false;
     // Make sure both labels come from the same function.
@@ -12422,43 +12400,43 @@
   Job &job = Queue.back();
 
   switch (job.Kind) {
-    case Job::AnyExprKind: {
-      if (const BinaryOperator *Bop = dyn_cast<BinaryOperator>(job.E)) {
-        if (shouldEnqueue(Bop)) {
-          job.Kind = Job::BinOpKind;
-          enqueue(Bop->getLHS());
-          return;
-        }
-      }
-
-      EvaluateExpr(job.E, Result);
-      Queue.pop_back();
-      return;
-    }
-
-    case Job::BinOpKind: {
-      const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
-      bool SuppressRHSDiags = false;
-      if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) {
-        Queue.pop_back();
+  case Job::AnyExprKind: {
+    if (BinaryOperator const *Bop = dyn_cast<BinaryOperator>(job.E)) {
+      if (shouldEnqueue(Bop)) {
+        job.Kind = Job::BinOpKind;
+        enqueue(Bop->getLHS());
         return;
       }
-      if (SuppressRHSDiags)
-        job.startSpeculativeEval(Info);
-      job.LHSResult.swap(Result);
-      job.Kind = Job::BinOpVisitedLHSKind;
-      enqueue(Bop->getRHS());
-      return;
     }
 
-    case Job::BinOpVisitedLHSKind: {
-      const BinaryOperator *Bop = cast<BinaryOperator>(job.E);
-      EvalResult RHS;
-      RHS.swap(Result);
-      Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val);
+    EvaluateExpr(job.E, Result);
+    Queue.pop_back();
+    return;
+  }
+
+  case Job::BinOpKind: {
+    BinaryOperator const *Bop = cast<BinaryOperator>(job.E);
+    bool SuppressRHSDiags = false;
+    if (!VisitBinOpLHSOnly(Result, Bop, SuppressRHSDiags)) {
       Queue.pop_back();
       return;
     }
+    if (SuppressRHSDiags)
+      job.startSpeculativeEval(Info);
+    job.LHSResult.swap(Result);
+    job.Kind = Job::BinOpVisitedLHSKind;
+    enqueue(Bop->getRHS());
+    return;
+  }
+
+  case Job::BinOpVisitedLHSKind: {
+    BinaryOperator const *Bop = cast<BinaryOperator>(job.E);
+    EvalResult RHS;
+    RHS.swap(Result);
+    Result.Failed = !VisitBinOp(job.LHSResult, RHS, Bop, Result.Val);
+    Queue.pop_back();
+    return;
+  }
   }
 
   llvm_unreachable("Invalid Job::Kind!");
@@ -12476,14 +12454,14 @@
 
 template <class SuccessCB, class AfterCB>
 static bool
-EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E,
+EvaluateComparisonBinaryOperator(EvalInfo &Info, BinaryOperator const *E,
                                  SuccessCB &&Success, AfterCB &&DoAfter) {
   assert(!E->isValueDependent());
   assert(E->isComparisonOp() && "expected comparison operator");
   assert((E->getOpcode() == BO_Cmp ||
           E->getType()->isIntegralOrEnumerationType()) &&
          "unsupported binary expression evaluation");
-  auto Error = [&](const Expr *E) {
+  auto Error = [&](Expr const *E) {
     Info.FFDiag(E, diag::note_invalid_subexpr_in_const_expr);
     return false;
   };
@@ -12554,9 +12532,9 @@
 
     if (LHS.isComplexFloat()) {
       APFloat::cmpResult CR_r =
-        LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal());
+          LHS.getComplexFloatReal().compare(RHS.getComplexFloatReal());
       APFloat::cmpResult CR_i =
-        LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag());
+          LHS.getComplexFloatImag().compare(RHS.getComplexFloatImag());
       bool IsEqual = CR_r == APFloat::cmpEqual && CR_i == APFloat::cmpEqual;
       return Success(IsEqual ? CmpResult::Equal : CmpResult::Unequal, E);
     } else {
@@ -12567,8 +12545,7 @@
     }
   }
 
-  if (LHSTy->isRealFloatingType() &&
-      RHSTy->isRealFloatingType()) {
+  if (LHSTy->isRealFloatingType() && RHSTy->isRealFloatingType()) {
     APFloat RHS(0.0), LHS(0.0);
 
     bool LHSOK = EvaluateFloat(E->getRHS(), RHS, Info);
@@ -12580,8 +12557,7 @@
 
     assert(E->isComparisonOp() && "Invalid binary operator!");
     llvm::APFloatBase::cmpResult APFloatCmpResult = LHS.compare(RHS);
-    if (!Info.InConstantContext &&
-        APFloatCmpResult == APFloat::cmpUnordered &&
+    if (!Info.InConstantContext && APFloatCmpResult == APFloat::cmpUnordered &&
         E->getFPFeaturesInEffect(Info.Ctx.getLangOpts()).isFPConstrained()) {
       // Note: Compares may raise invalid in some cases involving NaN or sNaN.
       Info.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);
@@ -12654,8 +12630,8 @@
       return Success(CmpResult::Unequal, E);
     }
 
-    const CharUnits &LHSOffset = LHSValue.getLValueOffset();
-    const CharUnits &RHSOffset = RHSValue.getLValueOffset();
+    CharUnits const &LHSOffset = LHSValue.getLValueOffset();
+    CharUnits const &RHSOffset = RHSValue.getLValueOffset();
 
     SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
     SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
@@ -12690,8 +12666,8 @@
       // 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]);
+        FieldDecl const *LF = getAsField(LHSDesignator.Entries[Mismatch]);
+        FieldDecl const *RF = getAsField(RHSDesignator.Entries[Mismatch]);
         if (!LF && !RF)
           Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes);
         else if (!LF)
@@ -12764,10 +12740,10 @@
 
     //   Otherwise if either is a pointer to a virtual member function, the
     //   result is unspecified.
-    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl()))
+    if (CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl()))
       if (MD->isVirtual())
         Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
-    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl()))
+    if (CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl()))
       if (MD->isVirtual())
         Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;
 
@@ -12791,11 +12767,11 @@
   return DoAfter();
 }
 
-bool RecordExprEvaluator::VisitBinCmp(const BinaryOperator *E) {
+bool RecordExprEvaluator::VisitBinCmp(BinaryOperator const *E) {
   if (!CheckLiteralType(Info, E))
     return false;
 
-  auto OnSuccess = [&](CmpResult CR, const BinaryOperator *E) {
+  auto OnSuccess = [&](CmpResult CR, BinaryOperator const *E) {
     ComparisonCategoryResult CCR;
     switch (CR) {
     case CmpResult::Unequal:
@@ -12831,7 +12807,7 @@
   });
 }
 
-bool IntExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
+bool IntExprEvaluator::VisitBinaryOperator(BinaryOperator const *E) {
   // We don't support assignment in C. C++ assignments don't get here because
   // assignment is an lvalue in C++.
   if (E->isAssignmentOp()) {
@@ -12850,11 +12826,10 @@
   if (E->isComparisonOp()) {
     // Evaluate builtin binary comparisons by evaluating them as three-way
     // comparisons and then translating the result.
-    auto OnSuccess = [&](CmpResult CR, const BinaryOperator *E) {
+    auto OnSuccess = [&](CmpResult CR, BinaryOperator const *E) {
       assert((CR != CmpResult::Unequal || E->isEqualityOp()) &&
              "should only produce Unequal for equality comparisons");
-      bool IsEqual   = CR == CmpResult::Equal,
-           IsLess    = CR == CmpResult::Less,
+      bool IsEqual = CR == CmpResult::Equal, IsLess = CR == CmpResult::Less,
            IsGreater = CR == CmpResult::Greater;
       auto Op = E->getOpcode();
       switch (Op) {
@@ -12898,12 +12873,12 @@
       // Handle &&A - &&B.
       if (!LHSValue.Offset.isZero() || !RHSValue.Offset.isZero())
         return Error(E);
-      const Expr *LHSExpr = LHSValue.Base.dyn_cast<const Expr *>();
-      const Expr *RHSExpr = RHSValue.Base.dyn_cast<const Expr *>();
+      Expr const *LHSExpr = LHSValue.Base.dyn_cast<Expr const *>();
+      Expr const *RHSExpr = RHSValue.Base.dyn_cast<Expr const *>();
       if (!LHSExpr || !RHSExpr)
         return Error(E);
-      const AddrLabelExpr *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
-      const AddrLabelExpr *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
+      AddrLabelExpr const *LHSAddrExpr = dyn_cast<AddrLabelExpr>(LHSExpr);
+      AddrLabelExpr const *RHSAddrExpr = dyn_cast<AddrLabelExpr>(RHSExpr);
       if (!LHSAddrExpr || !RHSAddrExpr)
         return Error(E);
       // Make sure both labels come from the same function.
@@ -12912,8 +12887,8 @@
         return Error(E);
       return Success(APValue(LHSAddrExpr, RHSAddrExpr), E);
     }
-    const CharUnits &LHSOffset = LHSValue.getLValueOffset();
-    const CharUnits &RHSOffset = RHSValue.getLValueOffset();
+    CharUnits const &LHSOffset = LHSValue.getLValueOffset();
+    CharUnits const &RHSOffset = RHSValue.getLValueOffset();
 
     SubobjectDesignator &LHSDesignator = LHSValue.getLValueDesignator();
     SubobjectDesignator &RHSDesignator = RHSValue.getLValueDesignator();
@@ -12970,8 +12945,8 @@
 /// VisitUnaryExprOrTypeTraitExpr - Evaluate a sizeof, alignof or vec_step with
 /// a result as the expression's type.
 bool IntExprEvaluator::VisitUnaryExprOrTypeTraitExpr(
-                                    const UnaryExprOrTypeTraitExpr *E) {
-  switch(E->getKind()) {
+    UnaryExprOrTypeTraitExpr const *E) {
+  switch (E->getKind()) {
   case UETT_PreferredAlignOf:
   case UETT_AlignOf: {
     if (E->isArgumentType())
@@ -13002,7 +12977,7 @@
     QualType SrcTy = E->getTypeOfArgument();
     // C++ [expr.sizeof]p2: "When applied to a reference or a reference type,
     //   the result is the size of the referenced type."
-    if (const ReferenceType *Ref = SrcTy->getAs<ReferenceType>())
+    if (ReferenceType const *Ref = SrcTy->getAs<ReferenceType>())
       SrcTy = Ref->getPointeeType();
 
     CharUnits Sizeof;
@@ -13012,17 +12987,17 @@
   }
   case UETT_OpenMPRequiredSimdAlign:
     assert(E->isArgumentType());
-    return Success(
-        Info.Ctx.toCharUnitsFromBits(
-                    Info.Ctx.getOpenMPDefaultSimdAlign(E->getArgumentType()))
-            .getQuantity(),
-        E);
+    return Success(Info.Ctx
+                       .toCharUnitsFromBits(Info.Ctx.getOpenMPDefaultSimdAlign(
+                           E->getArgumentType()))
+                       .getQuantity(),
+                   E);
   }
 
   llvm_unreachable("unknown expr/type trait");
 }
 
-bool IntExprEvaluator::VisitOffsetOfExpr(const OffsetOfExpr *OOE) {
+bool IntExprEvaluator::VisitOffsetOfExpr(OffsetOfExpr const *OOE) {
   CharUnits Result;
   unsigned n = OOE->getNumComponents();
   if (n == 0)
@@ -13032,11 +13007,11 @@
     OffsetOfNode ON = OOE->getComponent(i);
     switch (ON.getKind()) {
     case OffsetOfNode::Array: {
-      const Expr *Idx = OOE->getIndexExpr(ON.getArrayExprIndex());
+      Expr const *Idx = OOE->getIndexExpr(ON.getArrayExprIndex());
       APSInt IdxResult;
       if (!EvaluateInteger(Idx, IdxResult, Info))
         return false;
-      const ArrayType *AT = Info.Ctx.getAsArrayType(CurrentType);
+      ArrayType const *AT = Info.Ctx.getAsArrayType(CurrentType);
       if (!AT)
         return Error(OOE);
       CurrentType = AT->getElementType();
@@ -13047,12 +13022,13 @@
 
     case OffsetOfNode::Field: {
       FieldDecl *MemberDecl = ON.getField();
-      const RecordType *RT = CurrentType->getAs<RecordType>();
+      RecordType const *RT = CurrentType->getAs<RecordType>();
       if (!RT)
         return Error(OOE);
       RecordDecl *RD = RT->getDecl();
-      if (RD->isInvalidDecl()) return false;
-      const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
+      if (RD->isInvalidDecl())
+        return false;
+      ASTRecordLayout const &RL = Info.Ctx.getASTRecordLayout(RD);
       unsigned i = MemberDecl->getFieldIndex();
       assert(i < RL.getFieldCount() && "offsetof field in wrong type");
       Result += Info.Ctx.toCharUnitsFromBits(RL.getFieldOffset(i));
@@ -13069,16 +13045,17 @@
         return Error(OOE);
 
       // Find the layout of the class whose base we are looking into.
-      const RecordType *RT = CurrentType->getAs<RecordType>();
+      RecordType const *RT = CurrentType->getAs<RecordType>();
       if (!RT)
         return Error(OOE);
       RecordDecl *RD = RT->getDecl();
-      if (RD->isInvalidDecl()) return false;
-      const ASTRecordLayout &RL = Info.Ctx.getASTRecordLayout(RD);
+      if (RD->isInvalidDecl())
+        return false;
+      ASTRecordLayout const &RL = Info.Ctx.getASTRecordLayout(RD);
 
       // Find the base class itself.
       CurrentType = BaseSpec->getType();
-      const RecordType *BaseRT = CurrentType->getAs<RecordType>();
+      RecordType const *BaseRT = CurrentType->getAs<RecordType>();
       if (!BaseRT)
         return Error(OOE);
 
@@ -13091,7 +13068,7 @@
   return Success(Result, OOE);
 }
 
-bool IntExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
+bool IntExprEvaluator::VisitUnaryOperator(UnaryOperator const *E) {
   switch (E->getOpcode()) {
   default:
     // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
@@ -13107,8 +13084,9 @@
   case UO_Minus: {
     if (!Visit(E->getSubExpr()))
       return false;
-    if (!Result.isInt()) return Error(E);
-    const APSInt &Value = Result.getInt();
+    if (!Result.isInt())
+      return Error(E);
+    APSInt const &Value = Result.getInt();
     if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow() &&
         !HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1),
                         E->getType()))
@@ -13118,7 +13096,8 @@
   case UO_Not: {
     if (!Visit(E->getSubExpr()))
       return false;
-    if (!Result.isInt()) return Error(E);
+    if (!Result.isInt())
+      return Error(E);
     return Success(~Result.getInt(), E);
   }
   case UO_LNot: {
@@ -13132,8 +13111,8 @@
 
 /// HandleCast - This is used to evaluate implicit or explicit casts where the
 /// result type is integer.
-bool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {
-  const Expr *SubExpr = E->getSubExpr();
+bool IntExprEvaluator::VisitCastExpr(CastExpr const *E) {
+  Expr const *SubExpr = E->getSubExpr();
   QualType DestType = E->getType();
   QualType SrcType = SubExpr->getType();
 
@@ -13249,8 +13228,8 @@
       return Info.Ctx.getTypeSize(DestType) == Info.Ctx.getTypeSize(SrcType);
     }
 
-    return Success(HandleIntToIntCast(Info, E, DestType, SrcType,
-                                      Result.getInt()), E);
+    return Success(
+        HandleIntToIntCast(Info, E, DestType, SrcType, Result.getInt()), E);
   }
 
   case CK_PointerToIntegral: {
@@ -13304,7 +13283,7 @@
   llvm_unreachable("unknown cast resulting in integral value");
 }
 
-bool IntExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
+bool IntExprEvaluator::VisitUnaryReal(UnaryOperator const *E) {
   if (E->getSubExpr()->getType()->isAnyComplexType()) {
     ComplexValue LV;
     if (!EvaluateComplex(E->getSubExpr(), LV, Info))
@@ -13317,7 +13296,7 @@
   return Visit(E->getSubExpr());
 }
 
-bool IntExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
+bool IntExprEvaluator::VisitUnaryImag(UnaryOperator const *E) {
   if (E->getSubExpr()->getType()->isComplexIntegerType()) {
     ComplexValue LV;
     if (!EvaluateComplex(E->getSubExpr(), LV, Info))
@@ -13331,52 +13310,53 @@
   return Success(0, E);
 }
 
-bool IntExprEvaluator::VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
+bool IntExprEvaluator::VisitSizeOfPackExpr(SizeOfPackExpr const *E) {
   return Success(E->getPackLength(), E);
 }
 
-bool IntExprEvaluator::VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
+bool IntExprEvaluator::VisitCXXNoexceptExpr(CXXNoexceptExpr const *E) {
   return Success(E->getValue(), E);
 }
 
 bool IntExprEvaluator::VisitConceptSpecializationExpr(
-       const ConceptSpecializationExpr *E) {
+    ConceptSpecializationExpr const *E) {
   return Success(E->isSatisfied(), E);
 }
 
-bool IntExprEvaluator::VisitRequiresExpr(const RequiresExpr *E) {
+bool IntExprEvaluator::VisitRequiresExpr(RequiresExpr const *E) {
   return Success(E->isSatisfied(), E);
 }
 
-bool FixedPointExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
+bool FixedPointExprEvaluator::VisitUnaryOperator(UnaryOperator const *E) {
   switch (E->getOpcode()) {
-    default:
-      // Invalid unary operators
+  default:
+    // Invalid unary operators
+    return Error(E);
+  case UO_Plus:
+    // The result is just the value.
+    return Visit(E->getSubExpr());
+  case UO_Minus: {
+    if (!Visit(E->getSubExpr()))
+      return false;
+    if (!Result.isFixedPoint())
       return Error(E);
-    case UO_Plus:
-      // The result is just the value.
-      return Visit(E->getSubExpr());
-    case UO_Minus: {
-      if (!Visit(E->getSubExpr())) return false;
-      if (!Result.isFixedPoint())
-        return Error(E);
-      bool Overflowed;
-      APFixedPoint Negated = Result.getFixedPoint().negate(&Overflowed);
-      if (Overflowed && !HandleOverflow(Info, E, Negated, E->getType()))
-        return false;
-      return Success(Negated, E);
-    }
-    case UO_LNot: {
-      bool bres;
-      if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
-        return false;
-      return Success(!bres, E);
-    }
+    bool Overflowed;
+    APFixedPoint Negated = Result.getFixedPoint().negate(&Overflowed);
+    if (Overflowed && !HandleOverflow(Info, E, Negated, E->getType()))
+      return false;
+    return Success(Negated, E);
+  }
+  case UO_LNot: {
+    bool bres;
+    if (!EvaluateAsBooleanCondition(E->getSubExpr(), bres, Info))
+      return false;
+    return Success(!bres, E);
+  }
   }
 }
 
-bool FixedPointExprEvaluator::VisitCastExpr(const CastExpr *E) {
-  const Expr *SubExpr = E->getSubExpr();
+bool FixedPointExprEvaluator::VisitCastExpr(CastExpr const *E) {
+  Expr const *SubExpr = E->getSubExpr();
   QualType DestType = E->getType();
   assert(DestType->isFixedPointType() &&
          "Expected destination type to be a fixed point type");
@@ -13391,9 +13371,9 @@
     APFixedPoint Result = Src.convert(DestFXSema, &Overflowed);
     if (Overflowed) {
       if (Info.checkingForUndefinedBehavior())
-        Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
-                                         diag::warn_fixedpoint_constant_overflow)
-          << Result.toString() << E->getType();
+        Info.Ctx.getDiagnostics().Report(
+            E->getExprLoc(), diag::warn_fixedpoint_constant_overflow)
+            << Result.toString() << E->getType();
       if (!HandleOverflow(Info, E, Result, E->getType()))
         return false;
     }
@@ -13410,9 +13390,9 @@
 
     if (Overflowed) {
       if (Info.checkingForUndefinedBehavior())
-        Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
-                                         diag::warn_fixedpoint_constant_overflow)
-          << IntResult.toString() << E->getType();
+        Info.Ctx.getDiagnostics().Report(
+            E->getExprLoc(), diag::warn_fixedpoint_constant_overflow)
+            << IntResult.toString() << E->getType();
       if (!HandleOverflow(Info, E, IntResult, E->getType()))
         return false;
     }
@@ -13430,9 +13410,9 @@
 
     if (Overflowed) {
       if (Info.checkingForUndefinedBehavior())
-        Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
-                                         diag::warn_fixedpoint_constant_overflow)
-          << Result.toString() << E->getType();
+        Info.Ctx.getDiagnostics().Report(
+            E->getExprLoc(), diag::warn_fixedpoint_constant_overflow)
+            << Result.toString() << E->getType();
       if (!HandleOverflow(Info, E, Result, E->getType()))
         return false;
     }
@@ -13447,12 +13427,12 @@
   }
 }
 
-bool FixedPointExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
+bool FixedPointExprEvaluator::VisitBinaryOperator(BinaryOperator const *E) {
   if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
     return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
 
-  const Expr *LHS = E->getLHS();
-  const Expr *RHS = E->getRHS();
+  Expr const *LHS = E->getLHS();
+  Expr const *RHS = E->getRHS();
   FixedPointSemantics ResultFXSema =
       Info.Ctx.getFixedPointSemantics(E->getType());
 
@@ -13468,17 +13448,17 @@
   switch (E->getOpcode()) {
   case BO_Add: {
     Result = LHSFX.add(RHSFX, &OpOverflow)
-                  .convert(ResultFXSema, &ConversionOverflow);
+                 .convert(ResultFXSema, &ConversionOverflow);
     break;
   }
   case BO_Sub: {
     Result = LHSFX.sub(RHSFX, &OpOverflow)
-                  .convert(ResultFXSema, &ConversionOverflow);
+                 .convert(ResultFXSema, &ConversionOverflow);
     break;
   }
   case BO_Mul: {
     Result = LHSFX.mul(RHSFX, &OpOverflow)
-                  .convert(ResultFXSema, &ConversionOverflow);
+                 .convert(ResultFXSema, &ConversionOverflow);
     break;
   }
   case BO_Div: {
@@ -13487,7 +13467,7 @@
       return false;
     }
     Result = LHSFX.div(RHSFX, &OpOverflow)
-                  .convert(ResultFXSema, &ConversionOverflow);
+                 .convert(ResultFXSema, &ConversionOverflow);
     break;
   }
   case BO_Shl:
@@ -13520,7 +13500,7 @@
     if (Info.checkingForUndefinedBehavior())
       Info.Ctx.getDiagnostics().Report(E->getExprLoc(),
                                        diag::warn_fixedpoint_constant_overflow)
-        << Result.toString() << E->getType();
+          << Result.toString() << E->getType();
     if (!HandleOverflow(Info, E, Result, E->getType()))
       return false;
   }
@@ -13532,52 +13512,51 @@
 //===----------------------------------------------------------------------===//
 
 namespace {
-class FloatExprEvaluator
-  : public ExprEvaluatorBase<FloatExprEvaluator> {
+class FloatExprEvaluator : public ExprEvaluatorBase<FloatExprEvaluator> {
   APFloat &Result;
+
 public:
   FloatExprEvaluator(EvalInfo &info, APFloat &result)
-    : ExprEvaluatorBaseTy(info), Result(result) {}
+      : ExprEvaluatorBaseTy(info), Result(result) {}
 
-  bool Success(const APValue &V, const Expr *e) {
+  bool Success(APValue const &V, Expr const *e) {
     Result = V.getFloat();
     return true;
   }
 
-  bool ZeroInitialization(const Expr *E) {
+  bool ZeroInitialization(Expr const *E) {
     Result = APFloat::getZero(Info.Ctx.getFloatTypeSemantics(E->getType()));
     return true;
   }
 
-  bool VisitCallExpr(const CallExpr *E);
+  bool VisitCallExpr(CallExpr const *E);
 
-  bool VisitUnaryOperator(const UnaryOperator *E);
-  bool VisitBinaryOperator(const BinaryOperator *E);
-  bool VisitFloatingLiteral(const FloatingLiteral *E);
-  bool VisitCastExpr(const CastExpr *E);
+  bool VisitUnaryOperator(UnaryOperator const *E);
+  bool VisitBinaryOperator(BinaryOperator const *E);
+  bool VisitFloatingLiteral(FloatingLiteral const *E);
+  bool VisitCastExpr(CastExpr const *E);
 
-  bool VisitUnaryReal(const UnaryOperator *E);
-  bool VisitUnaryImag(const UnaryOperator *E);
+  bool VisitUnaryReal(UnaryOperator const *E);
+  bool VisitUnaryImag(UnaryOperator const *E);
 
   // FIXME: Missing: array subscript of vector, member of vector
 };
 } // end anonymous namespace
 
-static bool EvaluateFloat(const Expr* E, APFloat& Result, EvalInfo &Info) {
+static bool EvaluateFloat(Expr const *E, APFloat &Result, EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isRealFloatingType());
   return FloatExprEvaluator(Info, Result).Visit(E);
 }
 
-static bool TryEvaluateBuiltinNaN(const ASTContext &Context,
-                                  QualType ResultTy,
-                                  const Expr *Arg,
-                                  bool SNaN,
+static bool TryEvaluateBuiltinNaN(ASTContext const &Context, QualType ResultTy,
+                                  Expr const *Arg, bool SNaN,
                                   llvm::APFloat &Result) {
-  const StringLiteral *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
-  if (!S) return false;
+  StringLiteral const *S = dyn_cast<StringLiteral>(Arg->IgnoreParenCasts());
+  if (!S)
+    return false;
 
-  const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(ResultTy);
+  llvm::fltSemantics const &Sem = Context.getFloatTypeSemantics(ResultTy);
 
   llvm::APInt fill;
 
@@ -13607,7 +13586,7 @@
   return true;
 }
 
-bool FloatExprEvaluator::VisitCallExpr(const CallExpr *E) {
+bool FloatExprEvaluator::VisitCallExpr(CallExpr const *E) {
   switch (E->getBuiltinCallee()) {
   default:
     return ExprEvaluatorBaseTy::VisitCallExpr(E);
@@ -13620,8 +13599,8 @@
   case Builtin::BI__builtin_inff:
   case Builtin::BI__builtin_infl:
   case Builtin::BI__builtin_inff128: {
-    const llvm::fltSemantics &Sem =
-      Info.Ctx.getFloatTypeSemantics(E->getType());
+    llvm::fltSemantics const &Sem =
+        Info.Ctx.getFloatTypeSemantics(E->getType());
     Result = llvm::APFloat::getInf(Sem);
     return true;
   }
@@ -13630,8 +13609,8 @@
   case Builtin::BI__builtin_nansf:
   case Builtin::BI__builtin_nansl:
   case Builtin::BI__builtin_nansf128:
-    if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
-                               true, Result))
+    if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0), true,
+                               Result))
       return Error(E);
     return true;
 
@@ -13641,8 +13620,8 @@
   case Builtin::BI__builtin_nanf128:
     // If this is __builtin_nan() turn this into a nan, otherwise we
     // can't constant fold it.
-    if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0),
-                               false, Result))
+    if (!TryEvaluateBuiltinNaN(Info.Ctx, E->getType(), E->getArg(0), false,
+                               Result))
       return Error(E);
     return true;
 
@@ -13665,9 +13644,9 @@
   case Builtin::BI__arithmetic_fence:
     return EvaluateFloat(E->getArg(0), Result, Info);
 
-  // FIXME: Builtin::BI__builtin_powi
-  // FIXME: Builtin::BI__builtin_powif
-  // FIXME: Builtin::BI__builtin_powil
+    // FIXME: Builtin::BI__builtin_powi
+    // FIXME: Builtin::BI__builtin_powif
+    // FIXME: Builtin::BI__builtin_powil
 
   case Builtin::BI__builtin_copysign:
   case Builtin::BI__builtin_copysignf:
@@ -13683,7 +13662,7 @@
   }
 }
 
-bool FloatExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
+bool FloatExprEvaluator::VisitUnaryReal(UnaryOperator const *E) {
   if (E->getSubExpr()->getType()->isAnyComplexType()) {
     ComplexValue CV;
     if (!EvaluateComplex(E->getSubExpr(), CV, Info))
@@ -13695,7 +13674,7 @@
   return Visit(E->getSubExpr());
 }
 
-bool FloatExprEvaluator::VisitUnaryImag(const UnaryOperator *E) {
+bool FloatExprEvaluator::VisitUnaryImag(UnaryOperator const *E) {
   if (E->getSubExpr()->getType()->isAnyComplexType()) {
     ComplexValue CV;
     if (!EvaluateComplex(E->getSubExpr(), CV, Info))
@@ -13705,14 +13684,15 @@
   }
 
   VisitIgnoredValue(E->getSubExpr());
-  const llvm::fltSemantics &Sem = Info.Ctx.getFloatTypeSemantics(E->getType());
+  llvm::fltSemantics const &Sem = Info.Ctx.getFloatTypeSemantics(E->getType());
   Result = llvm::APFloat::getZero(Sem);
   return true;
 }
 
-bool FloatExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
+bool FloatExprEvaluator::VisitUnaryOperator(UnaryOperator const *E) {
   switch (E->getOpcode()) {
-  default: return Error(E);
+  default:
+    return Error(E);
   case UO_Plus:
     return EvaluateFloat(E->getSubExpr(), Result, Info);
   case UO_Minus:
@@ -13726,7 +13706,7 @@
   }
 }
 
-bool FloatExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
+bool FloatExprEvaluator::VisitBinaryOperator(BinaryOperator const *E) {
   if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
     return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
 
@@ -13738,13 +13718,13 @@
          handleFloatFloatBinOp(Info, E, Result, E->getOpcode(), RHS);
 }
 
-bool FloatExprEvaluator::VisitFloatingLiteral(const FloatingLiteral *E) {
+bool FloatExprEvaluator::VisitFloatingLiteral(FloatingLiteral const *E) {
   Result = E->getValue();
   return true;
 }
 
-bool FloatExprEvaluator::VisitCastExpr(const CastExpr *E) {
-  const Expr* SubExpr = E->getSubExpr();
+bool FloatExprEvaluator::VisitCastExpr(CastExpr const *E) {
+  Expr const *SubExpr = E->getSubExpr();
 
   switch (E->getCastKind()) {
   default:
@@ -13752,11 +13732,10 @@
 
   case CK_IntegralToFloating: {
     APSInt IntResult;
-    const FPOptions FPO = E->getFPFeaturesInEffect(
-                                  Info.Ctx.getLangOpts());
+    const FPOptions FPO = E->getFPFeaturesInEffect(Info.Ctx.getLangOpts());
     return EvaluateInteger(SubExpr, IntResult, Info) &&
-           HandleIntToFloatCast(Info, E, FPO, SubExpr->getType(),
-                                IntResult, E->getType(), Result);
+           HandleIntToFloatCast(Info, E, FPO, SubExpr->getType(), IntResult,
+                                E->getType(), Result);
   }
 
   case CK_FixedPointToFloating: {
@@ -13790,42 +13769,41 @@
 //===----------------------------------------------------------------------===//
 
 namespace {
-class ComplexExprEvaluator
-  : public ExprEvaluatorBase<ComplexExprEvaluator> {
+class ComplexExprEvaluator : public ExprEvaluatorBase<ComplexExprEvaluator> {
   ComplexValue &Result;
 
 public:
   ComplexExprEvaluator(EvalInfo &info, ComplexValue &Result)
-    : ExprEvaluatorBaseTy(info), Result(Result) {}
+      : ExprEvaluatorBaseTy(info), Result(Result) {}
 
-  bool Success(const APValue &V, const Expr *e) {
+  bool Success(APValue const &V, Expr const *e) {
     Result.setFrom(V);
     return true;
   }
 
-  bool ZeroInitialization(const Expr *E);
+  bool ZeroInitialization(Expr const *E);
 
   //===--------------------------------------------------------------------===//
   //                            Visitor Methods
   //===--------------------------------------------------------------------===//
 
-  bool VisitImaginaryLiteral(const ImaginaryLiteral *E);
-  bool VisitCastExpr(const CastExpr *E);
-  bool VisitBinaryOperator(const BinaryOperator *E);
-  bool VisitUnaryOperator(const UnaryOperator *E);
-  bool VisitInitListExpr(const InitListExpr *E);
-  bool VisitCallExpr(const CallExpr *E);
+  bool VisitImaginaryLiteral(ImaginaryLiteral const *E);
+  bool VisitCastExpr(CastExpr const *E);
+  bool VisitBinaryOperator(BinaryOperator const *E);
+  bool VisitUnaryOperator(UnaryOperator const *E);
+  bool VisitInitListExpr(InitListExpr const *E);
+  bool VisitCallExpr(CallExpr const *E);
 };
 } // end anonymous namespace
 
-static bool EvaluateComplex(const Expr *E, ComplexValue &Result,
+static bool EvaluateComplex(Expr const *E, ComplexValue &Result,
                             EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isAnyComplexType());
   return ComplexExprEvaluator(Info, Result).Visit(E);
 }
 
-bool ComplexExprEvaluator::ZeroInitialization(const Expr *E) {
+bool ComplexExprEvaluator::ZeroInitialization(Expr const *E) {
   QualType ElemTy = E->getType()->castAs<ComplexType>()->getElementType();
   if (ElemTy->isRealFloatingType()) {
     Result.makeComplexFloat();
@@ -13841,8 +13819,8 @@
   return true;
 }
 
-bool ComplexExprEvaluator::VisitImaginaryLiteral(const ImaginaryLiteral *E) {
-  const Expr* SubExpr = E->getSubExpr();
+bool ComplexExprEvaluator::VisitImaginaryLiteral(ImaginaryLiteral const *E) {
+  Expr const *SubExpr = E->getSubExpr();
 
   if (SubExpr->getType()->isRealFloatingType()) {
     Result.makeComplexFloat();
@@ -13866,7 +13844,7 @@
   }
 }
 
-bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) {
+bool ComplexExprEvaluator::VisitCastExpr(CastExpr const *E) {
 
   switch (E->getCastKind()) {
   case CK_BitCast:
@@ -13949,8 +13927,8 @@
       return false;
 
     QualType To = E->getType()->castAs<ComplexType>()->getElementType();
-    QualType From
-      = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
+    QualType From =
+        E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
 
     return HandleFloatToFloatCast(Info, E, From, To, Result.FloatReal) &&
            HandleFloatToFloatCast(Info, E, From, To, Result.FloatImag);
@@ -13961,13 +13939,13 @@
       return false;
 
     QualType To = E->getType()->castAs<ComplexType>()->getElementType();
-    QualType From
-      = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
+    QualType From =
+        E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
     Result.makeComplexInt();
-    return HandleFloatToIntCast(Info, E, From, Result.FloatReal,
-                                To, Result.IntReal) &&
-           HandleFloatToIntCast(Info, E, From, Result.FloatImag,
-                                To, Result.IntImag);
+    return HandleFloatToIntCast(Info, E, From, Result.FloatReal, To,
+                                Result.IntReal) &&
+           HandleFloatToIntCast(Info, E, From, Result.FloatImag, To,
+                                Result.IntImag);
   }
 
   case CK_IntegralRealToComplex: {
@@ -13985,8 +13963,8 @@
       return false;
 
     QualType To = E->getType()->castAs<ComplexType>()->getElementType();
-    QualType From
-      = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
+    QualType From =
+        E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
 
     Result.IntReal = HandleIntToIntCast(Info, E, To, From, Result.IntReal);
     Result.IntImag = HandleIntToIntCast(Info, E, To, From, Result.IntImag);
@@ -13997,23 +13975,22 @@
     if (!Visit(E->getSubExpr()))
       return false;
 
-    const FPOptions FPO = E->getFPFeaturesInEffect(
-                                  Info.Ctx.getLangOpts());
+    const FPOptions FPO = E->getFPFeaturesInEffect(Info.Ctx.getLangOpts());
     QualType To = E->getType()->castAs<ComplexType>()->getElementType();
-    QualType From
-      = E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
+    QualType From =
+        E->getSubExpr()->getType()->castAs<ComplexType>()->getElementType();
     Result.makeComplexFloat();
-    return HandleIntToFloatCast(Info, E, FPO, From, Result.IntReal,
-                                To, Result.FloatReal) &&
-           HandleIntToFloatCast(Info, E, FPO, From, Result.IntImag,
-                                To, Result.FloatImag);
+    return HandleIntToFloatCast(Info, E, FPO, From, Result.IntReal, To,
+                                Result.FloatReal) &&
+           HandleIntToFloatCast(Info, E, FPO, From, Result.IntImag, To,
+                                Result.FloatImag);
   }
   }
 
   llvm_unreachable("unknown cast resulting in complex value");
 }
 
-bool ComplexExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {
+bool ComplexExprEvaluator::VisitBinaryOperator(BinaryOperator const *E) {
   if (E->isPtrMemOp() || E->isAssignmentOp() || E->getOpcode() == BO_Comma)
     return ExprEvaluatorBaseTy::VisitBinaryOperator(E);
 
@@ -14050,7 +14027,8 @@
   assert(!(LHSReal && RHSReal) &&
          "Cannot have both operands of a complex operation be real.");
   switch (E->getOpcode()) {
-  default: return Error(E);
+  default:
+    return Error(E);
   case BO_Add:
     if (Result.isComplexFloat()) {
       Result.getComplexFloatReal().add(RHS.getComplexFloatReal(),
@@ -14155,11 +14133,11 @@
     } else {
       ComplexValue LHS = Result;
       Result.getComplexIntReal() =
-        (LHS.getComplexIntReal() * RHS.getComplexIntReal() -
-         LHS.getComplexIntImag() * RHS.getComplexIntImag());
+          (LHS.getComplexIntReal() * RHS.getComplexIntReal() -
+           LHS.getComplexIntImag() * RHS.getComplexIntImag());
       Result.getComplexIntImag() =
-        (LHS.getComplexIntReal() * RHS.getComplexIntImag() +
-         LHS.getComplexIntImag() * RHS.getComplexIntReal());
+          (LHS.getComplexIntReal() * RHS.getComplexIntImag() +
+           LHS.getComplexIntImag() * RHS.getComplexIntReal());
     }
     break;
   case BO_Div:
@@ -14223,13 +14201,15 @@
 
       ComplexValue LHS = Result;
       APSInt Den = RHS.getComplexIntReal() * RHS.getComplexIntReal() +
-        RHS.getComplexIntImag() * RHS.getComplexIntImag();
+                   RHS.getComplexIntImag() * RHS.getComplexIntImag();
       Result.getComplexIntReal() =
-        (LHS.getComplexIntReal() * RHS.getComplexIntReal() +
-         LHS.getComplexIntImag() * RHS.getComplexIntImag()) / Den;
+          (LHS.getComplexIntReal() * RHS.getComplexIntReal() +
+           LHS.getComplexIntImag() * RHS.getComplexIntImag()) /
+          Den;
       Result.getComplexIntImag() =
-        (LHS.getComplexIntImag() * RHS.getComplexIntReal() -
-         LHS.getComplexIntReal() * RHS.getComplexIntImag()) / Den;
+          (LHS.getComplexIntImag() * RHS.getComplexIntReal() -
+           LHS.getComplexIntReal() * RHS.getComplexIntImag()) /
+          Den;
     }
     break;
   }
@@ -14237,7 +14217,7 @@
   return true;
 }
 
-bool ComplexExprEvaluator::VisitUnaryOperator(const UnaryOperator *E) {
+bool ComplexExprEvaluator::VisitUnaryOperator(UnaryOperator const *E) {
   // Get the operand value into 'Result'.
   if (!Visit(E->getSubExpr()))
     return false;
@@ -14254,8 +14234,7 @@
     if (Result.isComplexFloat()) {
       Result.getComplexFloatReal().changeSign();
       Result.getComplexFloatImag().changeSign();
-    }
-    else {
+    } else {
       Result.getComplexIntReal() = -Result.getComplexIntReal();
       Result.getComplexIntImag() = -Result.getComplexIntImag();
     }
@@ -14269,7 +14248,7 @@
   }
 }
 
-bool ComplexExprEvaluator::VisitInitListExpr(const InitListExpr *E) {
+bool ComplexExprEvaluator::VisitInitListExpr(InitListExpr const *E) {
   if (E->getNumInits() == 2) {
     if (E->getType()->isComplexType()) {
       Result.makeComplexFloat();
@@ -14289,7 +14268,7 @@
   return ExprEvaluatorBaseTy::VisitInitListExpr(E);
 }
 
-bool ComplexExprEvaluator::VisitCallExpr(const CallExpr *E) {
+bool ComplexExprEvaluator::VisitCallExpr(CallExpr const *E) {
   switch (E->getBuiltinCallee()) {
   case Builtin::BI__builtin_complex:
     Result.makeComplexFloat();
@@ -14312,20 +14291,20 @@
 //===----------------------------------------------------------------------===//
 
 namespace {
-class AtomicExprEvaluator :
-    public ExprEvaluatorBase<AtomicExprEvaluator> {
-  const LValue *This;
+class AtomicExprEvaluator : public ExprEvaluatorBase<AtomicExprEvaluator> {
+  LValue const *This;
   APValue &Result;
+
 public:
-  AtomicExprEvaluator(EvalInfo &Info, const LValue *This, APValue &Result)
+  AtomicExprEvaluator(EvalInfo &Info, LValue const *This, APValue &Result)
       : ExprEvaluatorBaseTy(Info), This(This), Result(Result) {}
 
-  bool Success(const APValue &V, const Expr *E) {
+  bool Success(APValue const &V, Expr const *E) {
     Result = V;
     return true;
   }
 
-  bool ZeroInitialization(const Expr *E) {
+  bool ZeroInitialization(Expr const *E) {
     ImplicitValueInitExpr VIE(
         E->getType()->castAs<AtomicType>()->getValueType());
     // For atomic-qualified class (and array) types in C++, initialize the
@@ -14334,7 +14313,7 @@
                 : Evaluate(Result, Info, &VIE);
   }
 
-  bool VisitCastExpr(const CastExpr *E) {
+  bool VisitCastExpr(CastExpr const *E) {
     switch (E->getCastKind()) {
     default:
       return ExprEvaluatorBaseTy::VisitCastExpr(E);
@@ -14346,7 +14325,7 @@
 };
 } // end anonymous namespace
 
-static bool EvaluateAtomic(const Expr *E, const LValue *This, APValue &Result,
+static bool EvaluateAtomic(Expr const *E, LValue const *This, APValue &Result,
                            EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isAtomicType());
@@ -14359,16 +14338,15 @@
 //===----------------------------------------------------------------------===//
 
 namespace {
-class VoidExprEvaluator
-  : public ExprEvaluatorBase<VoidExprEvaluator> {
+class VoidExprEvaluator : public ExprEvaluatorBase<VoidExprEvaluator> {
 public:
   VoidExprEvaluator(EvalInfo &Info) : ExprEvaluatorBaseTy(Info) {}
 
-  bool Success(const APValue &V, const Expr *e) { return true; }
+  bool Success(APValue const &V, Expr const *e) { return true; }
 
-  bool ZeroInitialization(const Expr *E) { return true; }
+  bool ZeroInitialization(Expr const *E) { return true; }
 
-  bool VisitCastExpr(const CastExpr *E) {
+  bool VisitCastExpr(CastExpr const *E) {
     switch (E->getCastKind()) {
     default:
       return ExprEvaluatorBaseTy::VisitCastExpr(E);
@@ -14378,7 +14356,7 @@
     }
   }
 
-  bool VisitCallExpr(const CallExpr *E) {
+  bool VisitCallExpr(CallExpr const *E) {
     switch (E->getBuiltinCallee()) {
     case Builtin::BI__assume:
     case Builtin::BI__builtin_assume:
@@ -14395,11 +14373,11 @@
     return ExprEvaluatorBaseTy::VisitCallExpr(E);
   }
 
-  bool VisitCXXDeleteExpr(const CXXDeleteExpr *E);
+  bool VisitCXXDeleteExpr(CXXDeleteExpr const *E);
 };
 } // end anonymous namespace
 
-bool VoidExprEvaluator::VisitCXXDeleteExpr(const CXXDeleteExpr *E) {
+bool VoidExprEvaluator::VisitCXXDeleteExpr(CXXDeleteExpr const *E) {
   // We cannot speculatively evaluate a delete expression.
   if (Info.SpeculativeEvaluationDepth)
     return false;
@@ -14411,7 +14389,7 @@
     return false;
   }
 
-  const Expr *Arg = E->getArgument();
+  Expr const *Arg = E->getArgument();
 
   LValue Pointer;
   if (!EvaluatePointer(Arg, Pointer, Info))
@@ -14447,7 +14425,7 @@
   // For a class type with a virtual destructor, the selected operator delete
   // is the one looked up when building the destructor.
   if (!E->isArrayForm() && !E->isGlobalDelete()) {
-    const FunctionDecl *VirtualDelete = getVirtualOperatorDelete(AllocType);
+    FunctionDecl const *VirtualDelete = getVirtualOperatorDelete(AllocType);
     if (VirtualDelete &&
         !VirtualDelete->isReplaceableGlobalAllocationFunction()) {
       Info.FFDiag(E, diag::note_constexpr_new_non_replaceable)
@@ -14472,7 +14450,7 @@
   return true;
 }
 
-static bool EvaluateVoid(const Expr *E, EvalInfo &Info) {
+static bool EvaluateVoid(Expr const *E, EvalInfo &Info) {
   assert(!E->isValueDependent());
   assert(E->isPRValue() && E->getType()->isVoidType());
   return VoidExprEvaluator(Info).Visit(E);
@@ -14482,7 +14460,7 @@
 // Top level Expr::EvaluateAsRValue method.
 //===----------------------------------------------------------------------===//
 
-static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {
+static bool Evaluate(APValue &Result, EvalInfo &Info, Expr const *E) {
   assert(!E->isValueDependent());
   // In C, function designators are not lvalues, but we evaluate them as if they
   // are.
@@ -14514,7 +14492,8 @@
       return false;
     C.moveInto(Result);
   } else if (T->isFixedPointType()) {
-    if (!FixedPointExprEvaluator(Info, Result).Visit(E)) return false;
+    if (!FixedPointExprEvaluator(Info, Result).Visit(E))
+      return false;
   } else if (T->isMemberPointerType()) {
     MemberPtr P;
     if (!EvaluateMemberPointer(E, P, Info))
@@ -14537,8 +14516,7 @@
     Result = Value;
   } else if (T->isVoidType()) {
     if (!Info.getLangOpts().CPlusPlus11)
-      Info.CCEDiag(E, diag::note_constexpr_nonliteral)
-        << E->getType();
+      Info.CCEDiag(E, diag::note_constexpr_nonliteral) << E->getType();
     if (!EvaluateVoid(E, Info))
       return false;
   } else if (T->isAtomicType()) {
@@ -14567,8 +14545,8 @@
 /// EvaluateInPlace - Evaluate an expression in-place in an APValue. In some
 /// cases, the in-place evaluation is essential, since later initializers for
 /// an object can indirectly refer to subobjects which were initialized earlier.
-static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, const LValue &This,
-                            const Expr *E, bool AllowNonLiteralTypes) {
+static bool EvaluateInPlace(APValue &Result, EvalInfo &Info, LValue const &This,
+                            Expr const *E, bool AllowNonLiteralTypes) {
   assert(!E->isValueDependent());
 
   if (!AllowNonLiteralTypes && !CheckLiteralType(Info, E, &This))
@@ -14595,7 +14573,7 @@
 
 /// EvaluateAsRValue - Try to evaluate this expression, performing an implicit
 /// lvalue-to-rvalue cast if it is an lvalue.
-static bool EvaluateAsRValue(EvalInfo &Info, const Expr *E, APValue &Result) {
+static bool EvaluateAsRValue(EvalInfo &Info, Expr const *E, APValue &Result) {
   assert(!E->isValueDependent());
   if (Info.EnableNewConstInterp) {
     if (!Info.Ctx.getInterpContext().evaluateAsRValue(Info, E, Result))
@@ -14624,13 +14602,13 @@
          CheckMemoryLeaks(Info);
 }
 
-static bool FastEvaluateAsRValue(const Expr *Exp, Expr::EvalResult &Result,
-                                 const ASTContext &Ctx, bool &IsConst) {
+static bool FastEvaluateAsRValue(Expr const *Exp, Expr::EvalResult &Result,
+                                 ASTContext const &Ctx, bool &IsConst) {
   // Fast-path evaluations of integer literals, since we sometimes see files
   // containing vast quantities of these.
-  if (const IntegerLiteral *L = dyn_cast<IntegerLiteral>(Exp)) {
-    Result.Val = APValue(APSInt(L->getValue(),
-                                L->getType()->isUnsignedIntegerType()));
+  if (IntegerLiteral const *L = dyn_cast<IntegerLiteral>(Exp)) {
+    Result.Val =
+        APValue(APSInt(L->getValue(), L->getType()->isUnsignedIntegerType()));
     IsConst = true;
     return true;
   }
@@ -14659,8 +14637,8 @@
          (SEK < Expr::SE_AllowUndefinedBehavior && Result.HasUndefinedBehavior);
 }
 
-static bool EvaluateAsRValue(const Expr *E, Expr::EvalResult &Result,
-                             const ASTContext &Ctx, EvalInfo &Info) {
+static bool EvaluateAsRValue(Expr const *E, Expr::EvalResult &Result,
+                             ASTContext const &Ctx, EvalInfo &Info) {
   assert(!E->isValueDependent());
   bool IsConst;
   if (FastEvaluateAsRValue(E, Result, Ctx, IsConst))
@@ -14669,8 +14647,8 @@
   return EvaluateAsRValue(Info, E, Result.Val);
 }
 
-static bool EvaluateAsInt(const Expr *E, Expr::EvalResult &ExprResult,
-                          const ASTContext &Ctx,
+static bool EvaluateAsInt(Expr const *E, Expr::EvalResult &ExprResult,
+                          ASTContext const &Ctx,
                           Expr::SideEffectsKind AllowSideEffects,
                           EvalInfo &Info) {
   assert(!E->isValueDependent());
@@ -14685,8 +14663,8 @@
   return true;
 }
 
-static bool EvaluateAsFixedPoint(const Expr *E, Expr::EvalResult &ExprResult,
-                                 const ASTContext &Ctx,
+static bool EvaluateAsFixedPoint(Expr const *E, Expr::EvalResult &ExprResult,
+                                 ASTContext const &Ctx,
                                  Expr::SideEffectsKind AllowSideEffects,
                                  EvalInfo &Info) {
   assert(!E->isValueDependent());
@@ -14708,7 +14686,7 @@
 /// we want to.  If this function returns true, it returns the folded constant
 /// in Result. If this expression is a glvalue, an lvalue-to-rvalue conversion
 /// will be applied to the result.
-bool Expr::EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx,
+bool Expr::EvaluateAsRValue(EvalResult &Result, ASTContext const &Ctx,
                             bool InConstantContext) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
@@ -14717,7 +14695,7 @@
   return ::EvaluateAsRValue(this, Result, Ctx, Info);
 }
 
-bool Expr::EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx,
+bool Expr::EvaluateAsBooleanCondition(bool &Result, ASTContext const &Ctx,
                                       bool InConstantContext) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
@@ -14726,7 +14704,7 @@
          HandleConversionToBool(Scratch.Val, Result);
 }
 
-bool Expr::EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx,
+bool Expr::EvaluateAsInt(EvalResult &Result, ASTContext const &Ctx,
                          SideEffectsKind AllowSideEffects,
                          bool InConstantContext) const {
   assert(!isValueDependent() &&
@@ -14736,7 +14714,7 @@
   return ::EvaluateAsInt(this, Result, Ctx, AllowSideEffects, Info);
 }
 
-bool Expr::EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx,
+bool Expr::EvaluateAsFixedPoint(EvalResult &Result, ASTContext const &Ctx,
                                 SideEffectsKind AllowSideEffects,
                                 bool InConstantContext) const {
   assert(!isValueDependent() &&
@@ -14746,7 +14724,7 @@
   return ::EvaluateAsFixedPoint(this, Result, Ctx, AllowSideEffects, Info);
 }
 
-bool Expr::EvaluateAsFloat(APFloat &Result, const ASTContext &Ctx,
+bool Expr::EvaluateAsFloat(APFloat &Result, ASTContext const &Ctx,
                            SideEffectsKind AllowSideEffects,
                            bool InConstantContext) const {
   assert(!isValueDependent() &&
@@ -14765,7 +14743,7 @@
   return true;
 }
 
-bool Expr::EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx,
+bool Expr::EvaluateAsLValue(EvalResult &Result, ASTContext const &Ctx,
                             bool InConstantContext) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
@@ -14785,7 +14763,7 @@
   return true;
 }
 
-static bool EvaluateDestruction(const ASTContext &Ctx, APValue::LValueBase Base,
+static bool EvaluateDestruction(ASTContext const &Ctx, APValue::LValueBase Base,
                                 APValue DestroyedValue, QualType Type,
                                 SourceLocation Loc, Expr::EvalStatus &EStatus,
                                 bool IsConstantDestruction) {
@@ -14809,7 +14787,7 @@
   return true;
 }
 
-bool Expr::EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx,
+bool Expr::EvaluateAsConstantExpr(EvalResult &Result, ASTContext const &Ctx,
                                   ConstantExprKind Kind) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
@@ -14826,7 +14804,7 @@
   // If we're evaluating a prvalue, fake up a MaterializeTemporaryExpr to
   // represent the result of the evaluation. CheckConstantExpression ensures
   // this doesn't escape.
-  MaterializeTemporaryExpr BaseMTE(T, const_cast<Expr*>(this), true);
+  MaterializeTemporaryExpr BaseMTE(T, const_cast<Expr *>(this), true);
   APValue::LValueBase Base(&BaseMTE);
 
   Info.setEvaluatingDecl(Base, Result.Val);
@@ -14859,8 +14837,8 @@
   return true;
 }
 
-bool Expr::EvaluateAsInitializer(APValue &Value, const ASTContext &Ctx,
-                                 const VarDecl *VD,
+bool Expr::EvaluateAsInitializer(APValue &Value, ASTContext const &Ctx,
+                                 VarDecl const *VD,
                                  SmallVectorImpl<PartialDiagnosticAt> &Notes,
                                  bool IsConstantInitialization) const {
   assert(!isValueDependent() &&
@@ -14940,7 +14918,7 @@
 
 /// isEvaluatable - Call EvaluateAsRValue to see if this expression can be
 /// constant folded, but discard the result.
-bool Expr::isEvaluatable(const ASTContext &Ctx, SideEffectsKind SEK) const {
+bool Expr::isEvaluatable(ASTContext const &Ctx, SideEffectsKind SEK) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
@@ -14949,8 +14927,9 @@
          !hasUnacceptableSideEffect(Result, SEK);
 }
 
-APSInt Expr::EvaluateKnownConstInt(const ASTContext &Ctx,
-                    SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
+APSInt
+Expr::EvaluateKnownConstInt(ASTContext const &Ctx,
+                            SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
@@ -14968,7 +14947,7 @@
 }
 
 APSInt Expr::EvaluateKnownConstIntCheckOverflow(
-    const ASTContext &Ctx, SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
+    ASTContext const &Ctx, SmallVectorImpl<PartialDiagnosticAt> *Diag) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
@@ -14986,7 +14965,7 @@
   return EVResult.Val.getInt();
 }
 
-void Expr::EvaluateForOverflow(const ASTContext &Ctx) const {
+void Expr::EvaluateForOverflow(ASTContext const &Ctx) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
@@ -15039,13 +15018,13 @@
   ICEDiag(ICEKind IK, SourceLocation l) : Kind(IK), Loc(l) {}
 };
 
-}
+} // namespace
 
 static ICEDiag NoDiag() { return ICEDiag(IK_ICE, SourceLocation()); }
 
 static ICEDiag Worst(ICEDiag A, ICEDiag B) { return A.Kind >= B.Kind ? A : B; }
 
-static ICEDiag CheckEvalInICE(const Expr* E, const ASTContext &Ctx) {
+static ICEDiag CheckEvalInICE(Expr const *E, ASTContext const &Ctx) {
   Expr::EvalResult EVResult;
   Expr::EvalStatus Status;
   EvalInfo Info(Ctx, Status, EvalInfo::EM_ConstantExpression);
@@ -15058,7 +15037,7 @@
   return NoDiag();
 }
 
-static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
+static ICEDiag CheckICE(Expr const *E, ASTContext const &Ctx) {
   assert(!E->isValueDependent() && "Should not see value dependent exprs!");
   if (!E->getType()->isIntegralOrEnumerationType())
     return ICEDiag(IK_NotICE, E->getBeginLoc());
@@ -15170,8 +15149,8 @@
     return NoDiag();
 
   case Expr::SubstNonTypeTemplateParmExprClass:
-    return
-      CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(), Ctx);
+    return CheckICE(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement(),
+                    Ctx);
 
   case Expr::ConstantExprClass:
     return CheckICE(cast<ConstantExpr>(E)->getSubExpr(), Ctx);
@@ -15198,7 +15177,7 @@
     // C99 6.6/3 allows function calls within unevaluated subexpressions of
     // constant expressions, but they can never be ICEs because an ICE cannot
     // contain an operand of (pointer to) function type.
-    const CallExpr *CE = cast<CallExpr>(E);
+    CallExpr const *CE = cast<CallExpr>(E);
     if (CE->getBuiltinCallee())
       return CheckEvalInICE(E, Ctx);
     return ICEDiag(IK_NotICE, E->getBeginLoc());
@@ -15207,7 +15186,7 @@
     return CheckICE(cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm(),
                     Ctx);
   case Expr::DeclRefExprClass: {
-    const NamedDecl *D = cast<DeclRefExpr>(E)->getDecl();
+    NamedDecl const *D = cast<DeclRefExpr>(E)->getDecl();
     if (isa<EnumConstantDecl>(D))
       return NoDiag();
 
@@ -15220,7 +15199,7 @@
     //
     // We sometimes use CheckICE to check the C++98 rules in C++11 mode. In
     // that mode, use of reference variables should not be allowed.
-    const VarDecl *VD = dyn_cast<VarDecl>(D);
+    VarDecl const *VD = dyn_cast<VarDecl>(D);
     if (VD && VD->isUsableInConstantExpressions(Ctx) &&
         !VD->getType()->isReferenceType())
       return NoDiag();
@@ -15228,7 +15207,7 @@
     return ICEDiag(IK_NotICE, E->getBeginLoc());
   }
   case Expr::UnaryOperatorClass: {
-    const UnaryOperator *Exp = cast<UnaryOperator>(E);
+    UnaryOperator const *Exp = cast<UnaryOperator>(E);
     switch (Exp->getOpcode()) {
     case UO_PostInc:
     case UO_PostDec:
@@ -15262,14 +15241,14 @@
     return CheckEvalInICE(E, Ctx);
   }
   case Expr::UnaryExprOrTypeTraitExprClass: {
-    const UnaryExprOrTypeTraitExpr *Exp = cast<UnaryExprOrTypeTraitExpr>(E);
-    if ((Exp->getKind() ==  UETT_SizeOf) &&
+    UnaryExprOrTypeTraitExpr const *Exp = cast<UnaryExprOrTypeTraitExpr>(E);
+    if ((Exp->getKind() == UETT_SizeOf) &&
         Exp->getTypeOfArgument()->isVariableArrayType())
       return ICEDiag(IK_NotICE, E->getBeginLoc());
     return NoDiag();
   }
   case Expr::BinaryOperatorClass: {
-    const BinaryOperator *Exp = cast<BinaryOperator>(E);
+    BinaryOperator const *Exp = cast<BinaryOperator>(E);
     switch (Exp->getOpcode()) {
     case BO_PtrMemD:
     case BO_PtrMemI:
@@ -15309,8 +15288,7 @@
     case BO_Cmp: {
       ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
       ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
-      if (Exp->getOpcode() == BO_Div ||
-          Exp->getOpcode() == BO_Rem) {
+      if (Exp->getOpcode() == BO_Div || Exp->getOpcode() == BO_Rem) {
         // EvaluateAsRValue gives an error for undefined Div/Rem, so make sure
         // we don't evaluate one.
         if (LHSResult.Kind == IK_ICE && RHSResult.Kind == IK_ICE) {
@@ -15363,10 +15341,10 @@
   case Expr::CXXReinterpretCastExprClass:
   case Expr::CXXConstCastExprClass:
   case Expr::ObjCBridgedCastExprClass: {
-    const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
+    Expr const *SubExpr = cast<CastExpr>(E)->getSubExpr();
     if (isa<ExplicitCastExpr>(E)) {
-      if (const FloatingLiteral *FL
-            = dyn_cast<FloatingLiteral>(SubExpr->IgnoreParenImpCasts())) {
+      if (FloatingLiteral const *FL =
+              dyn_cast<FloatingLiteral>(SubExpr->IgnoreParenImpCasts())) {
         unsigned DestWidth = Ctx.getIntWidth(E->getType());
         bool DestSigned = E->getType()->isSignedIntegerOrEnumerationType();
         APSInt IgnoredVal(DestWidth, !DestSigned);
@@ -15374,9 +15352,9 @@
         // If the value does not fit in the destination type, the behavior is
         // undefined, so we are not required to treat it as a constant
         // expression.
-        if (FL->getValue().convertToInteger(IgnoredVal,
-                                            llvm::APFloat::rmTowardZero,
-                                            &Ignored) & APFloat::opInvalidOp)
+        if (FL->getValue().convertToInteger(
+                IgnoredVal, llvm::APFloat::rmTowardZero, &Ignored) &
+            APFloat::opInvalidOp)
           return ICEDiag(IK_NotICE, E->getBeginLoc());
         return NoDiag();
       }
@@ -15394,24 +15372,28 @@
     }
   }
   case Expr::BinaryConditionalOperatorClass: {
-    const BinaryConditionalOperator *Exp = cast<BinaryConditionalOperator>(E);
+    BinaryConditionalOperator const *Exp = cast<BinaryConditionalOperator>(E);
     ICEDiag CommonResult = CheckICE(Exp->getCommon(), Ctx);
-    if (CommonResult.Kind == IK_NotICE) return CommonResult;
+    if (CommonResult.Kind == IK_NotICE)
+      return CommonResult;
     ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
-    if (FalseResult.Kind == IK_NotICE) return FalseResult;
-    if (CommonResult.Kind == IK_ICEIfUnevaluated) return CommonResult;
+    if (FalseResult.Kind == IK_NotICE)
+      return FalseResult;
+    if (CommonResult.Kind == IK_ICEIfUnevaluated)
+      return CommonResult;
     if (FalseResult.Kind == IK_ICEIfUnevaluated &&
-        Exp->getCommon()->EvaluateKnownConstInt(Ctx) != 0) return NoDiag();
+        Exp->getCommon()->EvaluateKnownConstInt(Ctx) != 0)
+      return NoDiag();
     return FalseResult;
   }
   case Expr::ConditionalOperatorClass: {
-    const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
+    ConditionalOperator const *Exp = cast<ConditionalOperator>(E);
     // If the condition (ignoring parens) is a __builtin_constant_p call,
     // then only the true side is actually considered in an integer constant
     // expression, and it is fully evaluated.  This is an important GNU
     // extension.  See GCC PR38377 for discussion.
-    if (const CallExpr *CallCE
-        = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
+    if (CallExpr const *CallCE =
+            dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
       if (CallCE->getBuiltinCallee() == Builtin::BI__builtin_constant_p)
         return CheckEvalInICE(E, Ctx);
     ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
@@ -15454,12 +15436,13 @@
 }
 
 /// Evaluate an expression as a C++11 integral constant expression.
-static bool EvaluateCPlusPlus11IntegralConstantExpr(const ASTContext &Ctx,
-                                                    const Expr *E,
+static bool EvaluateCPlusPlus11IntegralConstantExpr(ASTContext const &Ctx,
+                                                    Expr const *E,
                                                     llvm::APSInt *Value,
                                                     SourceLocation *Loc) {
   if (!E->getType()->isIntegralOrUnscopedEnumerationType()) {
-    if (Loc) *Loc = E->getExprLoc();
+    if (Loc)
+      *Loc = E->getExprLoc();
     return false;
   }
 
@@ -15468,15 +15451,17 @@
     return false;
 
   if (!Result.isInt()) {
-    if (Loc) *Loc = E->getExprLoc();
+    if (Loc)
+      *Loc = E->getExprLoc();
     return false;
   }
 
-  if (Value) *Value = Result.getInt();
+  if (Value)
+    *Value = Result.getInt();
   return true;
 }
 
-bool Expr::isIntegerConstantExpr(const ASTContext &Ctx,
+bool Expr::isIntegerConstantExpr(ASTContext const &Ctx,
                                  SourceLocation *Loc) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
@@ -15486,13 +15471,14 @@
 
   ICEDiag D = CheckICE(this, Ctx);
   if (D.Kind != IK_ICE) {
-    if (Loc) *Loc = D.Loc;
+    if (Loc)
+      *Loc = D.Loc;
     return false;
   }
   return true;
 }
 
-Optional<llvm::APSInt> Expr::getIntegerConstantExpr(const ASTContext &Ctx,
+Optional<llvm::APSInt> Expr::getIntegerConstantExpr(ASTContext const &Ctx,
                                                     SourceLocation *Loc,
                                                     bool isEvaluated) const {
   assert(!isValueDependent() &&
@@ -15524,14 +15510,14 @@
   return ExprResult.Val.getInt();
 }
 
-bool Expr::isCXX98IntegralConstantExpr(const ASTContext &Ctx) const {
+bool Expr::isCXX98IntegralConstantExpr(ASTContext const &Ctx) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
   return CheckICE(this, Ctx).Kind == IK_ICE;
 }
 
-bool Expr::isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result,
+bool Expr::isCXX11ConstantExpr(ASTContext const &Ctx, APValue *Result,
                                SourceLocation *Loc) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
@@ -15555,19 +15541,21 @@
 
   if (!Diags.empty()) {
     IsConstExpr = false;
-    if (Loc) *Loc = Diags[0].first;
+    if (Loc)
+      *Loc = Diags[0].first;
   } else if (!IsConstExpr) {
     // FIXME: This shouldn't happen.
-    if (Loc) *Loc = getExprLoc();
+    if (Loc)
+      *Loc = getExprLoc();
   }
 
   return IsConstExpr;
 }
 
 bool Expr::EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx,
-                                    const FunctionDecl *Callee,
-                                    ArrayRef<const Expr*> Args,
-                                    const Expr *This) const {
+                                    FunctionDecl const *Callee,
+                                    ArrayRef<Expr const *> Args,
+                                    Expr const *This) const {
   assert(!isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
@@ -15576,7 +15564,7 @@
   Info.InConstantContext = true;
 
   LValue ThisVal;
-  const LValue *ThisPtr = nullptr;
+  LValue const *ThisPtr = nullptr;
   if (This) {
 #ifndef NDEBUG
     auto *MD = dyn_cast<CXXMethodDecl>(Callee);
@@ -15594,14 +15582,13 @@
   }
 
   CallRef Call = Info.CurrentCall->createCall(Callee);
-  for (ArrayRef<const Expr*>::iterator I = Args.begin(), E = Args.end();
+  for (ArrayRef<Expr const *>::iterator I = Args.begin(), E = Args.end();
        I != E; ++I) {
     unsigned Idx = I - Args.begin();
     if (Idx >= Callee->getNumParams())
       break;
-    const ParmVarDecl *PVD = Callee->getParamDecl(Idx);
-    if ((*I)->isValueDependent() ||
-        !EvaluateCallArg(PVD, *I, Call, Info) ||
+    ParmVarDecl const *PVD = Callee->getParamDecl(Idx);
+    if ((*I)->isValueDependent() || !EvaluateCallArg(PVD, *I, Call, Info) ||
         Info.EvalStatus.HasSideEffects) {
       // If evaluation fails, throw away the argument entirely.
       if (APValue *Slot = Info.getParamSlot(Call, PVD))
@@ -15626,9 +15613,8 @@
          !Info.EvalStatus.HasSideEffects;
 }
 
-bool Expr::isPotentialConstantExpr(const FunctionDecl *FD,
-                                   SmallVectorImpl<
-                                     PartialDiagnosticAt> &Diags) {
+bool Expr::isPotentialConstantExpr(
+    FunctionDecl const *FD, SmallVectorImpl<PartialDiagnosticAt> &Diags) {
   // FIXME: It would be useful to check constexpr function templates, but at the
   // moment the constant expression evaluator cannot cope with the non-rigorous
   // ASTs which we build for dependent expressions.
@@ -15648,8 +15634,8 @@
     return Diags.empty();
   }
 
-  const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
-  const CXXRecordDecl *RD = MD ? MD->getParent()->getCanonicalDecl() : nullptr;
+  CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(FD);
+  CXXRecordDecl const *RD = MD ? MD->getParent()->getCanonicalDecl() : nullptr;
 
   // Fabricate an arbitrary expression on the stack and pretend that it
   // is a temporary being used as the 'this' pointer.
@@ -15657,10 +15643,10 @@
   ImplicitValueInitExpr VIE(RD ? Info.Ctx.getRecordType(RD) : Info.Ctx.IntTy);
   This.set({&VIE, Info.CurrentCall->Index});
 
-  ArrayRef<const Expr*> Args;
+  ArrayRef<Expr const *> Args;
 
   APValue Scratch;
-  if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
+  if (CXXConstructorDecl const *CD = dyn_cast<CXXConstructorDecl>(FD)) {
     // Evaluate the call as a constant initializer, to allow the construction
     // of objects of non-literal types.
     Info.setEvaluatingDecl(This.getLValueBase(), Scratch);
@@ -15674,10 +15660,9 @@
   return Diags.empty();
 }
 
-bool Expr::isPotentialConstantExprUnevaluated(Expr *E,
-                                              const FunctionDecl *FD,
-                                              SmallVectorImpl<
-                                                PartialDiagnosticAt> &Diags) {
+bool Expr::isPotentialConstantExprUnevaluated(
+    Expr *E, FunctionDecl const *FD,
+    SmallVectorImpl<PartialDiagnosticAt> &Diags) {
   assert(!E->isValueDependent() &&
          "Expression evaluator can't be called on a dependent expression.");
 
@@ -15707,7 +15692,7 @@
   return tryEvaluateBuiltinObjectSize(this, Type, Info, Result);
 }
 
-static bool EvaluateBuiltinStrLen(const Expr *E, uint64_t &Result,
+static bool EvaluateBuiltinStrLen(Expr const *E, uint64_t &Result,
                                   EvalInfo &Info) {
   if (!E->getType()->hasPointerRepresentation() || !E->isPRValue())
     return false;
@@ -15720,8 +15705,8 @@
   QualType CharTy = E->getType()->getPointeeType();
 
   // Fast path: if it's a string literal, search the string value.
-  if (const StringLiteral *S = dyn_cast_or_null<StringLiteral>(
-          String.getLValueBase().dyn_cast<const Expr *>())) {
+  if (StringLiteral const *S = dyn_cast_or_null<StringLiteral>(
+          String.getLValueBase().dyn_cast<Expr const *>())) {
     StringRef Str = S->getBytes();
     int64_t Off = String.Offset.getQuantity();
     if (Off >= 0 && (uint64_t)Off <= (uint64_t)Str.size() &&
Index: clang/lib/AST/ExprObjC.cpp
===================================================================
--- clang/lib/AST/ExprObjC.cpp
+++ clang/lib/AST/ExprObjC.cpp
@@ -36,7 +36,7 @@
   setDependence(computeDependence(this));
 }
 
-ObjCArrayLiteral *ObjCArrayLiteral::Create(const ASTContext &C,
+ObjCArrayLiteral *ObjCArrayLiteral::Create(ASTContext const &C,
                                            ArrayRef<Expr *> Elements,
                                            QualType T, ObjCMethodDecl *Method,
                                            SourceRange SR) {
@@ -44,7 +44,7 @@
   return new (Mem) ObjCArrayLiteral(Elements, T, Method, SR);
 }
 
-ObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(const ASTContext &C,
+ObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(ASTContext const &C,
                                                 unsigned NumElements) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumElements));
   return new (Mem) ObjCArrayLiteral(EmptyShell(), NumElements);
@@ -75,7 +75,7 @@
 }
 
 ObjCDictionaryLiteral *
-ObjCDictionaryLiteral::Create(const ASTContext &C,
+ObjCDictionaryLiteral::Create(ASTContext const &C,
                               ArrayRef<ObjCDictionaryElement> VK,
                               bool HasPackExpansions, QualType T,
                               ObjCMethodDecl *method, SourceRange SR) {
@@ -85,7 +85,7 @@
 }
 
 ObjCDictionaryLiteral *
-ObjCDictionaryLiteral::CreateEmpty(const ASTContext &C, unsigned NumElements,
+ObjCDictionaryLiteral::CreateEmpty(ASTContext const &C, unsigned NumElements,
                                    bool HasPackExpansions) {
   void *Mem = C.Allocate(totalSizeToAlloc<KeyValuePair, ExpansionData>(
       NumElements, HasPackExpansions ? NumElements : 0));
@@ -93,7 +93,7 @@
       ObjCDictionaryLiteral(EmptyShell(), NumElements, HasPackExpansions);
 }
 
-QualType ObjCPropertyRefExpr::getReceiverType(const ASTContext &ctx) const {
+QualType ObjCPropertyRefExpr::getReceiverType(ASTContext const &ctx) const {
   if (isClassReceiver())
     return ctx.getObjCInterfaceType(getClassReceiver());
 
@@ -172,7 +172,7 @@
 }
 
 ObjCMessageExpr *
-ObjCMessageExpr::Create(const ASTContext &Context, QualType T, ExprValueKind VK,
+ObjCMessageExpr::Create(ASTContext const &Context, QualType T, ExprValueKind VK,
                         SourceLocation LBracLoc, SourceLocation SuperLoc,
                         bool IsInstanceSuper, QualType SuperType, Selector Sel,
                         ArrayRef<SourceLocation> SelLocs,
@@ -192,7 +192,7 @@
 }
 
 ObjCMessageExpr *
-ObjCMessageExpr::Create(const ASTContext &Context, QualType T, ExprValueKind VK,
+ObjCMessageExpr::Create(ASTContext const &Context, QualType T, ExprValueKind VK,
                         SourceLocation LBracLoc, TypeSourceInfo *Receiver,
                         Selector Sel, ArrayRef<SourceLocation> SelLocs,
                         ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
@@ -211,7 +211,7 @@
 }
 
 ObjCMessageExpr *
-ObjCMessageExpr::Create(const ASTContext &Context, QualType T, ExprValueKind VK,
+ObjCMessageExpr::Create(ASTContext const &Context, QualType T, ExprValueKind VK,
                         SourceLocation LBracLoc, Expr *Receiver, Selector Sel,
                         ArrayRef<SourceLocation> SelLocs,
                         ObjCMethodDecl *Method, ArrayRef<Expr *> Args,
@@ -229,14 +229,14 @@
                       Args, RBracLoc, isImplicit);
 }
 
-ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(const ASTContext &Context,
+ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext const &Context,
                                               unsigned NumArgs,
                                               unsigned NumStoredSelLocs) {
   ObjCMessageExpr *Mem = alloc(Context, NumArgs, NumStoredSelLocs);
   return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs);
 }
 
-ObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C,
+ObjCMessageExpr *ObjCMessageExpr::alloc(ASTContext const &C,
                                         ArrayRef<Expr *> Args,
                                         SourceLocation RBraceLoc,
                                         ArrayRef<SourceLocation> SelLocs,
@@ -248,7 +248,7 @@
   return alloc(C, Args.size(), NumStoredSelLocs);
 }
 
-ObjCMessageExpr *ObjCMessageExpr::alloc(const ASTContext &C, unsigned NumArgs,
+ObjCMessageExpr *ObjCMessageExpr::alloc(ASTContext const &C, unsigned NumArgs,
                                         unsigned NumStoredSelLocs) {
   return (ObjCMessageExpr *)C.Allocate(
       totalSizeToAlloc<void *, SourceLocation>(NumArgs + 1, NumStoredSelLocs),
@@ -261,9 +261,8 @@
     SelLocs.push_back(getSelectorLoc(i));
 }
 
-
 QualType ObjCMessageExpr::getCallReturnType(ASTContext &Ctx) const {
-  if (const ObjCMethodDecl *MD = getMethodDecl()) {
+  if (ObjCMethodDecl const *MD = getMethodDecl()) {
     QualType QT = MD->getReturnType();
     if (QT == Ctx.getObjCInstanceType()) {
       // instancetype corresponds to expression types.
@@ -292,7 +291,7 @@
 
 Selector ObjCMessageExpr::getSelector() const {
   if (HasMethod)
-    return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
+    return reinterpret_cast<ObjCMethodDecl const *>(SelectorOrMethod)
         ->getSelector();
   return Selector(SelectorOrMethod);
 }
@@ -314,10 +313,10 @@
 ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const {
   QualType T = getReceiverType();
 
-  if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
+  if (ObjCObjectPointerType const *Ptr = T->getAs<ObjCObjectPointerType>())
     return Ptr->getInterfaceDecl();
 
-  if (const ObjCObjectType *Ty = T->getAs<ObjCObjectType>())
+  if (ObjCObjectType const *Ty = T->getAs<ObjCObjectType>())
     return Ty->getInterface();
 
   return nullptr;
Index: clang/lib/AST/ExternalASTMerger.cpp
===================================================================
--- clang/lib/AST/ExternalASTMerger.cpp
+++ clang/lib/AST/ExternalASTMerger.cpp
@@ -11,12 +11,12 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/AST/ExternalASTMerger.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
-#include "clang/AST/ExternalASTMerger.h"
 
 using namespace clang;
 
@@ -35,20 +35,20 @@
 
 /// For the given DC, return the DC that is safe to perform lookups on.  This is
 /// the DC we actually want to work with most of the time.
-const DeclContext *CanonicalizeDC(const DeclContext *DC) {
+DeclContext const *CanonicalizeDC(DeclContext const *DC) {
   if (isa<LinkageSpecDecl>(DC))
     return DC->getRedeclContext();
   return DC;
 }
 
-Source<const DeclContext *>
-LookupSameContext(Source<TranslationUnitDecl *> SourceTU, const DeclContext *DC,
+Source<DeclContext const *>
+LookupSameContext(Source<TranslationUnitDecl *> SourceTU, DeclContext const *DC,
                   ASTImporter &ReverseImporter) {
   DC = CanonicalizeDC(DC);
   if (DC->isTranslationUnit()) {
     return SourceTU;
   }
-  Source<const DeclContext *> SourceParentDC =
+  Source<DeclContext const *> SourceParentDC =
       LookupSameContext(SourceTU, DC->getParent(), ReverseImporter);
   if (!SourceParentDC) {
     // If we couldn't find the parent DC in this TranslationUnit, give up.
@@ -100,7 +100,7 @@
 private:
   ExternalASTMerger &Parent;
   ASTImporter Reverse;
-  const ExternalASTMerger::OriginMap &FromOrigins;
+  ExternalASTMerger::OriginMap const &FromOrigins;
   /// @see ExternalASTMerger::ImporterSource::Temporary
   bool TemporarySource;
   /// Map of imported declarations back to the declarations they originated
@@ -109,10 +109,11 @@
   /// @see ExternalASTMerger::ImporterSource::Merger
   ExternalASTMerger *SourceMerger;
   llvm::raw_ostream &logs() { return Parent.logs(); }
+
 public:
   LazyASTImporter(ExternalASTMerger &_Parent, ASTContext &ToContext,
                   FileManager &ToFileManager,
-                  const ExternalASTMerger::ImporterSource &S,
+                  ExternalASTMerger::ImporterSource const &S,
                   std::shared_ptr<ASTImporterSharedState> SharedState)
       : ASTImporter(ToContext, ToFileManager, S.getASTContext(),
                     S.getFileManager(),
@@ -199,32 +200,29 @@
     ToOrigin[To] = From;
 
     if (auto *ToDC = dyn_cast<DeclContext>(To)) {
-      const bool LoggingEnabled = Parent.LoggingEnabled();
+      bool const LoggingEnabled = Parent.LoggingEnabled();
       if (LoggingEnabled)
-        logs() << "(ExternalASTMerger*)" << (void*)&Parent
-               << " imported (DeclContext*)" << (void*)ToDC
-               << ", (ASTContext*)" << (void*)&getToContext()
-               << " from (DeclContext*)" << (void*)llvm::cast<DeclContext>(From)
-               << ", (ASTContext*)" << (void*)&getFromContext()
-               << "\n";
+        logs() << "(ExternalASTMerger*)" << (void *)&Parent
+               << " imported (DeclContext*)" << (void *)ToDC
+               << ", (ASTContext*)" << (void *)&getToContext()
+               << " from (DeclContext*)"
+               << (void *)llvm::cast<DeclContext>(From) << ", (ASTContext*)"
+               << (void *)&getFromContext() << "\n";
       Source<DeclContext *> FromDC(
           cast<DeclContext>(From)->getPrimaryContext());
       if (FromOrigins.count(FromDC) &&
           Parent.HasImporterForOrigin(*FromOrigins.at(FromDC).AST)) {
         if (LoggingEnabled)
-          logs() << "(ExternalASTMerger*)" << (void*)&Parent
+          logs() << "(ExternalASTMerger*)" << (void *)&Parent
                  << " forced origin (DeclContext*)"
-                 << (void*)FromOrigins.at(FromDC).DC
-                 << ", (ASTContext*)"
-                 << (void*)FromOrigins.at(FromDC).AST
-                 << "\n";
+                 << (void *)FromOrigins.at(FromDC).DC << ", (ASTContext*)"
+                 << (void *)FromOrigins.at(FromDC).AST << "\n";
         Parent.ForceRecordOrigin(ToDC, FromOrigins.at(FromDC));
       } else {
         if (LoggingEnabled)
-          logs() << "(ExternalASTMerger*)" << (void*)&Parent
-                 << " maybe recording origin (DeclContext*)" << (void*)FromDC
-                 << ", (ASTContext*)" << (void*)&getFromContext()
-                 << "\n";
+          logs() << "(ExternalASTMerger*)" << (void *)&Parent
+                 << " maybe recording origin (DeclContext*)" << (void *)FromDC
+                 << ", (ASTContext*)" << (void *)&getFromContext() << "\n";
         Parent.MaybeRecordOrigin(ToDC, {FromDC, &getFromContext()});
       }
     }
@@ -244,10 +242,10 @@
   ASTImporter &GetReverse() { return Reverse; }
 };
 
-bool HasDeclOfSameType(llvm::ArrayRef<Candidate> Decls, const Candidate &C) {
+bool HasDeclOfSameType(llvm::ArrayRef<Candidate> Decls, Candidate const &C) {
   if (isa<FunctionDecl>(C.first.get()))
     return false;
-  return llvm::any_of(Decls, [&](const Candidate &D) {
+  return llvm::any_of(Decls, [&](Candidate const &D) {
     return C.first.get()->getKind() == D.first.get()->getKind();
   });
 }
@@ -255,7 +253,7 @@
 } // end namespace
 
 ASTImporter &ExternalASTMerger::ImporterForOrigin(ASTContext &OriginContext) {
-  for (const std::unique_ptr<ASTImporter> &I : Importers)
+  for (std::unique_ptr<ASTImporter> const &I : Importers)
     if (&I->getFromContext() == &OriginContext)
       return *I;
   llvm_unreachable("We should have an importer for this origin!");
@@ -263,21 +261,21 @@
 
 namespace {
 LazyASTImporter &LazyImporterForOrigin(ExternalASTMerger &Merger,
-                                   ASTContext &OriginContext) {
+                                       ASTContext &OriginContext) {
   return static_cast<LazyASTImporter &>(
       Merger.ImporterForOrigin(OriginContext));
 }
-}
+} // namespace
 
 bool ExternalASTMerger::HasImporterForOrigin(ASTContext &OriginContext) {
-  for (const std::unique_ptr<ASTImporter> &I : Importers)
+  for (std::unique_ptr<ASTImporter> const &I : Importers)
     if (&I->getFromContext() == &OriginContext)
       return true;
   return false;
 }
 
 template <typename CallbackType>
-void ExternalASTMerger::ForEachMatchingDC(const DeclContext *DC,
+void ExternalASTMerger::ForEachMatchingDC(DeclContext const *DC,
                                           CallbackType Callback) {
   if (Origins.count(DC)) {
     ExternalASTMerger::DCOrigin Origin = Origins[DC];
@@ -285,7 +283,7 @@
     Callback(Importer, Importer.GetReverse(), Origin.DC);
   } else {
     bool DidCallback = false;
-    for (const std::unique_ptr<ASTImporter> &Importer : Importers) {
+    for (std::unique_ptr<ASTImporter> const &Importer : Importers) {
       Source<TranslationUnitDecl *> SourceTU =
           Importer->getFromContext().getTranslationUnitDecl();
       ASTImporter &Reverse =
@@ -297,36 +295,39 @@
       }
     }
     if (!DidCallback && LoggingEnabled())
-      logs() << "(ExternalASTMerger*)" << (void*)this
-             << " asserting for (DeclContext*)" << (const void*)DC
-             << ", (ASTContext*)" << (void*)&Target.AST
-             << "\n";
+      logs() << "(ExternalASTMerger*)" << (void *)this
+             << " asserting for (DeclContext*)" << (void const *)DC
+             << ", (ASTContext*)" << (void *)&Target.AST << "\n";
     assert(DidCallback && "Couldn't find a source context matching our DC");
   }
 }
 
 void ExternalASTMerger::CompleteType(TagDecl *Tag) {
   assert(Tag->hasExternalLexicalStorage());
-  ForEachMatchingDC(Tag, [&](ASTImporter &Forward, ASTImporter &Reverse,
-                             Source<const DeclContext *> SourceDC) -> bool {
-    auto *SourceTag = const_cast<TagDecl *>(cast<TagDecl>(SourceDC.get()));
-    if (SourceTag->hasExternalLexicalStorage())
-      SourceTag->getASTContext().getExternalSource()->CompleteType(SourceTag);
-    if (!SourceTag->getDefinition())
-      return false;
-    Forward.MapImported(SourceTag, Tag);
-    if (llvm::Error Err = Forward.ImportDefinition(SourceTag))
-      llvm::consumeError(std::move(Err));
-    Tag->setCompleteDefinition(SourceTag->isCompleteDefinition());
-    return true;
-  });
+  ForEachMatchingDC(
+      Tag,
+      [&](ASTImporter &Forward, ASTImporter &Reverse,
+          Source<DeclContext const *> SourceDC) -> bool {
+        auto *SourceTag = const_cast<TagDecl *>(cast<TagDecl>(SourceDC.get()));
+        if (SourceTag->hasExternalLexicalStorage())
+          SourceTag->getASTContext().getExternalSource()->CompleteType(
+              SourceTag);
+        if (!SourceTag->getDefinition())
+          return false;
+        Forward.MapImported(SourceTag, Tag);
+        if (llvm::Error Err = Forward.ImportDefinition(SourceTag))
+          llvm::consumeError(std::move(Err));
+        Tag->setCompleteDefinition(SourceTag->isCompleteDefinition());
+        return true;
+      });
 }
 
 void ExternalASTMerger::CompleteType(ObjCInterfaceDecl *Interface) {
   assert(Interface->hasExternalLexicalStorage());
   ForEachMatchingDC(
-      Interface, [&](ASTImporter &Forward, ASTImporter &Reverse,
-                     Source<const DeclContext *> SourceDC) -> bool {
+      Interface,
+      [&](ASTImporter &Forward, ASTImporter &Reverse,
+          Source<DeclContext const *> SourceDC) -> bool {
         auto *SourceInterface = const_cast<ObjCInterfaceDecl *>(
             cast<ObjCInterfaceDecl>(SourceDC.get()));
         if (SourceInterface->hasExternalLexicalStorage())
@@ -347,7 +348,7 @@
   bool FoundMatchingDC = false;
   ForEachMatchingDC(Interface,
                     [&](ASTImporter &Forward, ASTImporter &Reverse,
-                        Source<const DeclContext *> SourceDC) -> bool {
+                        Source<DeclContext const *> SourceDC) -> bool {
                       FoundMatchingDC = true;
                       return true;
                     });
@@ -355,7 +356,7 @@
 }
 
 namespace {
-bool IsSameDC(const DeclContext *D1, const DeclContext *D2) {
+bool IsSameDC(DeclContext const *D1, DeclContext const *D2) {
   if (isa<ObjCContainerDecl>(D1) && isa<ObjCContainerDecl>(D2))
     return true; // There are many cases where Objective-C is ambiguous.
   if (auto *T1 = dyn_cast<TagDecl>(D1))
@@ -364,38 +365,40 @@
         return true;
   return D1 == D2 || D1 == CanonicalizeDC(D2);
 }
-}
+} // namespace
 
-void ExternalASTMerger::MaybeRecordOrigin(const DeclContext *ToDC,
+void ExternalASTMerger::MaybeRecordOrigin(DeclContext const *ToDC,
                                           DCOrigin Origin) {
   LazyASTImporter &Importer = LazyImporterForOrigin(*this, *Origin.AST);
   ASTImporter &Reverse = Importer.GetReverse();
-  Source<const DeclContext *> FoundFromDC =
+  Source<DeclContext const *> FoundFromDC =
       LookupSameContext(Origin.AST->getTranslationUnitDecl(), ToDC, Reverse);
-  const bool DoRecord = !FoundFromDC || !IsSameDC(FoundFromDC.get(), Origin.DC);
+  bool const DoRecord = !FoundFromDC || !IsSameDC(FoundFromDC.get(), Origin.DC);
   if (DoRecord)
     RecordOriginImpl(ToDC, Origin, Importer);
   if (LoggingEnabled())
-    logs() << "(ExternalASTMerger*)" << (void*)this
-             << (DoRecord ? " decided " : " decided NOT")
-             << " to record origin (DeclContext*)" << (void*)Origin.DC
-             << ", (ASTContext*)" << (void*)&Origin.AST
-             << "\n";
+    logs() << "(ExternalASTMerger*)" << (void *)this
+           << (DoRecord ? " decided " : " decided NOT")
+           << " to record origin (DeclContext*)" << (void *)Origin.DC
+           << ", (ASTContext*)" << (void *)&Origin.AST << "\n";
 }
 
-void ExternalASTMerger::ForceRecordOrigin(const DeclContext *ToDC,
+void ExternalASTMerger::ForceRecordOrigin(DeclContext const *ToDC,
                                           DCOrigin Origin) {
   RecordOriginImpl(ToDC, Origin, ImporterForOrigin(*Origin.AST));
 }
 
-void ExternalASTMerger::RecordOriginImpl(const DeclContext *ToDC, DCOrigin Origin,
+void ExternalASTMerger::RecordOriginImpl(DeclContext const *ToDC,
+                                         DCOrigin Origin,
                                          ASTImporter &Importer) {
   Origins[ToDC] = Origin;
-  Importer.ASTImporter::MapImported(cast<Decl>(Origin.DC), const_cast<Decl*>(cast<Decl>(ToDC)));
+  Importer.ASTImporter::MapImported(cast<Decl>(Origin.DC),
+                                    const_cast<Decl *>(cast<Decl>(ToDC)));
 }
 
-ExternalASTMerger::ExternalASTMerger(const ImporterTarget &Target,
-                                     llvm::ArrayRef<ImporterSource> Sources) : LogStream(&llvm::nulls()), Target(Target) {
+ExternalASTMerger::ExternalASTMerger(ImporterTarget const &Target,
+                                     llvm::ArrayRef<ImporterSource> Sources)
+    : LogStream(&llvm::nulls()), Target(Target) {
   SharedState = std::make_shared<ASTImporterSharedState>(
       *Target.AST.getTranslationUnitDecl());
   AddSources(Sources);
@@ -403,14 +406,14 @@
 
 Decl *ExternalASTMerger::FindOriginalDecl(Decl *D) {
   assert(&D->getASTContext() == &Target.AST);
-  for (const auto &I : Importers)
+  for (auto const &I : Importers)
     if (auto Result = I->GetOriginalDecl(D))
       return Result;
   return nullptr;
 }
 
 void ExternalASTMerger::AddSources(llvm::ArrayRef<ImporterSource> Sources) {
-  for (const ImporterSource &S : Sources) {
+  for (ImporterSource const &S : Sources) {
     assert(&S.getASTContext() != &Target.AST);
     // Check that the associated merger actually imports into the source AST.
     assert(!S.getMerger() || &S.getMerger()->Target.AST == &S.getASTContext());
@@ -421,24 +424,26 @@
 
 void ExternalASTMerger::RemoveSources(llvm::ArrayRef<ImporterSource> Sources) {
   if (LoggingEnabled())
-    for (const ImporterSource &S : Sources)
+    for (ImporterSource const &S : Sources)
       logs() << "(ExternalASTMerger*)" << (void *)this
              << " removing source (ASTContext*)" << (void *)&S.getASTContext()
              << "\n";
   Importers.erase(
-      std::remove_if(Importers.begin(), Importers.end(),
-                     [&Sources](std::unique_ptr<ASTImporter> &Importer) -> bool {
-                       for (const ImporterSource &S : Sources) {
-                         if (&Importer->getFromContext() == &S.getASTContext())
-                           return true;
-                       }
-                       return false;
-                     }),
+      std::remove_if(
+          Importers.begin(), Importers.end(),
+          [&Sources](std::unique_ptr<ASTImporter> &Importer) -> bool {
+            for (const ImporterSource &S : Sources) {
+              if (&Importer->getFromContext() == &S.getASTContext())
+                return true;
+            }
+            return false;
+          }),
       Importers.end());
-  for (OriginMap::iterator OI = Origins.begin(), OE = Origins.end(); OI != OE; ) {
-    std::pair<const DeclContext *, DCOrigin> Origin = *OI;
+  for (OriginMap::iterator OI = Origins.begin(), OE = Origins.end();
+       OI != OE;) {
+    std::pair<DeclContext const *, DCOrigin> Origin = *OI;
     bool Erase = false;
-    for (const ImporterSource &S : Sources) {
+    for (ImporterSource const &S : Sources) {
       if (&S.getASTContext() == Origin.second.AST) {
         Erase = true;
         break;
@@ -476,19 +481,19 @@
   return false;
 }
 
-bool ExternalASTMerger::FindExternalVisibleDeclsByName(const DeclContext *DC,
+bool ExternalASTMerger::FindExternalVisibleDeclsByName(DeclContext const *DC,
                                                        DeclarationName Name) {
   llvm::SmallVector<NamedDecl *, 1> Decls;
   llvm::SmallVector<Candidate, 4> Candidates;
 
-  auto FilterFoundDecl = [&Candidates](const Candidate &C) {
-   if (!HasDeclOfSameType(Candidates, C))
-     Candidates.push_back(C);
+  auto FilterFoundDecl = [&Candidates](Candidate const &C) {
+    if (!HasDeclOfSameType(Candidates, C))
+      Candidates.push_back(C);
   };
 
   ForEachMatchingDC(DC,
                     [&](ASTImporter &Forward, ASTImporter &Reverse,
-                        Source<const DeclContext *> SourceDC) -> bool {
+                        Source<DeclContext const *> SourceDC) -> bool {
                       auto FromNameOrErr = Reverse.Import(Name);
                       if (!FromNameOrErr) {
                         llvm::consumeError(FromNameOrErr.takeError());
@@ -506,7 +511,7 @@
     return false;
 
   Decls.reserve(Candidates.size());
-  for (const Candidate &C : Candidates) {
+  for (Candidate const &C : Candidates) {
     Decl *LookupRes = C.first.get();
     ASTImporter *Importer = C.second;
     auto NDOrErr = Importer->Import(LookupRes);
@@ -526,21 +531,22 @@
 }
 
 void ExternalASTMerger::FindExternalLexicalDecls(
-    const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
+    DeclContext const *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
     SmallVectorImpl<Decl *> &Result) {
-  ForEachMatchingDC(DC, [&](ASTImporter &Forward, ASTImporter &Reverse,
-                            Source<const DeclContext *> SourceDC) -> bool {
-    for (const Decl *SourceDecl : SourceDC.get()->decls()) {
-      if (IsKindWeWant(SourceDecl->getKind())) {
-        auto ImportedDeclOrErr = Forward.Import(SourceDecl);
-        if (ImportedDeclOrErr)
-          assert(!(*ImportedDeclOrErr) ||
-                 IsSameDC((*ImportedDeclOrErr)->getDeclContext(), DC));
-        else
-          llvm::consumeError(ImportedDeclOrErr.takeError());
-      }
-    }
-    return false;
-  });
+  ForEachMatchingDC(
+      DC,
+      [&](ASTImporter &Forward, ASTImporter &Reverse,
+          Source<DeclContext const *> SourceDC) -> bool {
+        for (const Decl *SourceDecl : SourceDC.get()->decls()) {
+          if (IsKindWeWant(SourceDecl->getKind())) {
+            auto ImportedDeclOrErr = Forward.Import(SourceDecl);
+            if (ImportedDeclOrErr)
+              assert(!(*ImportedDeclOrErr) ||
+                     IsSameDC((*ImportedDeclOrErr)->getDeclContext(), DC));
+            else
+              llvm::consumeError(ImportedDeclOrErr.takeError());
+          }
+        }
+        return false;
+      });
 }
-
Index: clang/lib/AST/ExternalASTSource.cpp
===================================================================
--- clang/lib/AST/ExternalASTSource.cpp
+++ clang/lib/AST/ExternalASTSource.cpp
@@ -36,7 +36,7 @@
 }
 
 ExternalASTSource::ExtKind
-ExternalASTSource::hasExternalDefinitions(const Decl *D) {
+ExternalASTSource::hasExternalDefinitions(Decl const *D) {
   return EK_ReplyHazy;
 }
 
@@ -44,7 +44,7 @@
                                             unsigned Length,
                                             SmallVectorImpl<Decl *> &Decls) {}
 
-void ExternalASTSource::CompleteRedeclChain(const Decl *D) {}
+void ExternalASTSource::CompleteRedeclChain(Decl const *D) {}
 
 void ExternalASTSource::CompleteType(TagDecl *Tag) {}
 
@@ -61,24 +61,20 @@
 void ExternalASTSource::PrintStats() {}
 
 bool ExternalASTSource::layoutRecordType(
-    const RecordDecl *Record, uint64_t &Size, uint64_t &Alignment,
-    llvm::DenseMap<const FieldDecl *, uint64_t> &FieldOffsets,
-    llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
-    llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets) {
+    RecordDecl const *Record, uint64_t &Size, uint64_t &Alignment,
+    llvm::DenseMap<FieldDecl const *, uint64_t> &FieldOffsets,
+    llvm::DenseMap<CXXRecordDecl const *, CharUnits> &BaseOffsets,
+    llvm::DenseMap<CXXRecordDecl const *, CharUnits> &VirtualBaseOffsets) {
   return false;
 }
 
-Decl *ExternalASTSource::GetExternalDecl(uint32_t ID) {
-  return nullptr;
-}
+Decl *ExternalASTSource::GetExternalDecl(uint32_t ID) { return nullptr; }
 
 Selector ExternalASTSource::GetExternalSelector(uint32_t ID) {
   return Selector();
 }
 
-uint32_t ExternalASTSource::GetNumExternalSelectors() {
-   return 0;
-}
+uint32_t ExternalASTSource::GetNumExternalSelectors() { return 0; }
 
 Stmt *ExternalASTSource::GetExternalDeclStmt(uint64_t Offset) {
   return nullptr;
@@ -94,16 +90,15 @@
   return nullptr;
 }
 
-bool
-ExternalASTSource::FindExternalVisibleDeclsByName(const DeclContext *DC,
-                                                  DeclarationName Name) {
+bool ExternalASTSource::FindExternalVisibleDeclsByName(DeclContext const *DC,
+                                                       DeclarationName Name) {
   return false;
 }
 
-void ExternalASTSource::completeVisibleDeclsMap(const DeclContext *DC) {}
+void ExternalASTSource::completeVisibleDeclsMap(DeclContext const *DC) {}
 
 void ExternalASTSource::FindExternalLexicalDecls(
-    const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
+    DeclContext const *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
     SmallVectorImpl<Decl *> &Result) {}
 
 void ExternalASTSource::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {}
Index: clang/lib/AST/FormatString.cpp
===================================================================
--- clang/lib/AST/FormatString.cpp
+++ clang/lib/AST/FormatString.cpp
@@ -17,12 +17,12 @@
 #include "llvm/Support/ConvertUTF.h"
 
 using clang::analyze_format_string::ArgType;
-using clang::analyze_format_string::FormatStringHandler;
+using clang::analyze_format_string::ConversionSpecifier;
 using clang::analyze_format_string::FormatSpecifier;
+using clang::analyze_format_string::FormatStringHandler;
 using clang::analyze_format_string::LengthModifier;
 using clang::analyze_format_string::OptionalAmount;
 using clang::analyze_format_string::PositionContext;
-using clang::analyze_format_string::ConversionSpecifier;
 using namespace clang;
 
 // Key function to FormatStringHandler.
@@ -33,15 +33,15 @@
 // scanf format strings.
 //===----------------------------------------------------------------------===//
 
-OptionalAmount
-clang::analyze_format_string::ParseAmount(const char *&Beg, const char *E) {
-  const char *I = Beg;
-  UpdateOnReturn <const char*> UpdateBeg(Beg, I);
+OptionalAmount clang::analyze_format_string::ParseAmount(char const *&Beg,
+                                                         char const *E) {
+  char const *I = Beg;
+  UpdateOnReturn<char const *> UpdateBeg(Beg, I);
 
   unsigned accumulator = 0;
   bool hasDigits = false;
 
-  for ( ; I != E; ++I) {
+  for (; I != E; ++I) {
     char c = *I;
     if (c >= '0' && c <= '9') {
       hasDigits = true;
@@ -51,7 +51,7 @@
 
     if (hasDigits)
       return OptionalAmount(OptionalAmount::Constant, accumulator, Beg, I - Beg,
-          false);
+                            false);
 
     break;
   }
@@ -59,10 +59,8 @@
   return OptionalAmount();
 }
 
-OptionalAmount
-clang::analyze_format_string::ParseNonPositionAmount(const char *&Beg,
-                                                     const char *E,
-                                                     unsigned &argIndex) {
+OptionalAmount clang::analyze_format_string::ParseNonPositionAmount(
+    char const *&Beg, char const *E, unsigned &argIndex) {
   if (*Beg == '*') {
     ++Beg;
     return OptionalAmount(OptionalAmount::Arg, argIndex++, Beg, 0, false);
@@ -71,15 +69,12 @@
   return ParseAmount(Beg, E);
 }
 
-OptionalAmount
-clang::analyze_format_string::ParsePositionAmount(FormatStringHandler &H,
-                                                  const char *Start,
-                                                  const char *&Beg,
-                                                  const char *E,
-                                                  PositionContext p) {
+OptionalAmount clang::analyze_format_string::ParsePositionAmount(
+    FormatStringHandler &H, char const *Start, char const *&Beg, char const *E,
+    PositionContext p) {
   if (*Beg == '*') {
-    const char *I = Beg + 1;
-    const OptionalAmount &Amt = ParseAmount(I, E);
+    char const *I = Beg + 1;
+    OptionalAmount const &Amt = ParseAmount(I, E);
 
     if (Amt.getHowSpecified() == OptionalAmount::NotSpecified) {
       H.HandleInvalidPosition(Beg, I - Beg, p);
@@ -103,7 +98,7 @@
         return OptionalAmount(false);
       }
 
-      const char *Tmp = Beg;
+      char const *Tmp = Beg;
       Beg = ++I;
 
       return OptionalAmount(OptionalAmount::Arg, Amt.getConstantAmount() - 1,
@@ -117,21 +112,15 @@
   return ParseAmount(Beg, E);
 }
 
-
-bool
-clang::analyze_format_string::ParseFieldWidth(FormatStringHandler &H,
-                                              FormatSpecifier &CS,
-                                              const char *Start,
-                                              const char *&Beg, const char *E,
-                                              unsigned *argIndex) {
+bool clang::analyze_format_string::ParseFieldWidth(
+    FormatStringHandler &H, FormatSpecifier &CS, char const *Start,
+    char const *&Beg, char const *E, unsigned *argIndex) {
   // FIXME: Support negative field widths.
   if (argIndex) {
     CS.setFieldWidth(ParseNonPositionAmount(Beg, E, *argIndex));
-  }
-  else {
-    const OptionalAmount Amt =
-      ParsePositionAmount(H, Start, Beg, E,
-                          analyze_format_string::FieldWidthPos);
+  } else {
+    const OptionalAmount Amt = ParsePositionAmount(
+        H, Start, Beg, E, analyze_format_string::FieldWidthPos);
 
     if (Amt.isInvalid())
       return true;
@@ -140,15 +129,14 @@
   return false;
 }
 
-bool
-clang::analyze_format_string::ParseArgPosition(FormatStringHandler &H,
-                                               FormatSpecifier &FS,
-                                               const char *Start,
-                                               const char *&Beg,
-                                               const char *E) {
-  const char *I = Beg;
+bool clang::analyze_format_string::ParseArgPosition(FormatStringHandler &H,
+                                                    FormatSpecifier &FS,
+                                                    char const *Start,
+                                                    char const *&Beg,
+                                                    char const *E) {
+  char const *I = Beg;
 
-  const OptionalAmount &Amt = ParseAmount(I, E);
+  OptionalAmount const &Amt = ParseAmount(I, E);
 
   if (I == E) {
     // No more characters left?
@@ -177,16 +165,15 @@
   return false;
 }
 
-bool
-clang::analyze_format_string::ParseVectorModifier(FormatStringHandler &H,
-                                                  FormatSpecifier &FS,
-                                                  const char *&I,
-                                                  const char *E,
-                                                  const LangOptions &LO) {
+bool clang::analyze_format_string::ParseVectorModifier(FormatStringHandler &H,
+                                                       FormatSpecifier &FS,
+                                                       char const *&I,
+                                                       char const *E,
+                                                       LangOptions const &LO) {
   if (!LO.OpenCL)
     return false;
 
-  const char *Start = I;
+  char const *Start = I;
   if (*I == 'v') {
     ++I;
 
@@ -207,86 +194,102 @@
   return false;
 }
 
-bool
-clang::analyze_format_string::ParseLengthModifier(FormatSpecifier &FS,
-                                                  const char *&I,
-                                                  const char *E,
-                                                  const LangOptions &LO,
-                                                  bool IsScanf) {
+bool clang::analyze_format_string::ParseLengthModifier(FormatSpecifier &FS,
+                                                       char const *&I,
+                                                       char const *E,
+                                                       LangOptions const &LO,
+                                                       bool IsScanf) {
   LengthModifier::Kind lmKind = LengthModifier::None;
-  const char *lmPosition = I;
+  char const *lmPosition = I;
   switch (*I) {
-    default:
-      return false;
-    case 'h':
+  default:
+    return false;
+  case 'h':
+    ++I;
+    if (I != E && *I == 'h') {
       ++I;
-      if (I != E && *I == 'h') {
-        ++I;
-        lmKind = LengthModifier::AsChar;
-      } else if (I != E && *I == 'l' && LO.OpenCL) {
-        ++I;
-        lmKind = LengthModifier::AsShortLong;
-      } else {
-        lmKind = LengthModifier::AsShort;
-      }
-      break;
-    case 'l':
+      lmKind = LengthModifier::AsChar;
+    } else if (I != E && *I == 'l' && LO.OpenCL) {
+      ++I;
+      lmKind = LengthModifier::AsShortLong;
+    } else {
+      lmKind = LengthModifier::AsShort;
+    }
+    break;
+  case 'l':
+    ++I;
+    if (I != E && *I == 'l') {
+      ++I;
+      lmKind = LengthModifier::AsLongLong;
+    } else {
+      lmKind = LengthModifier::AsLong;
+    }
+    break;
+  case 'j':
+    lmKind = LengthModifier::AsIntMax;
+    ++I;
+    break;
+  case 'z':
+    lmKind = LengthModifier::AsSizeT;
+    ++I;
+    break;
+  case 't':
+    lmKind = LengthModifier::AsPtrDiff;
+    ++I;
+    break;
+  case 'L':
+    lmKind = LengthModifier::AsLongDouble;
+    ++I;
+    break;
+  case 'q':
+    lmKind = LengthModifier::AsQuad;
+    ++I;
+    break;
+  case 'a':
+    if (IsScanf && !LO.C99 && !LO.CPlusPlus11) {
+      // For scanf in C90, look at the next character to see if this should
+      // be parsed as the GNU extension 'a' length modifier. If not, this
+      // will be parsed as a conversion specifier.
       ++I;
-      if (I != E && *I == 'l') {
-        ++I;
-        lmKind = LengthModifier::AsLongLong;
-      } else {
-        lmKind = LengthModifier::AsLong;
+      if (I != E && (*I == 's' || *I == 'S' || *I == '[')) {
+        lmKind = LengthModifier::AsAllocate;
+        break;
       }
+      --I;
+    }
+    return false;
+  case 'm':
+    if (IsScanf) {
+      lmKind = LengthModifier::AsMAllocate;
+      ++I;
       break;
-    case 'j': lmKind = LengthModifier::AsIntMax;     ++I; break;
-    case 'z': lmKind = LengthModifier::AsSizeT;      ++I; break;
-    case 't': lmKind = LengthModifier::AsPtrDiff;    ++I; break;
-    case 'L': lmKind = LengthModifier::AsLongDouble; ++I; break;
-    case 'q': lmKind = LengthModifier::AsQuad;       ++I; break;
-    case 'a':
-      if (IsScanf && !LO.C99 && !LO.CPlusPlus11) {
-        // For scanf in C90, look at the next character to see if this should
-        // be parsed as the GNU extension 'a' length modifier. If not, this
-        // will be parsed as a conversion specifier.
-        ++I;
-        if (I != E && (*I == 's' || *I == 'S' || *I == '[')) {
-          lmKind = LengthModifier::AsAllocate;
-          break;
-        }
-        --I;
-      }
-      return false;
-    case 'm':
-      if (IsScanf) {
-        lmKind = LengthModifier::AsMAllocate;
-        ++I;
+    }
+    return false;
+  // printf: AsInt64, AsInt32, AsInt3264
+  // scanf:  AsInt64
+  case 'I':
+    if (I + 1 != E && I + 2 != E) {
+      if (I[1] == '6' && I[2] == '4') {
+        I += 3;
+        lmKind = LengthModifier::AsInt64;
         break;
       }
-      return false;
-    // printf: AsInt64, AsInt32, AsInt3264
-    // scanf:  AsInt64
-    case 'I':
-      if (I + 1 != E && I + 2 != E) {
-        if (I[1] == '6' && I[2] == '4') {
-          I += 3;
-          lmKind = LengthModifier::AsInt64;
-          break;
-        }
-        if (IsScanf)
-          return false;
-
-        if (I[1] == '3' && I[2] == '2') {
-          I += 3;
-          lmKind = LengthModifier::AsInt32;
-          break;
-        }
+      if (IsScanf)
+        return false;
+
+      if (I[1] == '3' && I[2] == '2') {
+        I += 3;
+        lmKind = LengthModifier::AsInt32;
+        break;
       }
-      ++I;
-      lmKind = LengthModifier::AsInt3264;
-      break;
-    case 'w':
-      lmKind = LengthModifier::AsWide; ++I; break;
+    }
+    ++I;
+    lmKind = LengthModifier::AsInt3264;
+    break;
+  case 'w':
+    lmKind = LengthModifier::AsWide;
+    ++I;
+    break;
   }
   LengthModifier lm(lmPosition, lmKind);
   FS.setLengthModifier(lm);
@@ -294,14 +297,14 @@
 }
 
 bool clang::analyze_format_string::ParseUTF8InvalidSpecifier(
-    const char *SpecifierBegin, const char *FmtStrEnd, unsigned &Len) {
+    char const *SpecifierBegin, char const *FmtStrEnd, unsigned &Len) {
   if (SpecifierBegin + 1 >= FmtStrEnd)
     return false;
 
-  const llvm::UTF8 *SB =
-      reinterpret_cast<const llvm::UTF8 *>(SpecifierBegin + 1);
-  const llvm::UTF8 *SE = reinterpret_cast<const llvm::UTF8 *>(FmtStrEnd);
-  const char FirstByte = *SB;
+  llvm::UTF8 const *SB =
+      reinterpret_cast<llvm::UTF8 const *>(SpecifierBegin + 1);
+  llvm::UTF8 const *SE = reinterpret_cast<llvm::UTF8 const *>(FmtStrEnd);
+  char const FirstByte = *SB;
 
   // If the invalid specifier is a multibyte UTF-8 string, return the
   // total length accordingly so that the conversion specifier can be
@@ -324,7 +327,7 @@
 ArgType::matchesType(ASTContext &C, QualType argTy) const {
   if (Ptr) {
     // It has to be a pointer.
-    const PointerType *PT = argTy->getAs<PointerType>();
+    PointerType const *PT = argTy->getAs<PointerType>();
     if (!PT)
       return NoMatch;
 
@@ -336,157 +339,157 @@
   }
 
   switch (K) {
-    case InvalidTy:
-      llvm_unreachable("ArgType must be valid");
+  case InvalidTy:
+    llvm_unreachable("ArgType must be valid");
 
-    case UnknownTy:
-      return Match;
+  case UnknownTy:
+    return Match;
 
-    case AnyCharTy: {
-      if (const EnumType *ETy = argTy->getAs<EnumType>()) {
-        // If the enum is incomplete we know nothing about the underlying type.
-        // Assume that it's 'int'.
-        if (!ETy->getDecl()->isComplete())
-          return NoMatch;
-        argTy = ETy->getDecl()->getIntegerType();
+  case AnyCharTy: {
+    if (EnumType const *ETy = argTy->getAs<EnumType>()) {
+      // If the enum is incomplete we know nothing about the underlying type.
+      // Assume that it's 'int'.
+      if (!ETy->getDecl()->isComplete())
+        return NoMatch;
+      argTy = ETy->getDecl()->getIntegerType();
+    }
+
+    if (BuiltinType const *BT = argTy->getAs<BuiltinType>())
+      switch (BT->getKind()) {
+      default:
+        break;
+      case BuiltinType::Char_S:
+      case BuiltinType::SChar:
+      case BuiltinType::UChar:
+      case BuiltinType::Char_U:
+      case BuiltinType::Bool:
+        return Match;
       }
+    return NoMatch;
+  }
 
-      if (const BuiltinType *BT = argTy->getAs<BuiltinType>())
-        switch (BT->getKind()) {
-          default:
-            break;
-          case BuiltinType::Char_S:
-          case BuiltinType::SChar:
-          case BuiltinType::UChar:
-          case BuiltinType::Char_U:
-          case BuiltinType::Bool:
-            return Match;
-        }
-      return NoMatch;
+  case SpecificTy: {
+    if (EnumType const *ETy = argTy->getAs<EnumType>()) {
+      // If the enum is incomplete we know nothing about the underlying type.
+      // Assume that it's 'int'.
+      if (!ETy->getDecl()->isComplete())
+        argTy = C.IntTy;
+      else
+        argTy = ETy->getDecl()->getIntegerType();
     }
+    argTy = C.getCanonicalType(argTy).getUnqualifiedType();
 
-    case SpecificTy: {
-      if (const EnumType *ETy = argTy->getAs<EnumType>()) {
-        // If the enum is incomplete we know nothing about the underlying type.
-        // Assume that it's 'int'.
-        if (!ETy->getDecl()->isComplete())
-          argTy = C.IntTy;
-        else
-          argTy = ETy->getDecl()->getIntegerType();
+    if (T == argTy)
+      return Match;
+    // Check for "compatible types".
+    if (BuiltinType const *BT = argTy->getAs<BuiltinType>())
+      switch (BT->getKind()) {
+      default:
+        break;
+      case BuiltinType::Char_S:
+      case BuiltinType::SChar:
+      case BuiltinType::Char_U:
+      case BuiltinType::UChar:
+      case BuiltinType::Bool:
+        if (T == C.UnsignedShortTy || T == C.ShortTy)
+          return NoMatchTypeConfusion;
+        return T == C.UnsignedCharTy || T == C.SignedCharTy ? Match : NoMatch;
+      case BuiltinType::Short:
+        return T == C.UnsignedShortTy ? Match : NoMatch;
+      case BuiltinType::UShort:
+        return T == C.ShortTy ? Match : NoMatch;
+      case BuiltinType::Int:
+        return T == C.UnsignedIntTy ? Match : NoMatch;
+      case BuiltinType::UInt:
+        return T == C.IntTy ? Match : NoMatch;
+      case BuiltinType::Long:
+        return T == C.UnsignedLongTy ? Match : NoMatch;
+      case BuiltinType::ULong:
+        return T == C.LongTy ? Match : NoMatch;
+      case BuiltinType::LongLong:
+        return T == C.UnsignedLongLongTy ? Match : NoMatch;
+      case BuiltinType::ULongLong:
+        return T == C.LongLongTy ? Match : NoMatch;
       }
-      argTy = C.getCanonicalType(argTy).getUnqualifiedType();
+    return NoMatch;
+  }
 
-      if (T == argTy)
-        return Match;
-      // Check for "compatible types".
-      if (const BuiltinType *BT = argTy->getAs<BuiltinType>())
-        switch (BT->getKind()) {
-          default:
-            break;
-          case BuiltinType::Char_S:
-          case BuiltinType::SChar:
-          case BuiltinType::Char_U:
-          case BuiltinType::UChar:
-          case BuiltinType::Bool:
-            if (T == C.UnsignedShortTy || T == C.ShortTy)
-              return NoMatchTypeConfusion;
-            return T == C.UnsignedCharTy || T == C.SignedCharTy ? Match
-                                                                : NoMatch;
-          case BuiltinType::Short:
-            return T == C.UnsignedShortTy ? Match : NoMatch;
-          case BuiltinType::UShort:
-            return T == C.ShortTy ? Match : NoMatch;
-          case BuiltinType::Int:
-            return T == C.UnsignedIntTy ? Match : NoMatch;
-          case BuiltinType::UInt:
-            return T == C.IntTy ? Match : NoMatch;
-          case BuiltinType::Long:
-            return T == C.UnsignedLongTy ? Match : NoMatch;
-          case BuiltinType::ULong:
-            return T == C.LongTy ? Match : NoMatch;
-          case BuiltinType::LongLong:
-            return T == C.UnsignedLongLongTy ? Match : NoMatch;
-          case BuiltinType::ULongLong:
-            return T == C.LongLongTy ? Match : NoMatch;
-        }
+  case CStrTy: {
+    PointerType const *PT = argTy->getAs<PointerType>();
+    if (!PT)
       return NoMatch;
-    }
+    QualType pointeeTy = PT->getPointeeType();
+    if (BuiltinType const *BT = pointeeTy->getAs<BuiltinType>())
+      switch (BT->getKind()) {
+      case BuiltinType::Char_U:
+      case BuiltinType::UChar:
+      case BuiltinType::Char_S:
+      case BuiltinType::SChar:
+        return Match;
+      default:
+        break;
+      }
 
-    case CStrTy: {
-      const PointerType *PT = argTy->getAs<PointerType>();
-      if (!PT)
-        return NoMatch;
-      QualType pointeeTy = PT->getPointeeType();
-      if (const BuiltinType *BT = pointeeTy->getAs<BuiltinType>())
-        switch (BT->getKind()) {
-          case BuiltinType::Char_U:
-          case BuiltinType::UChar:
-          case BuiltinType::Char_S:
-          case BuiltinType::SChar:
-            return Match;
-          default:
-            break;
-        }
+    return NoMatch;
+  }
 
+  case WCStrTy: {
+    PointerType const *PT = argTy->getAs<PointerType>();
+    if (!PT)
       return NoMatch;
-    }
-
-    case WCStrTy: {
-      const PointerType *PT = argTy->getAs<PointerType>();
-      if (!PT)
-        return NoMatch;
-      QualType pointeeTy =
+    QualType pointeeTy =
         C.getCanonicalType(PT->getPointeeType()).getUnqualifiedType();
-      return pointeeTy == C.getWideCharType() ? Match : NoMatch;
-    }
+    return pointeeTy == C.getWideCharType() ? Match : NoMatch;
+  }
 
-    case WIntTy: {
-      QualType WInt = C.getCanonicalType(C.getWIntType()).getUnqualifiedType();
+  case WIntTy: {
+    QualType WInt = C.getCanonicalType(C.getWIntType()).getUnqualifiedType();
 
-      if (C.getCanonicalType(argTy).getUnqualifiedType() == WInt)
-        return Match;
+    if (C.getCanonicalType(argTy).getUnqualifiedType() == WInt)
+      return Match;
 
-      QualType PromoArg = argTy->isPromotableIntegerType()
-                              ? C.getPromotedIntegerType(argTy)
-                              : argTy;
-      PromoArg = C.getCanonicalType(PromoArg).getUnqualifiedType();
+    QualType PromoArg = argTy->isPromotableIntegerType()
+                            ? C.getPromotedIntegerType(argTy)
+                            : argTy;
+    PromoArg = C.getCanonicalType(PromoArg).getUnqualifiedType();
 
-      // If the promoted argument is the corresponding signed type of the
-      // wint_t type, then it should match.
-      if (PromoArg->hasSignedIntegerRepresentation() &&
-          C.getCorrespondingUnsignedType(PromoArg) == WInt)
-        return Match;
+    // If the promoted argument is the corresponding signed type of the
+    // wint_t type, then it should match.
+    if (PromoArg->hasSignedIntegerRepresentation() &&
+        C.getCorrespondingUnsignedType(PromoArg) == WInt)
+      return Match;
+
+    return WInt == PromoArg ? Match : NoMatch;
+  }
 
-      return WInt == PromoArg ? Match : NoMatch;
+  case CPointerTy:
+    if (argTy->isVoidPointerType()) {
+      return Match;
+    }
+    if (argTy->isPointerType() || argTy->isObjCObjectPointerType() ||
+        argTy->isBlockPointerType() || argTy->isNullPtrType()) {
+      return NoMatchPedantic;
+    } else {
+      return NoMatch;
     }
 
-    case CPointerTy:
-      if (argTy->isVoidPointerType()) {
-        return Match;
-      } if (argTy->isPointerType() || argTy->isObjCObjectPointerType() ||
-            argTy->isBlockPointerType() || argTy->isNullPtrType()) {
-        return NoMatchPedantic;
-      } else {
-        return NoMatch;
-      }
+  case ObjCPointerTy: {
+    if (argTy->getAs<ObjCObjectPointerType>() ||
+        argTy->getAs<BlockPointerType>())
+      return Match;
 
-    case ObjCPointerTy: {
-      if (argTy->getAs<ObjCObjectPointerType>() ||
-          argTy->getAs<BlockPointerType>())
+    // Handle implicit toll-free bridging.
+    if (PointerType const *PT = argTy->getAs<PointerType>()) {
+      // Things such as CFTypeRef are really just opaque pointers
+      // to C structs representing CF types that can often be bridged
+      // to Objective-C objects.  Since the compiler doesn't know which
+      // structs can be toll-free bridged, we just accept them all.
+      QualType pointee = PT->getPointeeType();
+      if (pointee->getAsStructureType() || pointee->isVoidType())
         return Match;
-
-      // Handle implicit toll-free bridging.
-      if (const PointerType *PT = argTy->getAs<PointerType>()) {
-        // Things such as CFTypeRef are really just opaque pointers
-        // to C structs representing CF types that can often be bridged
-        // to Objective-C objects.  Since the compiler doesn't know which
-        // structs can be toll-free bridged, we just accept them all.
-        QualType pointee = PT->getPointeeType();
-        if (pointee->getAsStructureType() || pointee->isVoidType())
-          return Match;
-      }
-      return NoMatch;
     }
+    return NoMatch;
+  }
   }
 
   llvm_unreachable("Invalid ArgType Kind!");
@@ -504,32 +507,32 @@
 QualType ArgType::getRepresentativeType(ASTContext &C) const {
   QualType Res;
   switch (K) {
-    case InvalidTy:
-      llvm_unreachable("No representative type for Invalid ArgType");
-    case UnknownTy:
-      llvm_unreachable("No representative type for Unknown ArgType");
-    case AnyCharTy:
-      Res = C.CharTy;
-      break;
-    case SpecificTy:
-      Res = T;
-      break;
-    case CStrTy:
-      Res = C.getPointerType(C.CharTy);
-      break;
-    case WCStrTy:
-      Res = C.getPointerType(C.getWideCharType());
-      break;
-    case ObjCPointerTy:
-      Res = C.ObjCBuiltinIdTy;
-      break;
-    case CPointerTy:
-      Res = C.VoidPtrTy;
-      break;
-    case WIntTy: {
-      Res = C.getWIntType();
-      break;
-    }
+  case InvalidTy:
+    llvm_unreachable("No representative type for Invalid ArgType");
+  case UnknownTy:
+    llvm_unreachable("No representative type for Unknown ArgType");
+  case AnyCharTy:
+    Res = C.CharTy;
+    break;
+  case SpecificTy:
+    Res = T;
+    break;
+  case CStrTy:
+    Res = C.getPointerType(C.CharTy);
+    break;
+  case WCStrTy:
+    Res = C.getPointerType(C.getWideCharType());
+    break;
+  case ObjCPointerTy:
+    Res = C.ObjCBuiltinIdTy;
+    break;
+  case CPointerTy:
+    Res = C.VoidPtrTy;
+    break;
+  case WIntTy: {
+    Res = C.getWIntType();
+    break;
+  }
   }
 
   if (Ptr)
@@ -546,7 +549,7 @@
     Alias = Name;
     if (Ptr) {
       // If ArgType is actually a pointer to T, append an asterisk.
-      Alias += (Alias[Alias.size()-1] == '*') ? "*" : " *";
+      Alias += (Alias[Alias.size() - 1] == '*') ? "*" : " *";
     }
     // If Alias is the same as the underlying type, e.g. wchar_t, then drop it.
     if (S == Alias)
@@ -558,7 +561,6 @@
   return std::string("'") + S + "'";
 }
 
-
 //===----------------------------------------------------------------------===//
 // Methods on OptionalAmount.
 //===----------------------------------------------------------------------===//
@@ -572,8 +574,7 @@
 // Methods on LengthModifier.
 //===----------------------------------------------------------------------===//
 
-const char *
-analyze_format_string::LengthModifier::toString() const {
+char const *analyze_format_string::LengthModifier::toString() const {
   switch (kind) {
   case AsChar:
     return "hh";
@@ -617,53 +618,86 @@
 // Methods on ConversionSpecifier.
 //===----------------------------------------------------------------------===//
 
-const char *ConversionSpecifier::toString() const {
+char const *ConversionSpecifier::toString() const {
   switch (kind) {
-  case dArg: return "d";
-  case DArg: return "D";
-  case iArg: return "i";
-  case oArg: return "o";
-  case OArg: return "O";
-  case uArg: return "u";
-  case UArg: return "U";
-  case xArg: return "x";
-  case XArg: return "X";
-  case fArg: return "f";
-  case FArg: return "F";
-  case eArg: return "e";
-  case EArg: return "E";
-  case gArg: return "g";
-  case GArg: return "G";
-  case aArg: return "a";
-  case AArg: return "A";
-  case cArg: return "c";
-  case sArg: return "s";
-  case pArg: return "p";
+  case dArg:
+    return "d";
+  case DArg:
+    return "D";
+  case iArg:
+    return "i";
+  case oArg:
+    return "o";
+  case OArg:
+    return "O";
+  case uArg:
+    return "u";
+  case UArg:
+    return "U";
+  case xArg:
+    return "x";
+  case XArg:
+    return "X";
+  case fArg:
+    return "f";
+  case FArg:
+    return "F";
+  case eArg:
+    return "e";
+  case EArg:
+    return "E";
+  case gArg:
+    return "g";
+  case GArg:
+    return "G";
+  case aArg:
+    return "a";
+  case AArg:
+    return "A";
+  case cArg:
+    return "c";
+  case sArg:
+    return "s";
+  case pArg:
+    return "p";
   case PArg:
     return "P";
-  case nArg: return "n";
-  case PercentArg:  return "%";
-  case ScanListArg: return "[";
-  case InvalidSpecifier: return nullptr;
+  case nArg:
+    return "n";
+  case PercentArg:
+    return "%";
+  case ScanListArg:
+    return "[";
+  case InvalidSpecifier:
+    return nullptr;
 
   // POSIX unicode extensions.
-  case CArg: return "C";
-  case SArg: return "S";
+  case CArg:
+    return "C";
+  case SArg:
+    return "S";
 
   // Objective-C specific specifiers.
-  case ObjCObjArg: return "@";
+  case ObjCObjArg:
+    return "@";
 
   // FreeBSD kernel specific specifiers.
-  case FreeBSDbArg: return "b";
-  case FreeBSDDArg: return "D";
-  case FreeBSDrArg: return "r";
-  case FreeBSDyArg: return "y";
+  case FreeBSDbArg:
+    return "b";
+  case FreeBSDDArg:
+    return "D";
+  case FreeBSDrArg:
+    return "r";
+  case FreeBSDyArg:
+    return "y";
 
   // GlibC specific specifiers.
-  case PrintErrno: return "m";
+  case PrintErrno:
+    return "m";
 
   // MS specific specifiers.
-  case ZArg: return "Z";
+  case ZArg:
+    return "Z";
   }
   return nullptr;
 }
@@ -702,7 +736,7 @@
     return;
   case Arg:
     if (UsesDotPrefix)
-        os << ".";
+      os << ".";
     if (usesPositionalArg())
       os << "*" << getPositionalArgIndex() << "$";
     else
@@ -710,252 +744,252 @@
     break;
   case Constant:
     if (UsesDotPrefix)
-        os << ".";
+      os << ".";
     os << amt;
     break;
   }
 }
 
-bool FormatSpecifier::hasValidLengthModifier(const TargetInfo &Target,
-                                             const LangOptions &LO) const {
+bool FormatSpecifier::hasValidLengthModifier(TargetInfo const &Target,
+                                             LangOptions const &LO) const {
   switch (LM.getKind()) {
-    case LengthModifier::None:
-      return true;
-
-    // Handle most integer flags
-    case LengthModifier::AsShort:
-      // Length modifier only applies to FP vectors.
-      if (LO.OpenCL && CS.isDoubleArg())
-        return !VectorNumElts.isInvalid();
-
-      if (Target.getTriple().isOSMSVCRT()) {
-        switch (CS.getKind()) {
-          case ConversionSpecifier::cArg:
-          case ConversionSpecifier::CArg:
-          case ConversionSpecifier::sArg:
-          case ConversionSpecifier::SArg:
-          case ConversionSpecifier::ZArg:
-            return true;
-          default:
-            break;
-        }
-      }
-      LLVM_FALLTHROUGH;
-    case LengthModifier::AsChar:
-    case LengthModifier::AsLongLong:
-    case LengthModifier::AsQuad:
-    case LengthModifier::AsIntMax:
-    case LengthModifier::AsSizeT:
-    case LengthModifier::AsPtrDiff:
-      switch (CS.getKind()) {
-        case ConversionSpecifier::dArg:
-        case ConversionSpecifier::DArg:
-        case ConversionSpecifier::iArg:
-        case ConversionSpecifier::oArg:
-        case ConversionSpecifier::OArg:
-        case ConversionSpecifier::uArg:
-        case ConversionSpecifier::UArg:
-        case ConversionSpecifier::xArg:
-        case ConversionSpecifier::XArg:
-        case ConversionSpecifier::nArg:
-          return true;
-        case ConversionSpecifier::FreeBSDrArg:
-        case ConversionSpecifier::FreeBSDyArg:
-          return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS4();
-        default:
-          return false;
-      }
-
-    case LengthModifier::AsShortLong:
-      return LO.OpenCL && !VectorNumElts.isInvalid();
-
-    // Handle 'l' flag
-    case LengthModifier::AsLong: // or AsWideChar
-      if (CS.isDoubleArg()) {
-        // Invalid for OpenCL FP scalars.
-        if (LO.OpenCL && VectorNumElts.isInvalid())
-          return false;
-        return true;
-      }
+  case LengthModifier::None:
+    return true;
 
-      switch (CS.getKind()) {
-        case ConversionSpecifier::dArg:
-        case ConversionSpecifier::DArg:
-        case ConversionSpecifier::iArg:
-        case ConversionSpecifier::oArg:
-        case ConversionSpecifier::OArg:
-        case ConversionSpecifier::uArg:
-        case ConversionSpecifier::UArg:
-        case ConversionSpecifier::xArg:
-        case ConversionSpecifier::XArg:
-        case ConversionSpecifier::nArg:
-        case ConversionSpecifier::cArg:
-        case ConversionSpecifier::sArg:
-        case ConversionSpecifier::ScanListArg:
-        case ConversionSpecifier::ZArg:
-          return true;
-        case ConversionSpecifier::FreeBSDrArg:
-        case ConversionSpecifier::FreeBSDyArg:
-          return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS4();
-        default:
-          return false;
-      }
+  // Handle most integer flags
+  case LengthModifier::AsShort:
+    // Length modifier only applies to FP vectors.
+    if (LO.OpenCL && CS.isDoubleArg())
+      return !VectorNumElts.isInvalid();
 
-    case LengthModifier::AsLongDouble:
+    if (Target.getTriple().isOSMSVCRT()) {
       switch (CS.getKind()) {
-        case ConversionSpecifier::aArg:
-        case ConversionSpecifier::AArg:
-        case ConversionSpecifier::fArg:
-        case ConversionSpecifier::FArg:
-        case ConversionSpecifier::eArg:
-        case ConversionSpecifier::EArg:
-        case ConversionSpecifier::gArg:
-        case ConversionSpecifier::GArg:
-          return true;
-        // GNU libc extension.
-        case ConversionSpecifier::dArg:
-        case ConversionSpecifier::iArg:
-        case ConversionSpecifier::oArg:
-        case ConversionSpecifier::uArg:
-        case ConversionSpecifier::xArg:
-        case ConversionSpecifier::XArg:
-          return !Target.getTriple().isOSDarwin() &&
-                 !Target.getTriple().isOSWindows();
-        default:
-          return false;
-      }
-
-    case LengthModifier::AsAllocate:
-      switch (CS.getKind()) {
-        case ConversionSpecifier::sArg:
-        case ConversionSpecifier::SArg:
-        case ConversionSpecifier::ScanListArg:
-          return true;
-        default:
-          return false;
+      case ConversionSpecifier::cArg:
+      case ConversionSpecifier::CArg:
+      case ConversionSpecifier::sArg:
+      case ConversionSpecifier::SArg:
+      case ConversionSpecifier::ZArg:
+        return true;
+      default:
+        break;
       }
+    }
+    LLVM_FALLTHROUGH;
+  case LengthModifier::AsChar:
+  case LengthModifier::AsLongLong:
+  case LengthModifier::AsQuad:
+  case LengthModifier::AsIntMax:
+  case LengthModifier::AsSizeT:
+  case LengthModifier::AsPtrDiff:
+    switch (CS.getKind()) {
+    case ConversionSpecifier::dArg:
+    case ConversionSpecifier::DArg:
+    case ConversionSpecifier::iArg:
+    case ConversionSpecifier::oArg:
+    case ConversionSpecifier::OArg:
+    case ConversionSpecifier::uArg:
+    case ConversionSpecifier::UArg:
+    case ConversionSpecifier::xArg:
+    case ConversionSpecifier::XArg:
+    case ConversionSpecifier::nArg:
+      return true;
+    case ConversionSpecifier::FreeBSDrArg:
+    case ConversionSpecifier::FreeBSDyArg:
+      return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS4();
+    default:
+      return false;
+    }
 
-    case LengthModifier::AsMAllocate:
-      switch (CS.getKind()) {
-        case ConversionSpecifier::cArg:
-        case ConversionSpecifier::CArg:
-        case ConversionSpecifier::sArg:
-        case ConversionSpecifier::SArg:
-        case ConversionSpecifier::ScanListArg:
-          return true;
-        default:
-          return false;
-      }
-    case LengthModifier::AsInt32:
-    case LengthModifier::AsInt3264:
-    case LengthModifier::AsInt64:
-      switch (CS.getKind()) {
-        case ConversionSpecifier::dArg:
-        case ConversionSpecifier::iArg:
-        case ConversionSpecifier::oArg:
-        case ConversionSpecifier::uArg:
-        case ConversionSpecifier::xArg:
-        case ConversionSpecifier::XArg:
-          return Target.getTriple().isOSMSVCRT();
-        default:
-          return false;
-      }
-    case LengthModifier::AsWide:
-      switch (CS.getKind()) {
-        case ConversionSpecifier::cArg:
-        case ConversionSpecifier::CArg:
-        case ConversionSpecifier::sArg:
-        case ConversionSpecifier::SArg:
-        case ConversionSpecifier::ZArg:
-          return Target.getTriple().isOSMSVCRT();
-        default:
-          return false;
-      }
-  }
-  llvm_unreachable("Invalid LengthModifier Kind!");
-}
+  case LengthModifier::AsShortLong:
+    return LO.OpenCL && !VectorNumElts.isInvalid();
 
-bool FormatSpecifier::hasStandardLengthModifier() const {
-  switch (LM.getKind()) {
-    case LengthModifier::None:
-    case LengthModifier::AsChar:
-    case LengthModifier::AsShort:
-    case LengthModifier::AsLong:
-    case LengthModifier::AsLongLong:
-    case LengthModifier::AsIntMax:
-    case LengthModifier::AsSizeT:
-    case LengthModifier::AsPtrDiff:
-    case LengthModifier::AsLongDouble:
+  // Handle 'l' flag
+  case LengthModifier::AsLong: // or AsWideChar
+    if (CS.isDoubleArg()) {
+      // Invalid for OpenCL FP scalars.
+      if (LO.OpenCL && VectorNumElts.isInvalid())
+        return false;
       return true;
-    case LengthModifier::AsAllocate:
-    case LengthModifier::AsMAllocate:
-    case LengthModifier::AsQuad:
-    case LengthModifier::AsInt32:
-    case LengthModifier::AsInt3264:
-    case LengthModifier::AsInt64:
-    case LengthModifier::AsWide:
-    case LengthModifier::AsShortLong: // ???
-      return false;
-  }
-  llvm_unreachable("Invalid LengthModifier Kind!");
-}
+    }
 
-bool FormatSpecifier::hasStandardConversionSpecifier(
-    const LangOptions &LangOpt) const {
-  switch (CS.getKind()) {
-    case ConversionSpecifier::cArg:
+    switch (CS.getKind()) {
     case ConversionSpecifier::dArg:
+    case ConversionSpecifier::DArg:
     case ConversionSpecifier::iArg:
     case ConversionSpecifier::oArg:
+    case ConversionSpecifier::OArg:
     case ConversionSpecifier::uArg:
+    case ConversionSpecifier::UArg:
     case ConversionSpecifier::xArg:
     case ConversionSpecifier::XArg:
+    case ConversionSpecifier::nArg:
+    case ConversionSpecifier::cArg:
+    case ConversionSpecifier::sArg:
+    case ConversionSpecifier::ScanListArg:
+    case ConversionSpecifier::ZArg:
+      return true;
+    case ConversionSpecifier::FreeBSDrArg:
+    case ConversionSpecifier::FreeBSDyArg:
+      return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS4();
+    default:
+      return false;
+    }
+
+  case LengthModifier::AsLongDouble:
+    switch (CS.getKind()) {
+    case ConversionSpecifier::aArg:
+    case ConversionSpecifier::AArg:
     case ConversionSpecifier::fArg:
     case ConversionSpecifier::FArg:
     case ConversionSpecifier::eArg:
     case ConversionSpecifier::EArg:
     case ConversionSpecifier::gArg:
     case ConversionSpecifier::GArg:
-    case ConversionSpecifier::aArg:
-    case ConversionSpecifier::AArg:
+      return true;
+    // GNU libc extension.
+    case ConversionSpecifier::dArg:
+    case ConversionSpecifier::iArg:
+    case ConversionSpecifier::oArg:
+    case ConversionSpecifier::uArg:
+    case ConversionSpecifier::xArg:
+    case ConversionSpecifier::XArg:
+      return !Target.getTriple().isOSDarwin() &&
+             !Target.getTriple().isOSWindows();
+    default:
+      return false;
+    }
+
+  case LengthModifier::AsAllocate:
+    switch (CS.getKind()) {
     case ConversionSpecifier::sArg:
-    case ConversionSpecifier::pArg:
-    case ConversionSpecifier::nArg:
-    case ConversionSpecifier::ObjCObjArg:
+    case ConversionSpecifier::SArg:
     case ConversionSpecifier::ScanListArg:
-    case ConversionSpecifier::PercentArg:
-    case ConversionSpecifier::PArg:
       return true;
+    default:
+      return false;
+    }
+
+  case LengthModifier::AsMAllocate:
+    switch (CS.getKind()) {
+    case ConversionSpecifier::cArg:
     case ConversionSpecifier::CArg:
+    case ConversionSpecifier::sArg:
+    case ConversionSpecifier::SArg:
+    case ConversionSpecifier::ScanListArg:
+      return true;
+    default:
+      return false;
+    }
+  case LengthModifier::AsInt32:
+  case LengthModifier::AsInt3264:
+  case LengthModifier::AsInt64:
+    switch (CS.getKind()) {
+    case ConversionSpecifier::dArg:
+    case ConversionSpecifier::iArg:
+    case ConversionSpecifier::oArg:
+    case ConversionSpecifier::uArg:
+    case ConversionSpecifier::xArg:
+    case ConversionSpecifier::XArg:
+      return Target.getTriple().isOSMSVCRT();
+    default:
+      return false;
+    }
+  case LengthModifier::AsWide:
+    switch (CS.getKind()) {
+    case ConversionSpecifier::cArg:
+    case ConversionSpecifier::CArg:
+    case ConversionSpecifier::sArg:
     case ConversionSpecifier::SArg:
-      return LangOpt.ObjC;
-    case ConversionSpecifier::InvalidSpecifier:
-    case ConversionSpecifier::FreeBSDbArg:
-    case ConversionSpecifier::FreeBSDDArg:
-    case ConversionSpecifier::FreeBSDrArg:
-    case ConversionSpecifier::FreeBSDyArg:
-    case ConversionSpecifier::PrintErrno:
-    case ConversionSpecifier::DArg:
-    case ConversionSpecifier::OArg:
-    case ConversionSpecifier::UArg:
     case ConversionSpecifier::ZArg:
+      return Target.getTriple().isOSMSVCRT();
+    default:
       return false;
+    }
+  }
+  llvm_unreachable("Invalid LengthModifier Kind!");
+}
+
+bool FormatSpecifier::hasStandardLengthModifier() const {
+  switch (LM.getKind()) {
+  case LengthModifier::None:
+  case LengthModifier::AsChar:
+  case LengthModifier::AsShort:
+  case LengthModifier::AsLong:
+  case LengthModifier::AsLongLong:
+  case LengthModifier::AsIntMax:
+  case LengthModifier::AsSizeT:
+  case LengthModifier::AsPtrDiff:
+  case LengthModifier::AsLongDouble:
+    return true;
+  case LengthModifier::AsAllocate:
+  case LengthModifier::AsMAllocate:
+  case LengthModifier::AsQuad:
+  case LengthModifier::AsInt32:
+  case LengthModifier::AsInt3264:
+  case LengthModifier::AsInt64:
+  case LengthModifier::AsWide:
+  case LengthModifier::AsShortLong: // ???
+    return false;
+  }
+  llvm_unreachable("Invalid LengthModifier Kind!");
+}
+
+bool FormatSpecifier::hasStandardConversionSpecifier(
+    LangOptions const &LangOpt) const {
+  switch (CS.getKind()) {
+  case ConversionSpecifier::cArg:
+  case ConversionSpecifier::dArg:
+  case ConversionSpecifier::iArg:
+  case ConversionSpecifier::oArg:
+  case ConversionSpecifier::uArg:
+  case ConversionSpecifier::xArg:
+  case ConversionSpecifier::XArg:
+  case ConversionSpecifier::fArg:
+  case ConversionSpecifier::FArg:
+  case ConversionSpecifier::eArg:
+  case ConversionSpecifier::EArg:
+  case ConversionSpecifier::gArg:
+  case ConversionSpecifier::GArg:
+  case ConversionSpecifier::aArg:
+  case ConversionSpecifier::AArg:
+  case ConversionSpecifier::sArg:
+  case ConversionSpecifier::pArg:
+  case ConversionSpecifier::nArg:
+  case ConversionSpecifier::ObjCObjArg:
+  case ConversionSpecifier::ScanListArg:
+  case ConversionSpecifier::PercentArg:
+  case ConversionSpecifier::PArg:
+    return true;
+  case ConversionSpecifier::CArg:
+  case ConversionSpecifier::SArg:
+    return LangOpt.ObjC;
+  case ConversionSpecifier::InvalidSpecifier:
+  case ConversionSpecifier::FreeBSDbArg:
+  case ConversionSpecifier::FreeBSDDArg:
+  case ConversionSpecifier::FreeBSDrArg:
+  case ConversionSpecifier::FreeBSDyArg:
+  case ConversionSpecifier::PrintErrno:
+  case ConversionSpecifier::DArg:
+  case ConversionSpecifier::OArg:
+  case ConversionSpecifier::UArg:
+  case ConversionSpecifier::ZArg:
+    return false;
   }
   llvm_unreachable("Invalid ConversionSpecifier Kind!");
 }
 
 bool FormatSpecifier::hasStandardLengthConversionCombination() const {
   if (LM.getKind() == LengthModifier::AsLongDouble) {
-    switch(CS.getKind()) {
-        case ConversionSpecifier::dArg:
-        case ConversionSpecifier::iArg:
-        case ConversionSpecifier::oArg:
-        case ConversionSpecifier::uArg:
-        case ConversionSpecifier::xArg:
-        case ConversionSpecifier::XArg:
-          return false;
-        default:
-          return true;
+    switch (CS.getKind()) {
+    case ConversionSpecifier::dArg:
+    case ConversionSpecifier::iArg:
+    case ConversionSpecifier::oArg:
+    case ConversionSpecifier::uArg:
+    case ConversionSpecifier::xArg:
+    case ConversionSpecifier::XArg:
+      return false;
+    default:
+      return true;
     }
   }
   return true;
@@ -977,10 +1011,10 @@
 bool FormatSpecifier::namedTypeToLengthModifier(QualType QT,
                                                 LengthModifier &LM) {
   assert(isa<TypedefType>(QT) && "Expected a TypedefType");
-  const TypedefNameDecl *Typedef = cast<TypedefType>(QT)->getDecl();
+  TypedefNameDecl const *Typedef = cast<TypedefType>(QT)->getDecl();
 
   for (;;) {
-    const IdentifierInfo *Identifier = Typedef->getIdentifier();
+    IdentifierInfo const *Identifier = Typedef->getIdentifier();
     if (Identifier->getName() == "size_t") {
       LM.setKind(LengthModifier::AsSizeT);
       return true;
Index: clang/lib/AST/InheritViz.cpp
===================================================================
--- clang/lib/AST/InheritViz.cpp
+++ clang/lib/AST/InheritViz.cpp
@@ -31,14 +31,14 @@
 /// differentiate between uses of types as virtual bases
 /// vs. non-virtual bases.
 class InheritanceHierarchyWriter {
-  ASTContext& Context;
+  ASTContext &Context;
   raw_ostream &Out;
   std::map<QualType, int, QualTypeOrdering> DirectBaseCount;
   std::set<QualType, QualTypeOrdering> KnownVirtualBases;
 
 public:
-  InheritanceHierarchyWriter(ASTContext& Context, raw_ostream& Out)
-    : Context(Context), Out(Out) { }
+  InheritanceHierarchyWriter(ASTContext &Context, raw_ostream &Out)
+      : Context(Context), Out(Out) {}
 
   void WriteGraph(QualType Type) {
     Out << "digraph \"" << llvm::DOT::EscapeString(Type.getAsString())
@@ -55,7 +55,7 @@
   /// WriteNodeReference - Write out a reference to the given node,
   /// using a unique identifier for each direct base and for the
   /// (only) virtual base.
-  raw_ostream& WriteNodeReference(QualType Type, bool FromVirtual);
+  raw_ostream &WriteNodeReference(QualType Type, bool FromVirtual);
 };
 } // namespace
 
@@ -90,9 +90,9 @@
   Out << " \"];\n";
 
   // Display the base classes.
-  const auto *Decl =
-      static_cast<const CXXRecordDecl *>(Type->castAs<RecordType>()->getDecl());
-  for (const auto &Base : Decl->bases()) {
+  auto const *Decl =
+      static_cast<CXXRecordDecl const *>(Type->castAs<RecordType>()->getDecl());
+  for (auto const &Base : Decl->bases()) {
     QualType CanonBaseType = Context.getCanonicalType(Base.getType());
 
     // If this is not virtual inheritance, bump the direct base
@@ -120,9 +120,8 @@
 /// WriteNodeReference - Write out a reference to the given node,
 /// using a unique identifier for each direct base and for the
 /// (only) virtual base.
-raw_ostream&
-InheritanceHierarchyWriter::WriteNodeReference(QualType Type,
-                                               bool FromVirtual) {
+raw_ostream &InheritanceHierarchyWriter::WriteNodeReference(QualType Type,
+                                                            bool FromVirtual) {
   QualType CanonType = Context.getCanonicalType(Type);
 
   Out << "Class_" << CanonType.getAsOpaquePtr();
@@ -133,7 +132,7 @@
 
 /// viewInheritance - Display the inheritance hierarchy of this C++
 /// class using GraphViz.
-void CXXRecordDecl::viewInheritance(ASTContext& Context) const {
+void CXXRecordDecl::viewInheritance(ASTContext &Context) const {
   QualType Self = Context.getTypeDeclType(this);
 
   int FD;
Index: clang/lib/AST/ItaniumCXXABI.cpp
===================================================================
--- clang/lib/AST/ItaniumCXXABI.cpp
+++ clang/lib/AST/ItaniumCXXABI.cpp
@@ -38,14 +38,15 @@
 /// the anonymous union.
 /// If there is no such data member (i.e., if all of the data members
 /// in the union are unnamed), then there is no way for a program to
-/// refer to the anonymous union, and there is therefore no need to mangle its name.
+/// refer to the anonymous union, and there is therefore no need to mangle its
+/// name.
 ///
 /// Returns the name of anonymous union VarDecl or nullptr if it is not found.
-static const IdentifierInfo *findAnonymousUnionVarDeclName(const VarDecl& VD) {
-  const RecordType *RT = VD.getType()->getAs<RecordType>();
+static IdentifierInfo const *findAnonymousUnionVarDeclName(VarDecl const &VD) {
+  RecordType const *RT = VD.getType()->getAs<RecordType>();
   assert(RT && "type of VarDecl is expected to be RecordType.");
   assert(RT->getDecl()->isUnion() && "RecordType is expected to be a union.");
-  if (const FieldDecl *FD = RT->getDecl()->findFirstNamedDataMember()) {
+  if (FieldDecl const *FD = RT->getDecl()->findFirstNamedDataMember()) {
     return FD->getIdentifier();
   }
 
@@ -54,7 +55,7 @@
 
 /// The name of a decomposition declaration.
 struct DecompositionDeclName {
-  using BindingArray = ArrayRef<const BindingDecl*>;
+  using BindingArray = ArrayRef<BindingDecl const *>;
 
   /// Representative example of a set of bindings with these names.
   BindingArray Bindings;
@@ -63,28 +64,28 @@
   struct Iterator
       : llvm::iterator_adaptor_base<Iterator, BindingArray::const_iterator,
                                     std::random_access_iterator_tag,
-                                    const IdentifierInfo *> {
+                                    IdentifierInfo const *> {
     Iterator(BindingArray::const_iterator It) : iterator_adaptor_base(It) {}
-    const IdentifierInfo *operator*() const {
+    IdentifierInfo const *operator*() const {
       return (*this->I)->getIdentifier();
     }
   };
   Iterator begin() const { return Iterator(Bindings.begin()); }
   Iterator end() const { return Iterator(Bindings.end()); }
 };
-}
+} // namespace
 
 namespace llvm {
-template<typename T> bool isDenseMapKeyEmpty(T V) {
-  return llvm::DenseMapInfo<T>::isEqual(
-      V, llvm::DenseMapInfo<T>::getEmptyKey());
+template <typename T> bool isDenseMapKeyEmpty(T V) {
+  return llvm::DenseMapInfo<T>::isEqual(V,
+                                        llvm::DenseMapInfo<T>::getEmptyKey());
 }
-template<typename T> bool isDenseMapKeyTombstone(T V) {
+template <typename T> bool isDenseMapKeyTombstone(T V) {
   return llvm::DenseMapInfo<T>::isEqual(
       V, llvm::DenseMapInfo<T>::getTombstoneKey());
 }
 
-template<typename T>
+template <typename T>
 Optional<bool> areDenseMapKeysEqualSpecialValues(T LHS, T RHS) {
   bool LHSEmpty = isDenseMapKeyEmpty(LHS);
   bool RHSEmpty = isDenseMapKeyEmpty(RHS);
@@ -99,9 +100,8 @@
   return None;
 }
 
-template<>
-struct DenseMapInfo<DecompositionDeclName> {
-  using ArrayInfo = llvm::DenseMapInfo<ArrayRef<const BindingDecl*>>;
+template <> struct DenseMapInfo<DecompositionDeclName> {
+  using ArrayInfo = llvm::DenseMapInfo<ArrayRef<BindingDecl const *>>;
   static DecompositionDeclName getEmptyKey() {
     return {ArrayInfo::getEmptyKey()};
   }
@@ -113,15 +113,15 @@
     return llvm::hash_combine_range(Key.begin(), Key.end());
   }
   static bool isEqual(DecompositionDeclName LHS, DecompositionDeclName RHS) {
-    if (Optional<bool> Result = areDenseMapKeysEqualSpecialValues(
-            LHS.Bindings, RHS.Bindings))
+    if (Optional<bool> Result =
+            areDenseMapKeysEqualSpecialValues(LHS.Bindings, RHS.Bindings))
       return *Result;
 
     return LHS.Bindings.size() == RHS.Bindings.size() &&
            std::equal(LHS.begin(), LHS.end(), RHS.begin());
   }
 };
-}
+} // namespace llvm
 
 namespace {
 
@@ -131,16 +131,16 @@
   ItaniumMangleContext *Mangler;
   llvm::StringMap<unsigned> LambdaManglingNumbers;
   unsigned BlockManglingNumber = 0;
-  llvm::DenseMap<const IdentifierInfo *, unsigned> VarManglingNumbers;
-  llvm::DenseMap<const IdentifierInfo *, unsigned> TagManglingNumbers;
+  llvm::DenseMap<IdentifierInfo const *, unsigned> VarManglingNumbers;
+  llvm::DenseMap<IdentifierInfo const *, unsigned> TagManglingNumbers;
   llvm::DenseMap<DecompositionDeclName, unsigned>
       DecompsitionDeclManglingNumbers;
 
 public:
   ItaniumNumberingContext(ItaniumMangleContext *Mangler) : Mangler(Mangler) {}
 
-  unsigned getManglingNumber(const CXXMethodDecl *CallOperator) override {
-    const CXXRecordDecl *Lambda = CallOperator->getParent();
+  unsigned getManglingNumber(CXXMethodDecl const *CallOperator) override {
+    CXXRecordDecl const *Lambda = CallOperator->getParent();
     assert(Lambda->isLambda());
 
     // Computation of the <lambda-sig> is non-trivial and subtle. Rather than
@@ -152,22 +152,20 @@
     return ++LambdaManglingNumbers[LambdaSig];
   }
 
-  unsigned getManglingNumber(const BlockDecl *BD) override {
+  unsigned getManglingNumber(BlockDecl const *BD) override {
     return ++BlockManglingNumber;
   }
 
-  unsigned getStaticLocalNumber(const VarDecl *VD) override {
-    return 0;
-  }
+  unsigned getStaticLocalNumber(VarDecl const *VD) override { return 0; }
 
   /// Variable decls are numbered by identifier.
-  unsigned getManglingNumber(const VarDecl *VD, unsigned) override {
+  unsigned getManglingNumber(VarDecl const *VD, unsigned) override {
     if (auto *DD = dyn_cast<DecompositionDecl>(VD)) {
       DecompositionDeclName Name{DD->bindings()};
       return ++DecompsitionDeclManglingNumbers[Name];
     }
 
-    const IdentifierInfo *Identifier = VD->getIdentifier();
+    IdentifierInfo const *Identifier = VD->getIdentifier();
     if (!Identifier) {
       // VarDecl without an identifier represents an anonymous union
       // declaration.
@@ -176,7 +174,7 @@
     return ++VarManglingNumbers[Identifier];
   }
 
-  unsigned getManglingNumber(const TagDecl *TD, unsigned) override {
+  unsigned getManglingNumber(TagDecl const *TD, unsigned) override {
     return ++TagManglingNumbers[TD->getIdentifier()];
   }
 };
@@ -184,15 +182,17 @@
 class ItaniumCXXABI : public CXXABI {
 private:
   std::unique_ptr<MangleContext> Mangler;
+
 protected:
   ASTContext &Context;
+
 public:
   ItaniumCXXABI(ASTContext &Ctx)
       : Mangler(Ctx.createMangleContext()), Context(Ctx) {}
 
   MemberPointerInfo
-  getMemberPointerInfo(const MemberPointerType *MPT) const override {
-    const TargetInfo &Target = Context.getTargetInfo();
+  getMemberPointerInfo(MemberPointerType const *MPT) const override {
+    TargetInfo const &Target = Context.getTargetInfo();
     TargetInfo::IntType PtrDiff = Target.getPtrDiffType(0);
     MemberPointerInfo MPI;
     MPI.Width = Target.getTypeWidth(PtrDiff);
@@ -204,7 +204,7 @@
   }
 
   CallingConv getDefaultMethodCallConv(bool isVariadic) const override {
-    const llvm::Triple &T = Context.getTargetInfo().getTriple();
+    llvm::Triple const &T = Context.getTargetInfo().getTriple();
     if (!isVariadic && T.isWindowsGNUEnvironment() &&
         T.getArch() == llvm::Triple::x86)
       return CC_X86ThisCall;
@@ -213,19 +213,19 @@
 
   // We cheat and just check that the class has a vtable pointer, and that it's
   // only big enough to have a vtable pointer and nothing more (or less).
-  bool isNearlyEmpty(const CXXRecordDecl *RD) const override {
+  bool isNearlyEmpty(CXXRecordDecl const *RD) const override {
 
     // Check that the class has a vtable pointer.
     if (!RD->isDynamicClass())
       return false;
 
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
     CharUnits PointerSize =
-      Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
+        Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
     return Layout.getNonVirtualSize() == PointerSize;
   }
 
-  const CXXConstructorDecl *
+  CXXConstructorDecl const *
   getCopyConstructorForExceptionObject(CXXRecordDecl *RD) override {
     return nullptr;
   }
@@ -236,14 +236,14 @@
   void addTypedefNameForUnnamedTagDecl(TagDecl *TD,
                                        TypedefNameDecl *DD) override {}
 
-  TypedefNameDecl *getTypedefNameForUnnamedTagDecl(const TagDecl *TD) override {
+  TypedefNameDecl *getTypedefNameForUnnamedTagDecl(TagDecl const *TD) override {
     return nullptr;
   }
 
   void addDeclaratorForUnnamedTagDecl(TagDecl *TD,
                                       DeclaratorDecl *DD) override {}
 
-  DeclaratorDecl *getDeclaratorForUnnamedTagDecl(const TagDecl *TD) override {
+  DeclaratorDecl *getDeclaratorForUnnamedTagDecl(TagDecl const *TD) override {
     return nullptr;
   }
 
@@ -253,7 +253,7 @@
         cast<ItaniumMangleContext>(Mangler.get()));
   }
 };
-}
+} // namespace
 
 CXXABI *clang::CreateItaniumCXXABI(ASTContext &Ctx) {
   return new ItaniumCXXABI(Ctx);
Index: clang/lib/AST/ItaniumMangle.cpp
===================================================================
--- clang/lib/AST/ItaniumMangle.cpp
+++ clang/lib/AST/ItaniumMangle.cpp
@@ -42,54 +42,54 @@
 
 /// Retrieve the declaration context that should be used when mangling the given
 /// declaration.
-static const DeclContext *getEffectiveDeclContext(const Decl *D) {
+static DeclContext const *getEffectiveDeclContext(Decl const *D) {
   // The ABI assumes that lambda closure types that occur within
   // default arguments live in the context of the function. However, due to
   // the way in which Clang parses and creates function declarations, this is
   // not the case: the lambda closure type ends up living in the context
   // where the function itself resides, because the function declaration itself
   // had not yet been created. Fix the context here.
-  if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
+  if (CXXRecordDecl const *RD = dyn_cast<CXXRecordDecl>(D)) {
     if (RD->isLambda())
-      if (ParmVarDecl *ContextParam
-            = dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
+      if (ParmVarDecl *ContextParam =
+              dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
         return ContextParam->getDeclContext();
   }
 
   // Perform the same check for block literals.
-  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
-    if (ParmVarDecl *ContextParam
-          = dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
+  if (BlockDecl const *BD = dyn_cast<BlockDecl>(D)) {
+    if (ParmVarDecl *ContextParam =
+            dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
       return ContextParam->getDeclContext();
   }
 
-  const DeclContext *DC = D->getDeclContext();
+  DeclContext const *DC = D->getDeclContext();
   if (isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC) ||
       isa<OMPDeclareMapperDecl>(DC)) {
     return getEffectiveDeclContext(cast<Decl>(DC));
   }
 
-  if (const auto *VD = dyn_cast<VarDecl>(D))
+  if (auto const *VD = dyn_cast<VarDecl>(D))
     if (VD->isExternC())
       return VD->getASTContext().getTranslationUnitDecl();
 
-  if (const auto *FD = dyn_cast<FunctionDecl>(D))
+  if (auto const *FD = dyn_cast<FunctionDecl>(D))
     if (FD->isExternC())
       return FD->getASTContext().getTranslationUnitDecl();
 
   return DC->getRedeclContext();
 }
 
-static const DeclContext *getEffectiveParentContext(const DeclContext *DC) {
+static DeclContext const *getEffectiveParentContext(DeclContext const *DC) {
   return getEffectiveDeclContext(cast<Decl>(DC));
 }
 
-static bool isLocalContainerContext(const DeclContext *DC) {
+static bool isLocalContainerContext(DeclContext const *DC) {
   return isa<FunctionDecl>(DC) || isa<ObjCMethodDecl>(DC) || isa<BlockDecl>(DC);
 }
 
-static const RecordDecl *GetLocalClassDecl(const Decl *D) {
-  const DeclContext *DC = getEffectiveDeclContext(D);
+static RecordDecl const *GetLocalClassDecl(Decl const *D) {
+  DeclContext const *DC = getEffectiveDeclContext(D);
   while (!DC->isNamespace() && !DC->isTranslationUnit()) {
     if (isLocalContainerContext(DC))
       return dyn_cast<RecordDecl>(D);
@@ -99,32 +99,32 @@
   return nullptr;
 }
 
-static const FunctionDecl *getStructor(const FunctionDecl *fn) {
-  if (const FunctionTemplateDecl *ftd = fn->getPrimaryTemplate())
+static FunctionDecl const *getStructor(FunctionDecl const *fn) {
+  if (FunctionTemplateDecl const *ftd = fn->getPrimaryTemplate())
     return ftd->getTemplatedDecl();
 
   return fn;
 }
 
-static const NamedDecl *getStructor(const NamedDecl *decl) {
-  const FunctionDecl *fn = dyn_cast_or_null<FunctionDecl>(decl);
+static NamedDecl const *getStructor(NamedDecl const *decl) {
+  FunctionDecl const *fn = dyn_cast_or_null<FunctionDecl>(decl);
   return (fn ? getStructor(fn) : decl);
 }
 
-static bool isLambda(const NamedDecl *ND) {
-  const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(ND);
+static bool isLambda(NamedDecl const *ND) {
+  CXXRecordDecl const *Record = dyn_cast<CXXRecordDecl>(ND);
   if (!Record)
     return false;
 
   return Record->isLambda();
 }
 
-static const unsigned UnknownArity = ~0U;
+static unsigned const UnknownArity = ~0U;
 
 class ItaniumMangleContextImpl : public ItaniumMangleContext {
-  typedef std::pair<const DeclContext*, IdentifierInfo*> DiscriminatorKeyTy;
+  typedef std::pair<DeclContext const *, IdentifierInfo *> DiscriminatorKeyTy;
   llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
-  llvm::DenseMap<const NamedDecl*, unsigned> Uniquifier;
+  llvm::DenseMap<NamedDecl const *, unsigned> Uniquifier;
   const DiscriminatorOverrideTy DiscriminatorOverride = nullptr;
 
   bool NeedsUniqueInternalLinkageNames = false;
@@ -139,58 +139,58 @@
   /// @name Mangler Entry Points
   /// @{
 
-  bool shouldMangleCXXName(const NamedDecl *D) override;
-  bool shouldMangleStringLiteral(const StringLiteral *) override {
+  bool shouldMangleCXXName(NamedDecl const *D) override;
+  bool shouldMangleStringLiteral(StringLiteral const *) override {
     return false;
   }
 
-  bool isUniqueInternalLinkageDecl(const NamedDecl *ND) override;
+  bool isUniqueInternalLinkageDecl(NamedDecl const *ND) override;
   void needsUniqueInternalLinkageNames() override {
     NeedsUniqueInternalLinkageNames = true;
   }
 
   void mangleCXXName(GlobalDecl GD, raw_ostream &) override;
-  void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk,
+  void mangleThunk(CXXMethodDecl const *MD, ThunkInfo const &Thunk,
                    raw_ostream &) override;
-  void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type,
-                          const ThisAdjustment &ThisAdjustment,
+  void mangleCXXDtorThunk(CXXDestructorDecl const *DD, CXXDtorType Type,
+                          ThisAdjustment const &ThisAdjustment,
                           raw_ostream &) override;
-  void mangleReferenceTemporary(const VarDecl *D, unsigned ManglingNumber,
+  void mangleReferenceTemporary(VarDecl const *D, unsigned ManglingNumber,
                                 raw_ostream &) override;
-  void mangleCXXVTable(const CXXRecordDecl *RD, raw_ostream &) override;
-  void mangleCXXVTT(const CXXRecordDecl *RD, raw_ostream &) override;
-  void mangleCXXCtorVTable(const CXXRecordDecl *RD, int64_t Offset,
-                           const CXXRecordDecl *Type, raw_ostream &) override;
+  void mangleCXXVTable(CXXRecordDecl const *RD, raw_ostream &) override;
+  void mangleCXXVTT(CXXRecordDecl const *RD, raw_ostream &) override;
+  void mangleCXXCtorVTable(CXXRecordDecl const *RD, int64_t Offset,
+                           CXXRecordDecl const *Type, raw_ostream &) override;
   void mangleCXXRTTI(QualType T, raw_ostream &) override;
   void mangleCXXRTTIName(QualType T, raw_ostream &) override;
   void mangleTypeName(QualType T, raw_ostream &) override;
 
-  void mangleCXXCtorComdat(const CXXConstructorDecl *D, raw_ostream &) override;
-  void mangleCXXDtorComdat(const CXXDestructorDecl *D, raw_ostream &) override;
-  void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &) override;
-  void mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out) override;
-  void mangleDynamicAtExitDestructor(const VarDecl *D,
+  void mangleCXXCtorComdat(CXXConstructorDecl const *D, raw_ostream &) override;
+  void mangleCXXDtorComdat(CXXDestructorDecl const *D, raw_ostream &) override;
+  void mangleStaticGuardVariable(VarDecl const *D, raw_ostream &) override;
+  void mangleDynamicInitializer(VarDecl const *D, raw_ostream &Out) override;
+  void mangleDynamicAtExitDestructor(VarDecl const *D,
                                      raw_ostream &Out) override;
-  void mangleDynamicStermFinalizer(const VarDecl *D, raw_ostream &Out) override;
-  void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl,
+  void mangleDynamicStermFinalizer(VarDecl const *D, raw_ostream &Out) override;
+  void mangleSEHFilterExpression(NamedDecl const *EnclosingDecl,
                                  raw_ostream &Out) override;
-  void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl,
+  void mangleSEHFinallyBlock(NamedDecl const *EnclosingDecl,
                              raw_ostream &Out) override;
-  void mangleItaniumThreadLocalInit(const VarDecl *D, raw_ostream &) override;
-  void mangleItaniumThreadLocalWrapper(const VarDecl *D,
+  void mangleItaniumThreadLocalInit(VarDecl const *D, raw_ostream &) override;
+  void mangleItaniumThreadLocalWrapper(VarDecl const *D,
                                        raw_ostream &) override;
 
-  void mangleStringLiteral(const StringLiteral *, raw_ostream &) override;
+  void mangleStringLiteral(StringLiteral const *, raw_ostream &) override;
 
-  void mangleLambdaSig(const CXXRecordDecl *Lambda, raw_ostream &) override;
+  void mangleLambdaSig(CXXRecordDecl const *Lambda, raw_ostream &) override;
 
-  bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) {
+  bool getNextDiscriminator(NamedDecl const *ND, unsigned &disc) {
     // Lambda closure types are already numbered.
     if (isLambda(ND))
       return false;
 
     // Anonymous tags are already numbered.
-    if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
+    if (TagDecl const *Tag = dyn_cast<TagDecl>(ND)) {
       if (Tag->getName().empty() && !Tag->getTypedefNameForAnonDecl())
         return false;
     }
@@ -207,16 +207,16 @@
     // Make up a reasonable number for internal decls.
     unsigned &discriminator = Uniquifier[ND];
     if (!discriminator) {
-      const DeclContext *DC = getEffectiveDeclContext(ND);
+      DeclContext const *DC = getEffectiveDeclContext(ND);
       discriminator = ++Discriminator[std::make_pair(DC, ND->getIdentifier())];
     }
     if (discriminator == 1)
       return false;
-    disc = discriminator-2;
+    disc = discriminator - 2;
     return true;
   }
 
-  std::string getLambdaString(const CXXRecordDecl *Lambda) override {
+  std::string getLambdaString(CXXRecordDecl const *Lambda) override {
     // This function matches the one in MicrosoftMangle, which returns
     // the string that is used in lambda mangled names.
     assert(Lambda->isLambda() && "RD must be a lambda!");
@@ -224,8 +224,8 @@
     Decl *LambdaContextDecl = Lambda->getLambdaContextDecl();
     unsigned LambdaManglingNumber = Lambda->getLambdaManglingNumber();
     unsigned LambdaId;
-    const ParmVarDecl *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
-    const FunctionDecl *Func =
+    ParmVarDecl const *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
+    FunctionDecl const *Func =
         Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr;
 
     if (Func) {
@@ -266,7 +266,7 @@
   /// The "structor" is the top-level declaration being mangled, if
   /// that's not a template specialization; otherwise it's the pattern
   /// for that specialization.
-  const NamedDecl *Structor;
+  NamedDecl const *Structor;
   unsigned StructorType;
 
   /// The next substitution sequence number.
@@ -281,14 +281,10 @@
     FunctionTypeDepthState() : Bits(0) {}
 
     /// The number of function types we're inside.
-    unsigned getDepth() const {
-      return Bits >> 1;
-    }
+    unsigned getDepth() const { return Bits >> 1; }
 
     /// True if we're in the return type of the innermost function type.
-    bool isInResultType() const {
-      return Bits & InResultTypeMask;
-    }
+    bool isInResultType() const { return Bits & InResultTypeMask; }
 
     FunctionTypeDepthState push() {
       FunctionTypeDepthState tmp = *this;
@@ -296,13 +292,9 @@
       return tmp;
     }
 
-    void enterResultType() {
-      Bits |= InResultTypeMask;
-    }
+    void enterResultType() { Bits |= InResultTypeMask; }
 
-    void leaveResultType() {
-      Bits &= ~InResultTypeMask;
-    }
+    void leaveResultType() { Bits &= ~InResultTypeMask; }
 
     void pop(FunctionTypeDepthState saved) {
       assert(getDepth() == saved.getDepth() + 1);
@@ -328,20 +320,20 @@
     }
 
     // No copy, no move.
-    AbiTagState(const AbiTagState &) = delete;
-    AbiTagState &operator=(const AbiTagState &) = delete;
+    AbiTagState(AbiTagState const &) = delete;
+    AbiTagState &operator=(AbiTagState const &) = delete;
 
     ~AbiTagState() { pop(); }
 
-    void write(raw_ostream &Out, const NamedDecl *ND,
-               const AbiTagList *AdditionalAbiTags) {
+    void write(raw_ostream &Out, NamedDecl const *ND,
+               AbiTagList const *AdditionalAbiTags) {
       ND = cast<NamedDecl>(ND->getCanonicalDecl());
       if (!isa<FunctionDecl>(ND) && !isa<VarDecl>(ND)) {
         assert(
             !AdditionalAbiTags &&
             "only function and variables need a list of additional abi tags");
-        if (const auto *NS = dyn_cast<NamespaceDecl>(ND)) {
-          if (const auto *AbiTag = NS->getAttr<AbiTagAttr>()) {
+        if (auto const *NS = dyn_cast<NamespaceDecl>(ND)) {
+          if (auto const *AbiTag = NS->getAttr<AbiTagAttr>()) {
             UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(),
                                AbiTag->tags().end());
           }
@@ -351,7 +343,7 @@
       }
 
       AbiTagList TagList;
-      if (const auto *AbiTag = ND->getAttr<AbiTagAttr>()) {
+      if (auto const *AbiTag = ND->getAttr<AbiTagAttr>()) {
         UsedAbiTags.insert(UsedAbiTags.end(), AbiTag->tags().begin(),
                            AbiTag->tags().end());
         TagList.insert(TagList.end(), AbiTag->tags().begin(),
@@ -371,16 +363,12 @@
       writeSortedUniqueAbiTags(Out, TagList);
     }
 
-    const AbiTagList &getUsedAbiTags() const { return UsedAbiTags; }
-    void setUsedAbiTags(const AbiTagList &AbiTags) {
-      UsedAbiTags = AbiTags;
-    }
+    AbiTagList const &getUsedAbiTags() const { return UsedAbiTags; }
+    void setUsedAbiTags(AbiTagList const &AbiTags) { UsedAbiTags = AbiTags; }
 
-    const AbiTagList &getEmittedAbiTags() const {
-      return EmittedAbiTags;
-    }
+    AbiTagList const &getEmittedAbiTags() const { return EmittedAbiTags; }
 
-    const AbiTagList &getSortedUniqueUsedAbiTags() {
+    AbiTagList const &getSortedUniqueUsedAbiTags() {
       llvm::sort(UsedAbiTags);
       UsedAbiTags.erase(std::unique(UsedAbiTags.begin(), UsedAbiTags.end()),
                         UsedAbiTags.end());
@@ -409,8 +397,8 @@
       LinkHead = Parent;
     }
 
-    void writeSortedUniqueAbiTags(raw_ostream &Out, const AbiTagList &AbiTags) {
-      for (const auto &Tag : AbiTags) {
+    void writeSortedUniqueAbiTags(raw_ostream &Out, AbiTagList const &AbiTags) {
+      for (auto const &Tag : AbiTags) {
         EmittedAbiTags.push_back(Tag);
         Out << "B";
         Out << Tag.size();
@@ -429,21 +417,20 @@
 
 public:
   CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
-                 const NamedDecl *D = nullptr, bool NullOut_ = false)
-    : Context(C), Out(Out_), NullOut(NullOut_),  Structor(getStructor(D)),
-      StructorType(0), SeqID(0), AbiTagsRoot(AbiTags) {
+                 NamedDecl const *D = nullptr, bool NullOut_ = false)
+      : Context(C), Out(Out_), NullOut(NullOut_), Structor(getStructor(D)),
+        StructorType(0), SeqID(0), AbiTagsRoot(AbiTags) {
     // These can't be mangled without a ctor type or dtor type.
-    assert(!D || (!isa<CXXDestructorDecl>(D) &&
-                  !isa<CXXConstructorDecl>(D)));
+    assert(!D || (!isa<CXXDestructorDecl>(D) && !isa<CXXConstructorDecl>(D)));
   }
   CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
-                 const CXXConstructorDecl *D, CXXCtorType Type)
-    : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
-      SeqID(0), AbiTagsRoot(AbiTags) { }
+                 CXXConstructorDecl const *D, CXXCtorType Type)
+      : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
+        SeqID(0), AbiTagsRoot(AbiTags) {}
   CXXNameMangler(ItaniumMangleContextImpl &C, raw_ostream &Out_,
-                 const CXXDestructorDecl *D, CXXDtorType Type)
-    : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
-      SeqID(0), AbiTagsRoot(AbiTags) { }
+                 CXXDestructorDecl const *D, CXXDtorType Type)
+      : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
+        SeqID(0), AbiTagsRoot(AbiTags) {}
 
   CXXNameMangler(CXXNameMangler &Outer, raw_ostream &Out_)
       : Context(Outer.Context), Out(Out_), NullOut(false),
@@ -460,32 +447,31 @@
   raw_ostream &getStream() { return Out; }
 
   void disableDerivedAbiTags() { DisableDerivedAbiTags = true; }
-  static bool shouldHaveAbiTags(ItaniumMangleContextImpl &C, const VarDecl *VD);
+  static bool shouldHaveAbiTags(ItaniumMangleContextImpl &C, VarDecl const *VD);
 
   void mangle(GlobalDecl GD);
   void mangleCallOffset(int64_t NonVirtual, int64_t Virtual);
-  void mangleNumber(const llvm::APSInt &I);
+  void mangleNumber(llvm::APSInt const &I);
   void mangleNumber(int64_t Number);
-  void mangleFloat(const llvm::APFloat &F);
+  void mangleFloat(llvm::APFloat const &F);
   void mangleFunctionEncoding(GlobalDecl GD);
   void mangleSeqID(unsigned SeqID);
   void mangleName(GlobalDecl GD);
   void mangleType(QualType T);
-  void mangleNameOrStandardSubstitution(const NamedDecl *ND);
-  void mangleLambdaSig(const CXXRecordDecl *Lambda);
+  void mangleNameOrStandardSubstitution(NamedDecl const *ND);
+  void mangleLambdaSig(CXXRecordDecl const *Lambda);
 
 private:
-
-  bool mangleSubstitution(const NamedDecl *ND);
+  bool mangleSubstitution(NamedDecl const *ND);
   bool mangleSubstitution(QualType T);
   bool mangleSubstitution(TemplateName Template);
   bool mangleSubstitution(uintptr_t Ptr);
 
   void mangleExistingSubstitution(TemplateName name);
 
-  bool mangleStandardSubstitution(const NamedDecl *ND);
+  bool mangleStandardSubstitution(NamedDecl const *ND);
 
-  void addSubstitution(const NamedDecl *ND) {
+  void addSubstitution(NamedDecl const *ND) {
     ND = cast<NamedDecl>(ND->getCanonicalDecl());
 
     addSubstitution(reinterpret_cast<uintptr_t>(ND));
@@ -494,73 +480,73 @@
   void addSubstitution(TemplateName Template);
   void addSubstitution(uintptr_t Ptr);
   // Destructive copy substitutions from other mangler.
-  void extendSubstitutions(CXXNameMangler* Other);
+  void extendSubstitutions(CXXNameMangler *Other);
 
   void mangleUnresolvedPrefix(NestedNameSpecifier *qualifier,
                               bool recursive = false);
   void mangleUnresolvedName(NestedNameSpecifier *qualifier,
                             DeclarationName name,
-                            const TemplateArgumentLoc *TemplateArgs,
+                            TemplateArgumentLoc const *TemplateArgs,
                             unsigned NumTemplateArgs,
                             unsigned KnownArity = UnknownArity);
 
-  void mangleFunctionEncodingBareType(const FunctionDecl *FD);
+  void mangleFunctionEncodingBareType(FunctionDecl const *FD);
 
   void mangleNameWithAbiTags(GlobalDecl GD,
-                             const AbiTagList *AdditionalAbiTags);
-  void mangleModuleName(const Module *M);
+                             AbiTagList const *AdditionalAbiTags);
+  void mangleModuleName(Module const *M);
   void mangleModuleNamePrefix(StringRef Name);
-  void mangleTemplateName(const TemplateDecl *TD,
-                          const TemplateArgument *TemplateArgs,
+  void mangleTemplateName(TemplateDecl const *TD,
+                          TemplateArgument const *TemplateArgs,
                           unsigned NumTemplateArgs);
   void mangleUnqualifiedName(GlobalDecl GD,
-                             const AbiTagList *AdditionalAbiTags) {
-    mangleUnqualifiedName(GD, cast<NamedDecl>(GD.getDecl())->getDeclName(), UnknownArity,
-                          AdditionalAbiTags);
+                             AbiTagList const *AdditionalAbiTags) {
+    mangleUnqualifiedName(GD, cast<NamedDecl>(GD.getDecl())->getDeclName(),
+                          UnknownArity, AdditionalAbiTags);
   }
   void mangleUnqualifiedName(GlobalDecl GD, DeclarationName Name,
                              unsigned KnownArity,
-                             const AbiTagList *AdditionalAbiTags);
-  void mangleUnscopedName(GlobalDecl GD,
-                          const AbiTagList *AdditionalAbiTags);
+                             AbiTagList const *AdditionalAbiTags);
+  void mangleUnscopedName(GlobalDecl GD, AbiTagList const *AdditionalAbiTags);
   void mangleUnscopedTemplateName(GlobalDecl GD,
-                                  const AbiTagList *AdditionalAbiTags);
-  void mangleSourceName(const IdentifierInfo *II);
-  void mangleRegCallName(const IdentifierInfo *II);
-  void mangleDeviceStubName(const IdentifierInfo *II);
-  void mangleSourceNameWithAbiTags(
-      const NamedDecl *ND, const AbiTagList *AdditionalAbiTags = nullptr);
-  void mangleLocalName(GlobalDecl GD,
-                       const AbiTagList *AdditionalAbiTags);
-  void mangleBlockForPrefix(const BlockDecl *Block);
-  void mangleUnqualifiedBlock(const BlockDecl *Block);
-  void mangleTemplateParamDecl(const NamedDecl *Decl);
-  void mangleLambda(const CXXRecordDecl *Lambda);
-  void mangleNestedName(GlobalDecl GD, const DeclContext *DC,
-                        const AbiTagList *AdditionalAbiTags,
-                        bool NoFunction=false);
-  void mangleNestedName(const TemplateDecl *TD,
-                        const TemplateArgument *TemplateArgs,
+                                  AbiTagList const *AdditionalAbiTags);
+  void mangleSourceName(IdentifierInfo const *II);
+  void mangleRegCallName(IdentifierInfo const *II);
+  void mangleDeviceStubName(IdentifierInfo const *II);
+  void
+  mangleSourceNameWithAbiTags(NamedDecl const *ND,
+                              AbiTagList const *AdditionalAbiTags = nullptr);
+  void mangleLocalName(GlobalDecl GD, AbiTagList const *AdditionalAbiTags);
+  void mangleBlockForPrefix(BlockDecl const *Block);
+  void mangleUnqualifiedBlock(BlockDecl const *Block);
+  void mangleTemplateParamDecl(NamedDecl const *Decl);
+  void mangleLambda(CXXRecordDecl const *Lambda);
+  void mangleNestedName(GlobalDecl GD, DeclContext const *DC,
+                        AbiTagList const *AdditionalAbiTags,
+                        bool NoFunction = false);
+  void mangleNestedName(TemplateDecl const *TD,
+                        TemplateArgument const *TemplateArgs,
                         unsigned NumTemplateArgs);
   void mangleNestedNameWithClosurePrefix(GlobalDecl GD,
-                                         const NamedDecl *PrefixND,
-                                         const AbiTagList *AdditionalAbiTags);
+                                         NamedDecl const *PrefixND,
+                                         AbiTagList const *AdditionalAbiTags);
   void manglePrefix(NestedNameSpecifier *qualifier);
-  void manglePrefix(const DeclContext *DC, bool NoFunction=false);
+  void manglePrefix(DeclContext const *DC, bool NoFunction = false);
   void manglePrefix(QualType type);
-  void mangleTemplatePrefix(GlobalDecl GD, bool NoFunction=false);
+  void mangleTemplatePrefix(GlobalDecl GD, bool NoFunction = false);
   void mangleTemplatePrefix(TemplateName Template);
-  const NamedDecl *getClosurePrefix(const Decl *ND);
-  void mangleClosurePrefix(const NamedDecl *ND, bool NoFunction = false);
+  NamedDecl const *getClosurePrefix(Decl const *ND);
+  void mangleClosurePrefix(NamedDecl const *ND, bool NoFunction = false);
   bool mangleUnresolvedTypeOrSimpleId(QualType DestroyedType,
                                       StringRef Prefix = "");
   void mangleOperatorName(DeclarationName Name, unsigned Arity);
   void mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity);
   void mangleVendorQualifier(StringRef qualifier);
-  void mangleQualifiers(Qualifiers Quals, const DependentAddressSpaceType *DAST = nullptr);
+  void mangleQualifiers(Qualifiers Quals,
+                        DependentAddressSpaceType const *DAST = nullptr);
   void mangleRefQualifier(RefQualifierKind RefQualifier);
 
-  void mangleObjCMethodName(const ObjCMethodDecl *MD);
+  void mangleObjCMethodName(ObjCMethodDecl const *MD);
 
   // Declare manglers for every type class.
 #define ABSTRACT_TYPE(CLASS, PARENT)
@@ -568,67 +554,64 @@
 #define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T);
 #include "clang/AST/TypeNodes.inc"
 
-  void mangleType(const TagType*);
+  void mangleType(TagType const *);
   void mangleType(TemplateName);
   static StringRef getCallingConvQualifierName(CallingConv CC);
   void mangleExtParameterInfo(FunctionProtoType::ExtParameterInfo info);
-  void mangleExtFunctionInfo(const FunctionType *T);
-  void mangleBareFunctionType(const FunctionProtoType *T, bool MangleReturnType,
-                              const FunctionDecl *FD = nullptr);
-  void mangleNeonVectorType(const VectorType *T);
-  void mangleNeonVectorType(const DependentVectorType *T);
-  void mangleAArch64NeonVectorType(const VectorType *T);
-  void mangleAArch64NeonVectorType(const DependentVectorType *T);
-  void mangleAArch64FixedSveVectorType(const VectorType *T);
-  void mangleAArch64FixedSveVectorType(const DependentVectorType *T);
-
-  void mangleIntegerLiteral(QualType T, const llvm::APSInt &Value);
-  void mangleFloatLiteral(QualType T, const llvm::APFloat &V);
+  void mangleExtFunctionInfo(FunctionType const *T);
+  void mangleBareFunctionType(FunctionProtoType const *T, bool MangleReturnType,
+                              FunctionDecl const *FD = nullptr);
+  void mangleNeonVectorType(VectorType const *T);
+  void mangleNeonVectorType(DependentVectorType const *T);
+  void mangleAArch64NeonVectorType(VectorType const *T);
+  void mangleAArch64NeonVectorType(DependentVectorType const *T);
+  void mangleAArch64FixedSveVectorType(VectorType const *T);
+  void mangleAArch64FixedSveVectorType(DependentVectorType const *T);
+
+  void mangleIntegerLiteral(QualType T, llvm::APSInt const &Value);
+  void mangleFloatLiteral(QualType T, llvm::APFloat const &V);
   void mangleFixedPointLiteral();
   void mangleNullPointer(QualType T);
 
-  void mangleMemberExprBase(const Expr *base, bool isArrow);
-  void mangleMemberExpr(const Expr *base, bool isArrow,
+  void mangleMemberExprBase(Expr const *base, bool isArrow);
+  void mangleMemberExpr(Expr const *base, bool isArrow,
                         NestedNameSpecifier *qualifier,
-                        NamedDecl *firstQualifierLookup,
-                        DeclarationName name,
-                        const TemplateArgumentLoc *TemplateArgs,
-                        unsigned NumTemplateArgs,
-                        unsigned knownArity);
-  void mangleCastExpression(const Expr *E, StringRef CastEncoding);
-  void mangleInitListElements(const InitListExpr *InitList);
-  void mangleExpression(const Expr *E, unsigned Arity = UnknownArity,
+                        NamedDecl *firstQualifierLookup, DeclarationName name,
+                        TemplateArgumentLoc const *TemplateArgs,
+                        unsigned NumTemplateArgs, unsigned knownArity);
+  void mangleCastExpression(Expr const *E, StringRef CastEncoding);
+  void mangleInitListElements(InitListExpr const *InitList);
+  void mangleExpression(Expr const *E, unsigned Arity = UnknownArity,
                         bool AsTemplateArg = false);
-  void mangleCXXCtorType(CXXCtorType T, const CXXRecordDecl *InheritedFrom);
+  void mangleCXXCtorType(CXXCtorType T, CXXRecordDecl const *InheritedFrom);
   void mangleCXXDtorType(CXXDtorType T);
 
   void mangleTemplateArgs(TemplateName TN,
-                          const TemplateArgumentLoc *TemplateArgs,
+                          TemplateArgumentLoc const *TemplateArgs,
                           unsigned NumTemplateArgs);
-  void mangleTemplateArgs(TemplateName TN, const TemplateArgument *TemplateArgs,
+  void mangleTemplateArgs(TemplateName TN, TemplateArgument const *TemplateArgs,
                           unsigned NumTemplateArgs);
-  void mangleTemplateArgs(TemplateName TN, const TemplateArgumentList &AL);
+  void mangleTemplateArgs(TemplateName TN, TemplateArgumentList const &AL);
   void mangleTemplateArg(TemplateArgument A, bool NeedExactType);
-  void mangleTemplateArgExpr(const Expr *E);
-  void mangleValueInTemplateArg(QualType T, const APValue &V, bool TopLevel,
+  void mangleTemplateArgExpr(Expr const *E);
+  void mangleValueInTemplateArg(QualType T, APValue const &V, bool TopLevel,
                                 bool NeedExactType = false);
 
   void mangleTemplateParameter(unsigned Depth, unsigned Index);
 
-  void mangleFunctionParam(const ParmVarDecl *parm);
+  void mangleFunctionParam(ParmVarDecl const *parm);
 
-  void writeAbiTags(const NamedDecl *ND,
-                    const AbiTagList *AdditionalAbiTags);
+  void writeAbiTags(NamedDecl const *ND, AbiTagList const *AdditionalAbiTags);
 
   // Returns sorted unique list of ABI tags.
-  AbiTagList makeFunctionReturnTypeTags(const FunctionDecl *FD);
+  AbiTagList makeFunctionReturnTypeTags(FunctionDecl const *FD);
   // Returns sorted unique list of ABI tags.
-  AbiTagList makeVariableTypeTags(const VarDecl *VD);
+  AbiTagList makeVariableTypeTags(VarDecl const *VD);
 };
 
-}
+} // namespace
 
-static bool isInternalLinkageDecl(const NamedDecl *ND) {
+static bool isInternalLinkageDecl(NamedDecl const *ND) {
   if (ND && ND->getFormalLinkage() == InternalLinkage &&
       !ND->isExternallyVisible() &&
       getEffectiveDeclContext(ND)->isFileContext() &&
@@ -639,11 +622,11 @@
 
 // Check if this Function Decl needs a unique internal linkage name.
 bool ItaniumMangleContextImpl::isUniqueInternalLinkageDecl(
-    const NamedDecl *ND) {
+    NamedDecl const *ND) {
   if (!NeedsUniqueInternalLinkageNames || !ND)
     return false;
 
-  const auto *FD = dyn_cast<FunctionDecl>(ND);
+  auto const *FD = dyn_cast<FunctionDecl>(ND);
   if (!FD)
     return false;
 
@@ -658,8 +641,8 @@
   return false;
 }
 
-bool ItaniumMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) {
-  const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
+bool ItaniumMangleContextImpl::shouldMangleCXXName(NamedDecl const *D) {
+  FunctionDecl const *FD = dyn_cast<FunctionDecl>(D);
   if (FD) {
     LanguageLinkage L = FD->getLanguageLinkage();
     // Overloadable functions need mangling.
@@ -696,14 +679,14 @@
   if (!getASTContext().getLangOpts().CPlusPlus)
     return false;
 
-  const VarDecl *VD = dyn_cast<VarDecl>(D);
+  VarDecl const *VD = dyn_cast<VarDecl>(D);
   if (VD && !isa<DecompositionDecl>(D)) {
     // C variables are not mangled.
     if (VD->isExternC())
       return false;
 
     // Variables at global scope with non-internal linkage are not mangled
-    const DeclContext *DC = getEffectiveDeclContext(D);
+    DeclContext const *DC = getEffectiveDeclContext(D);
     // Check for extern variable declared locally.
     if (DC->isFunctionOrMethod() && D->hasLinkage())
       while (!DC->isNamespace() && !DC->isTranslationUnit())
@@ -717,14 +700,14 @@
   return true;
 }
 
-void CXXNameMangler::writeAbiTags(const NamedDecl *ND,
-                                  const AbiTagList *AdditionalAbiTags) {
+void CXXNameMangler::writeAbiTags(NamedDecl const *ND,
+                                  AbiTagList const *AdditionalAbiTags) {
   assert(AbiTags && "require AbiTagState");
   AbiTags->write(Out, ND, DisableDerivedAbiTags ? nullptr : AdditionalAbiTags);
 }
 
 void CXXNameMangler::mangleSourceNameWithAbiTags(
-    const NamedDecl *ND, const AbiTagList *AdditionalAbiTags) {
+    NamedDecl const *ND, AbiTagList const *AdditionalAbiTags) {
   mangleSourceName(ND->getIdentifier());
   writeAbiTags(ND, AdditionalAbiTags);
 }
@@ -739,7 +722,7 @@
   else if (isa<VarDecl, FieldDecl, MSGuidDecl, TemplateParamObjectDecl,
                BindingDecl>(GD.getDecl()))
     mangleName(GD);
-  else if (const IndirectFieldDecl *IFD =
+  else if (IndirectFieldDecl const *IFD =
                dyn_cast<IndirectFieldDecl>(GD.getDecl()))
     mangleName(IFD->getAnonField());
   else
@@ -747,7 +730,7 @@
 }
 
 void CXXNameMangler::mangleFunctionEncoding(GlobalDecl GD) {
-  const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
+  FunctionDecl const *FD = cast<FunctionDecl>(GD.getDecl());
   // <encoding> ::= <function name> <bare-function-type>
 
   // Don't mangle in the type if this isn't a decl we should typically mangle.
@@ -780,7 +763,7 @@
 
   // Get tags from return type that are not present in function name or
   // encoding.
-  const AbiTagList &UsedAbiTags =
+  AbiTagList const &UsedAbiTags =
       FunctionEncodingMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();
   AbiTagList AdditionalAbiTags(ReturnTypeAbiTags.size());
   AdditionalAbiTags.erase(
@@ -798,7 +781,7 @@
   extendSubstitutions(&FunctionEncodingMangler);
 }
 
-void CXXNameMangler::mangleFunctionEncodingBareType(const FunctionDecl *FD) {
+void CXXNameMangler::mangleFunctionEncodingBareType(FunctionDecl const *FD) {
   if (FD->hasAttr<EnableIfAttr>()) {
     FunctionTypeDepthState Saved = FunctionTypeDepth.push();
     Out << "Ua9enable_ifI";
@@ -860,7 +843,7 @@
                          MangleReturnType, FD);
 }
 
-static const DeclContext *IgnoreLinkageSpecDecls(const DeclContext *DC) {
+static DeclContext const *IgnoreLinkageSpecDecls(DeclContext const *DC) {
   while (isa<LinkageSpecDecl>(DC)) {
     DC = getEffectiveParentContext(DC);
   }
@@ -869,44 +852,44 @@
 }
 
 /// Return whether a given namespace is the 'std' namespace.
-static bool isStd(const NamespaceDecl *NS) {
+static bool isStd(NamespaceDecl const *NS) {
   if (!IgnoreLinkageSpecDecls(getEffectiveParentContext(NS))
-                                ->isTranslationUnit())
+           ->isTranslationUnit())
     return false;
 
-  const IdentifierInfo *II = NS->getOriginalNamespace()->getIdentifier();
+  IdentifierInfo const *II = NS->getOriginalNamespace()->getIdentifier();
   return II && II->isStr("std");
 }
 
 // isStdNamespace - Return whether a given decl context is a toplevel 'std'
 // namespace.
-static bool isStdNamespace(const DeclContext *DC) {
+static bool isStdNamespace(DeclContext const *DC) {
   if (!DC->isNamespace())
     return false;
 
   return isStd(cast<NamespaceDecl>(DC));
 }
 
-static const GlobalDecl
-isTemplate(GlobalDecl GD, const TemplateArgumentList *&TemplateArgs) {
-  const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
+static const GlobalDecl isTemplate(GlobalDecl GD,
+                                   TemplateArgumentList const *&TemplateArgs) {
+  NamedDecl const *ND = cast<NamedDecl>(GD.getDecl());
   // Check if we have a function template.
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
-    if (const TemplateDecl *TD = FD->getPrimaryTemplate()) {
+  if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(ND)) {
+    if (TemplateDecl const *TD = FD->getPrimaryTemplate()) {
       TemplateArgs = FD->getTemplateSpecializationArgs();
       return GD.getWithDecl(TD);
     }
   }
 
   // Check if we have a class template.
-  if (const ClassTemplateSpecializationDecl *Spec =
-        dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
+  if (ClassTemplateSpecializationDecl const *Spec =
+          dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
     TemplateArgs = &Spec->getTemplateArgs();
     return GD.getWithDecl(Spec->getSpecializedTemplate());
   }
 
   // Check if we have a variable template.
-  if (const VarTemplateSpecializationDecl *Spec =
+  if (VarTemplateSpecializationDecl const *Spec =
           dyn_cast<VarTemplateSpecializationDecl>(ND)) {
     TemplateArgs = &Spec->getTemplateArgs();
     return GD.getWithDecl(Spec->getSpecializedTemplate());
@@ -916,13 +899,13 @@
 }
 
 static TemplateName asTemplateName(GlobalDecl GD) {
-  const TemplateDecl *TD = dyn_cast_or_null<TemplateDecl>(GD.getDecl());
-  return TemplateName(const_cast<TemplateDecl*>(TD));
+  TemplateDecl const *TD = dyn_cast_or_null<TemplateDecl>(GD.getDecl());
+  return TemplateName(const_cast<TemplateDecl *>(TD));
 }
 
 void CXXNameMangler::mangleName(GlobalDecl GD) {
-  const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
-  if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
+  NamedDecl const *ND = cast<NamedDecl>(GD.getDecl());
+  if (VarDecl const *VD = dyn_cast<VarDecl>(ND)) {
     // Variables should have implicit tags from its type.
     AbiTagList VariableTypeAbiTags = makeVariableTypeTags(VD);
     if (VariableTypeAbiTags.empty()) {
@@ -938,7 +921,7 @@
     VariableNameMangler.mangleNameWithAbiTags(VD, nullptr);
 
     // Get tags from variable type that are not present in its name.
-    const AbiTagList &UsedAbiTags =
+    AbiTagList const &UsedAbiTags =
         VariableNameMangler.AbiTagsRoot.getSortedUniqueUsedAbiTags();
     AbiTagList AdditionalAbiTags(VariableTypeAbiTags.size());
     AdditionalAbiTags.erase(
@@ -954,15 +937,15 @@
   }
 }
 
-void CXXNameMangler::mangleNameWithAbiTags(GlobalDecl GD,
-                                           const AbiTagList *AdditionalAbiTags) {
-  const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
+void CXXNameMangler::mangleNameWithAbiTags(
+    GlobalDecl GD, AbiTagList const *AdditionalAbiTags) {
+  NamedDecl const *ND = cast<NamedDecl>(GD.getDecl());
   //  <name> ::= [<module-name>] <nested-name>
   //         ::= [<module-name>] <unscoped-name>
   //         ::= [<module-name>] <unscoped-template-name> <template-args>
   //         ::= <local-name>
   //
-  const DeclContext *DC = getEffectiveDeclContext(ND);
+  DeclContext const *DC = getEffectiveDeclContext(ND);
 
   // If this is an extern variable declared locally, the relevant DeclContext
   // is that of the containing namespace, or the translation unit.
@@ -993,14 +976,14 @@
 
   // Closures can require a nested-name mangling even if they're semantically
   // in the global namespace.
-  if (const NamedDecl *PrefixND = getClosurePrefix(ND)) {
+  if (NamedDecl const *PrefixND = getClosurePrefix(ND)) {
     mangleNestedNameWithClosurePrefix(GD, PrefixND, AdditionalAbiTags);
     return;
   }
 
   if (DC->isTranslationUnit() || isStdNamespace(DC)) {
     // Check if we have a template.
-    const TemplateArgumentList *TemplateArgs = nullptr;
+    TemplateArgumentList const *TemplateArgs = nullptr;
     if (GlobalDecl TD = isTemplate(GD, TemplateArgs)) {
       mangleUnscopedTemplateName(TD, AdditionalAbiTags);
       mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
@@ -1014,7 +997,7 @@
   mangleNestedName(GD, DC, AdditionalAbiTags);
 }
 
-void CXXNameMangler::mangleModuleName(const Module *M) {
+void CXXNameMangler::mangleModuleName(Module const *M) {
   // Implement the C++ Modules TS name mangling proposal; see
   //     https://gcc.gnu.org/wiki/cxx-modules?action=AttachFile
   //
@@ -1049,10 +1032,10 @@
   ModuleSubstitutions.insert({Name, ModuleSubstitutions.size()});
 }
 
-void CXXNameMangler::mangleTemplateName(const TemplateDecl *TD,
-                                        const TemplateArgument *TemplateArgs,
+void CXXNameMangler::mangleTemplateName(TemplateDecl const *TD,
+                                        TemplateArgument const *TemplateArgs,
                                         unsigned NumTemplateArgs) {
-  const DeclContext *DC = IgnoreLinkageSpecDecls(getEffectiveDeclContext(TD));
+  DeclContext const *DC = IgnoreLinkageSpecDecls(getEffectiveDeclContext(TD));
 
   if (DC->isTranslationUnit() || isStdNamespace(DC)) {
     mangleUnscopedTemplateName(TD, nullptr);
@@ -1063,8 +1046,8 @@
 }
 
 void CXXNameMangler::mangleUnscopedName(GlobalDecl GD,
-                                        const AbiTagList *AdditionalAbiTags) {
-  const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
+                                        AbiTagList const *AdditionalAbiTags) {
+  NamedDecl const *ND = cast<NamedDecl>(GD.getDecl());
   //  <unscoped-name> ::= <unqualified-name>
   //                  ::= St <unqualified-name>   # ::std::
 
@@ -1075,28 +1058,29 @@
 }
 
 void CXXNameMangler::mangleUnscopedTemplateName(
-    GlobalDecl GD, const AbiTagList *AdditionalAbiTags) {
-  const TemplateDecl *ND = cast<TemplateDecl>(GD.getDecl());
+    GlobalDecl GD, AbiTagList const *AdditionalAbiTags) {
+  TemplateDecl const *ND = cast<TemplateDecl>(GD.getDecl());
   //     <unscoped-template-name> ::= <unscoped-name>
   //                              ::= <substitution>
   if (mangleSubstitution(ND))
     return;
 
   // <template-template-param> ::= <template-param>
-  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
+  if (auto const *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
     assert(!AdditionalAbiTags &&
            "template template param cannot have abi tags");
     mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
   } else if (isa<BuiltinTemplateDecl>(ND) || isa<ConceptDecl>(ND)) {
     mangleUnscopedName(GD, AdditionalAbiTags);
   } else {
-    mangleUnscopedName(GD.getWithDecl(ND->getTemplatedDecl()), AdditionalAbiTags);
+    mangleUnscopedName(GD.getWithDecl(ND->getTemplatedDecl()),
+                       AdditionalAbiTags);
   }
 
   addSubstitution(ND);
 }
 
-void CXXNameMangler::mangleFloat(const llvm::APFloat &f) {
+void CXXNameMangler::mangleFloat(llvm::APFloat const &f) {
   // ABI:
   //   Floating-point literals are encoded using a fixed-length
   //   lowercase hexadecimal string corresponding to the internal
@@ -1128,17 +1112,15 @@
     hexDigit &= 0xF;
 
     // Map that over to a lowercase hex digit.
-    static const char charForHex[16] = {
-      '0', '1', '2', '3', '4', '5', '6', '7',
-      '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
-    };
+    static char const charForHex[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
+                                        '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
     buffer[stringIndex] = charForHex[hexDigit];
   }
 
   Out.write(buffer.data(), numCharacters);
 }
 
-void CXXNameMangler::mangleFloatLiteral(QualType T, const llvm::APFloat &V) {
+void CXXNameMangler::mangleFloatLiteral(QualType T, llvm::APFloat const &V) {
   Out << 'L';
   mangleType(T);
   mangleFloat(V);
@@ -1159,7 +1141,7 @@
   Out << "0E";
 }
 
-void CXXNameMangler::mangleNumber(const llvm::APSInt &Value) {
+void CXXNameMangler::mangleNumber(llvm::APSInt const &Value) {
   if (Value.isSigned() && Value.isNegative()) {
     Out << 'n';
     Value.abs().print(Out, /*signed*/ false);
@@ -1199,7 +1181,7 @@
 }
 
 void CXXNameMangler::manglePrefix(QualType type) {
-  if (const auto *TST = type->getAs<TemplateSpecializationType>()) {
+  if (auto const *TST = type->getAs<TemplateSpecializationType>()) {
     if (!mangleSubstitution(QualType(TST, 0))) {
       mangleTemplatePrefix(TST->getTemplateName());
 
@@ -1210,7 +1192,7 @@
                          TST->getNumArgs());
       addSubstitution(QualType(TST, 0));
     }
-  } else if (const auto *DTST =
+  } else if (auto const *DTST =
                  type->getAs<DependentTemplateSpecializationType>()) {
     if (!mangleSubstitution(QualType(DTST, 0))) {
       TemplateName Template = getASTContext().getDependentTemplateName(
@@ -1284,7 +1266,7 @@
 
   case NestedNameSpecifier::TypeSpec:
   case NestedNameSpecifier::TypeSpecWithTemplate: {
-    const Type *type = qualifier->getAsType();
+    Type const *type = qualifier->getAsType();
 
     // We only want to use an unresolved-type encoding if this is one of:
     //   - a decltype
@@ -1328,36 +1310,37 @@
 /// weren't resolved to specific entities.
 void CXXNameMangler::mangleUnresolvedName(
     NestedNameSpecifier *qualifier, DeclarationName name,
-    const TemplateArgumentLoc *TemplateArgs, unsigned NumTemplateArgs,
+    TemplateArgumentLoc const *TemplateArgs, unsigned NumTemplateArgs,
     unsigned knownArity) {
-  if (qualifier) mangleUnresolvedPrefix(qualifier);
+  if (qualifier)
+    mangleUnresolvedPrefix(qualifier);
   switch (name.getNameKind()) {
-    // <base-unresolved-name> ::= <simple-id>
-    case DeclarationName::Identifier:
-      mangleSourceName(name.getAsIdentifierInfo());
-      break;
-    // <base-unresolved-name> ::= dn <destructor-name>
-    case DeclarationName::CXXDestructorName:
-      Out << "dn";
-      mangleUnresolvedTypeOrSimpleId(name.getCXXNameType());
-      break;
-    // <base-unresolved-name> ::= on <operator-name>
-    case DeclarationName::CXXConversionFunctionName:
-    case DeclarationName::CXXLiteralOperatorName:
-    case DeclarationName::CXXOperatorName:
-      Out << "on";
-      mangleOperatorName(name, knownArity);
-      break;
-    case DeclarationName::CXXConstructorName:
-      llvm_unreachable("Can't mangle a constructor name!");
-    case DeclarationName::CXXUsingDirective:
-      llvm_unreachable("Can't mangle a using directive name!");
-    case DeclarationName::CXXDeductionGuideName:
-      llvm_unreachable("Can't mangle a deduction guide name!");
-    case DeclarationName::ObjCMultiArgSelector:
-    case DeclarationName::ObjCOneArgSelector:
-    case DeclarationName::ObjCZeroArgSelector:
-      llvm_unreachable("Can't mangle Objective-C selector names here!");
+  // <base-unresolved-name> ::= <simple-id>
+  case DeclarationName::Identifier:
+    mangleSourceName(name.getAsIdentifierInfo());
+    break;
+  // <base-unresolved-name> ::= dn <destructor-name>
+  case DeclarationName::CXXDestructorName:
+    Out << "dn";
+    mangleUnresolvedTypeOrSimpleId(name.getCXXNameType());
+    break;
+  // <base-unresolved-name> ::= on <operator-name>
+  case DeclarationName::CXXConversionFunctionName:
+  case DeclarationName::CXXLiteralOperatorName:
+  case DeclarationName::CXXOperatorName:
+    Out << "on";
+    mangleOperatorName(name, knownArity);
+    break;
+  case DeclarationName::CXXConstructorName:
+    llvm_unreachable("Can't mangle a constructor name!");
+  case DeclarationName::CXXUsingDirective:
+    llvm_unreachable("Can't mangle a using directive name!");
+  case DeclarationName::CXXDeductionGuideName:
+    llvm_unreachable("Can't mangle a deduction guide name!");
+  case DeclarationName::ObjCMultiArgSelector:
+  case DeclarationName::ObjCOneArgSelector:
+  case DeclarationName::ObjCZeroArgSelector:
+    llvm_unreachable("Can't mangle Objective-C selector names here!");
   }
 
   // The <simple-id> and on <operator-name> productions end in an optional
@@ -1366,18 +1349,17 @@
     mangleTemplateArgs(TemplateName(), TemplateArgs, NumTemplateArgs);
 }
 
-void CXXNameMangler::mangleUnqualifiedName(GlobalDecl GD,
-                                           DeclarationName Name,
-                                           unsigned KnownArity,
-                                           const AbiTagList *AdditionalAbiTags) {
-  const NamedDecl *ND = cast_or_null<NamedDecl>(GD.getDecl());
+void CXXNameMangler::mangleUnqualifiedName(
+    GlobalDecl GD, DeclarationName Name, unsigned KnownArity,
+    AbiTagList const *AdditionalAbiTags) {
+  NamedDecl const *ND = cast_or_null<NamedDecl>(GD.getDecl());
   unsigned Arity = KnownArity;
   //  <unqualified-name> ::= <operator-name>
   //                     ::= <ctor-dtor-name>
   //                     ::= <source-name>
   switch (Name.getNameKind()) {
   case DeclarationName::Identifier: {
-    const IdentifierInfo *II = Name.getAsIdentifierInfo();
+    IdentifierInfo const *II = Name.getAsIdentifierInfo();
 
     // We mangle decomposition declarations as the names of their bindings.
     if (auto *DD = dyn_cast<DecompositionDecl>(ND)) {
@@ -1432,9 +1414,9 @@
         Out << 'L';
 
       auto *FD = dyn_cast<FunctionDecl>(ND);
-      bool IsRegCall = FD &&
-                       FD->getType()->castAs<FunctionType>()->getCallConv() ==
-                           clang::CC_X86RegCall;
+      bool IsRegCall =
+          FD && FD->getType()->castAs<FunctionType>()->getCallConv() ==
+                    clang::CC_X86RegCall;
       bool IsDeviceStub =
           FD && FD->hasAttr<CUDAGlobalAttr>() &&
           GD.getKernelReferenceKind() == KernelReferenceKind::Stub;
@@ -1452,7 +1434,7 @@
     // Otherwise, an anonymous entity.  We must have a declaration.
     assert(ND && "mangling empty name without declaration");
 
-    if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
+    if (NamespaceDecl const *NS = dyn_cast<NamespaceDecl>(ND)) {
       if (NS->isAnonymousNamespace()) {
         // This is how gcc mangles these names.
         Out << "12_GLOBAL__N_1";
@@ -1460,9 +1442,9 @@
       }
     }
 
-    if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
+    if (VarDecl const *VD = dyn_cast<VarDecl>(ND)) {
       // We must have an anonymous union or struct declaration.
-      const RecordDecl *RD = VD->getType()->castAs<RecordType>()->getDecl();
+      RecordDecl const *RD = VD->getType()->castAs<RecordType>()->getDecl();
 
       // Itanium C++ ABI 5.1.2:
       //
@@ -1473,14 +1455,15 @@
       //   the data members in the union are unnamed), then there is no way for
       //   a program to refer to the anonymous union, and there is therefore no
       //   need to mangle its name.
-      assert(RD->isAnonymousStructOrUnion()
-             && "Expected anonymous struct or union!");
-      const FieldDecl *FD = RD->findFirstNamedDataMember();
+      assert(RD->isAnonymousStructOrUnion() &&
+             "Expected anonymous struct or union!");
+      FieldDecl const *FD = RD->findFirstNamedDataMember();
 
       // It's actually possible for various reasons for us to get here
       // with an empty anonymous struct / union.  Fortunately, it
       // doesn't really matter what name we generate.
-      if (!FD) break;
+      if (!FD)
+        break;
       assert(FD->getIdentifier() && "Data member name isn't an identifier!");
 
       mangleSourceName(FD->getIdentifier());
@@ -1498,8 +1481,8 @@
       break;
 
     // We must have an anonymous struct.
-    const TagDecl *TD = cast<TagDecl>(ND);
-    if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) {
+    TagDecl const *TD = cast<TagDecl>(ND);
+    if (TypedefNameDecl const *D = TD->getTypedefNameForAnonDecl()) {
       assert(TD->getDeclContext() == D->getDeclContext() &&
              "Typedef should not be in another decl context!");
       assert(D->getDeclName().getAsIdentifierInfo() &&
@@ -1517,7 +1500,7 @@
     // <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _
     // <lambda-sig> ::= <template-param-decl>* <parameter-type>+
     //     # Parameter types or 'v' for 'void'.
-    if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) {
+    if (CXXRecordDecl const *Record = dyn_cast<CXXRecordDecl>(TD)) {
       if (Record->isLambda() && (Record->getLambdaManglingNumber() ||
                                  Context.getDiscriminatorOverride()(
                                      Context.getASTContext(), Record))) {
@@ -1560,9 +1543,9 @@
     llvm_unreachable("Can't mangle Objective-C selector names here!");
 
   case DeclarationName::CXXConstructorName: {
-    const CXXRecordDecl *InheritedFrom = nullptr;
+    CXXRecordDecl const *InheritedFrom = nullptr;
     TemplateName InheritedTemplateName;
-    const TemplateArgumentList *InheritedTemplateArgs = nullptr;
+    TemplateArgumentList const *InheritedTemplateArgs = nullptr;
     if (auto Inherited =
             cast<CXXConstructorDecl>(ND)->getInheritedConstructor()) {
       InheritedFrom = Inherited.getConstructor()->getParent();
@@ -1607,7 +1590,7 @@
       Arity = cast<FunctionDecl>(ND)->getNumParams();
 
       // If we have a member function, we need to include the 'this' pointer.
-      if (const auto *MD = dyn_cast<CXXMethodDecl>(ND))
+      if (auto const *MD = dyn_cast<CXXMethodDecl>(ND))
         if (!MD->isStatic())
           Arity++;
     }
@@ -1626,7 +1609,7 @@
   }
 }
 
-void CXXNameMangler::mangleRegCallName(const IdentifierInfo *II) {
+void CXXNameMangler::mangleRegCallName(IdentifierInfo const *II) {
   // <source-name> ::= <positive length number> __regcall3__ <identifier>
   // <number> ::= [n] <non-negative decimal integer>
   // <identifier> ::= <unqualified source code identifier>
@@ -1634,7 +1617,7 @@
       << II->getName();
 }
 
-void CXXNameMangler::mangleDeviceStubName(const IdentifierInfo *II) {
+void CXXNameMangler::mangleDeviceStubName(IdentifierInfo const *II) {
   // <source-name> ::= <positive length number> __device_stub__ <identifier>
   // <number> ::= [n] <non-negative decimal integer>
   // <identifier> ::= <unqualified source code identifier>
@@ -1642,25 +1625,24 @@
       << II->getName();
 }
 
-void CXXNameMangler::mangleSourceName(const IdentifierInfo *II) {
+void CXXNameMangler::mangleSourceName(IdentifierInfo const *II) {
   // <source-name> ::= <positive length number> <identifier>
   // <number> ::= [n] <non-negative decimal integer>
   // <identifier> ::= <unqualified source code identifier>
   Out << II->getLength() << II->getName();
 }
 
-void CXXNameMangler::mangleNestedName(GlobalDecl GD,
-                                      const DeclContext *DC,
-                                      const AbiTagList *AdditionalAbiTags,
+void CXXNameMangler::mangleNestedName(GlobalDecl GD, DeclContext const *DC,
+                                      AbiTagList const *AdditionalAbiTags,
                                       bool NoFunction) {
-  const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
+  NamedDecl const *ND = cast<NamedDecl>(GD.getDecl());
   // <nested-name>
   //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
   //   ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix>
   //       <template-args> E
 
   Out << 'N';
-  if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) {
+  if (CXXMethodDecl const *Method = dyn_cast<CXXMethodDecl>(ND)) {
     Qualifiers MethodQuals = Method->getMethodQualifiers();
     // We do not consider restrict a distinguishing attribute for overloading
     // purposes so we must not mangle it.
@@ -1670,7 +1652,7 @@
   }
 
   // Check if we have a template.
-  const TemplateArgumentList *TemplateArgs = nullptr;
+  TemplateArgumentList const *TemplateArgs = nullptr;
   if (GlobalDecl TD = isTemplate(GD, TemplateArgs)) {
     mangleTemplatePrefix(TD, NoFunction);
     mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
@@ -1681,8 +1663,8 @@
 
   Out << 'E';
 }
-void CXXNameMangler::mangleNestedName(const TemplateDecl *TD,
-                                      const TemplateArgument *TemplateArgs,
+void CXXNameMangler::mangleNestedName(TemplateDecl const *TD,
+                                      TemplateArgument const *TemplateArgs,
                                       unsigned NumTemplateArgs) {
   // <nested-name> ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
 
@@ -1695,8 +1677,8 @@
 }
 
 void CXXNameMangler::mangleNestedNameWithClosurePrefix(
-    GlobalDecl GD, const NamedDecl *PrefixND,
-    const AbiTagList *AdditionalAbiTags) {
+    GlobalDecl GD, NamedDecl const *PrefixND,
+    AbiTagList const *AdditionalAbiTags) {
   // A <closure-prefix> represents a variable or field, not a regular
   // DeclContext, so needs special handling. In this case we're mangling a
   // limited form of <nested-name>:
@@ -1711,7 +1693,7 @@
   Out << 'E';
 }
 
-static GlobalDecl getParentOfLocalEntity(const DeclContext *DC) {
+static GlobalDecl getParentOfLocalEntity(DeclContext const *DC) {
   GlobalDecl GD;
   // The Itanium spec says:
   // For entities in constructors and destructors, the mangling of the
@@ -1727,25 +1709,25 @@
 }
 
 void CXXNameMangler::mangleLocalName(GlobalDecl GD,
-                                     const AbiTagList *AdditionalAbiTags) {
-  const Decl *D = GD.getDecl();
+                                     AbiTagList const *AdditionalAbiTags) {
+  Decl const *D = GD.getDecl();
   // <local-name> := Z <function encoding> E <entity name> [<discriminator>]
   //              := Z <function encoding> E s [<discriminator>]
   // <local-name> := Z <function encoding> E d [ <parameter number> ]
   //                 _ <entity name>
   // <discriminator> := _ <non-negative number>
   assert(isa<NamedDecl>(D) || isa<BlockDecl>(D));
-  const RecordDecl *RD = GetLocalClassDecl(D);
-  const DeclContext *DC = getEffectiveDeclContext(RD ? RD : D);
+  RecordDecl const *RD = GetLocalClassDecl(D);
+  DeclContext const *DC = getEffectiveDeclContext(RD ? RD : D);
 
   Out << 'Z';
 
   {
     AbiTagState LocalAbiTags(AbiTags);
 
-    if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(DC))
+    if (ObjCMethodDecl const *MD = dyn_cast<ObjCMethodDecl>(DC))
       mangleObjCMethodName(MD);
-    else if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC))
+    else if (BlockDecl const *BD = dyn_cast<BlockDecl>(DC))
       mangleBlockForPrefix(BD);
     else
       mangleFunctionEncoding(getParentOfLocalEntity(DC));
@@ -1766,12 +1748,12 @@
     // <entity name> will of course contain a <closure-type-name>: Its
     // numbering will be local to the particular argument in which it appears
     // -- other default arguments do not affect its encoding.
-    const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD);
+    CXXRecordDecl const *CXXRD = dyn_cast<CXXRecordDecl>(RD);
     if (CXXRD && CXXRD->isLambda()) {
-      if (const ParmVarDecl *Parm
-              = dyn_cast_or_null<ParmVarDecl>(CXXRD->getLambdaContextDecl())) {
-        if (const FunctionDecl *Func
-              = dyn_cast<FunctionDecl>(Parm->getDeclContext())) {
+      if (ParmVarDecl const *Parm =
+              dyn_cast_or_null<ParmVarDecl>(CXXRD->getLambdaContextDecl())) {
+        if (FunctionDecl const *Func =
+                dyn_cast<FunctionDecl>(Parm->getDeclContext())) {
           Out << 'd';
           unsigned Num = Func->getNumParams() - Parm->getFunctionScopeIndex();
           if (Num > 1)
@@ -1783,27 +1765,27 @@
 
     // Mangle the name relative to the closest enclosing function.
     // equality ok because RD derived from ND above
-    if (D == RD)  {
+    if (D == RD) {
       mangleUnqualifiedName(RD, AdditionalAbiTags);
-    } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
-      if (const NamedDecl *PrefixND = getClosurePrefix(BD))
+    } else if (BlockDecl const *BD = dyn_cast<BlockDecl>(D)) {
+      if (NamedDecl const *PrefixND = getClosurePrefix(BD))
         mangleClosurePrefix(PrefixND, true /*NoFunction*/);
       else
         manglePrefix(getEffectiveDeclContext(BD), true /*NoFunction*/);
       assert(!AdditionalAbiTags && "Block cannot have additional abi tags");
       mangleUnqualifiedBlock(BD);
     } else {
-      const NamedDecl *ND = cast<NamedDecl>(D);
+      NamedDecl const *ND = cast<NamedDecl>(D);
       mangleNestedName(GD, getEffectiveDeclContext(ND), AdditionalAbiTags,
                        true /*NoFunction*/);
     }
-  } else if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
+  } else if (BlockDecl const *BD = dyn_cast<BlockDecl>(D)) {
     // Mangle a block in a default parameter; see above explanation for
     // lambdas.
-    if (const ParmVarDecl *Parm
-            = dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl())) {
-      if (const FunctionDecl *Func
-            = dyn_cast<FunctionDecl>(Parm->getDeclContext())) {
+    if (ParmVarDecl const *Parm =
+            dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl())) {
+      if (FunctionDecl const *Func =
+              dyn_cast<FunctionDecl>(Parm->getDeclContext())) {
         Out << 'd';
         unsigned Num = Func->getNumParams() - Parm->getFunctionScopeIndex();
         if (Num > 1)
@@ -1818,7 +1800,7 @@
     mangleUnqualifiedName(GD, AdditionalAbiTags);
   }
 
-  if (const NamedDecl *ND = dyn_cast<NamedDecl>(RD ? RD : D)) {
+  if (NamedDecl const *ND = dyn_cast<NamedDecl>(RD ? RD : D)) {
     unsigned disc;
     if (Context.getNextDiscriminator(ND, disc)) {
       if (disc < 10)
@@ -1829,24 +1811,24 @@
   }
 }
 
-void CXXNameMangler::mangleBlockForPrefix(const BlockDecl *Block) {
+void CXXNameMangler::mangleBlockForPrefix(BlockDecl const *Block) {
   if (GetLocalClassDecl(Block)) {
     mangleLocalName(Block, /* AdditionalAbiTags */ nullptr);
     return;
   }
-  const DeclContext *DC = getEffectiveDeclContext(Block);
+  DeclContext const *DC = getEffectiveDeclContext(Block);
   if (isLocalContainerContext(DC)) {
     mangleLocalName(Block, /* AdditionalAbiTags */ nullptr);
     return;
   }
-  if (const NamedDecl *PrefixND = getClosurePrefix(Block))
+  if (NamedDecl const *PrefixND = getClosurePrefix(Block))
     mangleClosurePrefix(PrefixND);
   else
     manglePrefix(DC);
   mangleUnqualifiedBlock(Block);
 }
 
-void CXXNameMangler::mangleUnqualifiedBlock(const BlockDecl *Block) {
+void CXXNameMangler::mangleUnqualifiedBlock(BlockDecl const *Block) {
   // When trying to be ABI-compatibility with clang 12 and before, mangle a
   // <data-member-prefix> now, with no substitutions and no <template-args>.
   if (Decl *Context = Block->getBlockManglingContextDecl()) {
@@ -1854,7 +1836,7 @@
             LangOptions::ClangABI::Ver12 &&
         (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
         Context->getDeclContext()->isRecord()) {
-      const auto *ND = cast<NamedDecl>(Context);
+      auto const *ND = cast<NamedDecl>(Context);
       if (ND->getIdentifier()) {
         mangleSourceNameWithAbiTags(ND);
         Out << 'M';
@@ -1883,7 +1865,7 @@
 //   ::= Tn <type>                       # template non-type parameter
 //   ::= Tt <template-param-decl>* E     # template template parameter
 //   ::= Tp <template-param-decl>        # template parameter pack
-void CXXNameMangler::mangleTemplateParamDecl(const NamedDecl *Decl) {
+void CXXNameMangler::mangleTemplateParamDecl(NamedDecl const *Decl) {
   if (auto *Ty = dyn_cast<TemplateTypeParmDecl>(Decl)) {
     if (Ty->isParameterPack())
       Out << "Tp";
@@ -1924,7 +1906,7 @@
   }
 }
 
-void CXXNameMangler::mangleLambda(const CXXRecordDecl *Lambda) {
+void CXXNameMangler::mangleLambda(CXXRecordDecl const *Lambda) {
   // When trying to be ABI-compatibility with clang 12 and before, mangle a
   // <data-member-prefix> now, with no substitutions.
   if (Decl *Context = Lambda->getLambdaContextDecl()) {
@@ -1932,10 +1914,10 @@
             LangOptions::ClangABI::Ver12 &&
         (isa<VarDecl>(Context) || isa<FieldDecl>(Context)) &&
         !isa<ParmVarDecl>(Context)) {
-      if (const IdentifierInfo *Name
-            = cast<NamedDecl>(Context)->getIdentifier()) {
+      if (IdentifierInfo const *Name =
+              cast<NamedDecl>(Context)->getIdentifier()) {
         mangleSourceName(Name);
-        const TemplateArgumentList *TemplateArgs = nullptr;
+        TemplateArgumentList const *TemplateArgs = nullptr;
         if (GlobalDecl TD = isTemplate(cast<NamedDecl>(Context), TemplateArgs))
           mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
         Out << 'M';
@@ -1969,7 +1951,7 @@
   Out << '_';
 }
 
-void CXXNameMangler::mangleLambdaSig(const CXXRecordDecl *Lambda) {
+void CXXNameMangler::mangleLambdaSig(CXXRecordDecl const *Lambda) {
   for (auto *D : Lambda->getLambdaExplicitTemplateParameters())
     mangleTemplateParamDecl(D);
   auto *Proto =
@@ -2013,7 +1995,7 @@
   llvm_unreachable("unexpected nested name specifier");
 }
 
-void CXXNameMangler::manglePrefix(const DeclContext *DC, bool NoFunction) {
+void CXXNameMangler::manglePrefix(DeclContext const *DC, bool NoFunction) {
   //  <prefix> ::= <prefix> <unqualified-name>
   //           ::= <template-prefix> <template-args>
   //           ::= <closure-prefix>
@@ -2031,16 +2013,16 @@
 
   assert(!isLocalContainerContext(DC));
 
-  const NamedDecl *ND = cast<NamedDecl>(DC);
+  NamedDecl const *ND = cast<NamedDecl>(DC);
   if (mangleSubstitution(ND))
     return;
 
   // Check if we have a template-prefix or a closure-prefix.
-  const TemplateArgumentList *TemplateArgs = nullptr;
+  TemplateArgumentList const *TemplateArgs = nullptr;
   if (GlobalDecl TD = isTemplate(ND, TemplateArgs)) {
     mangleTemplatePrefix(TD);
     mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
-  } else if (const NamedDecl *PrefixND = getClosurePrefix(ND)) {
+  } else if (NamedDecl const *PrefixND = getClosurePrefix(ND)) {
     mangleClosurePrefix(PrefixND, NoFunction);
     mangleUnqualifiedName(ND, nullptr);
   } else {
@@ -2074,7 +2056,7 @@
   if (Clang11Compat && mangleSubstitution(Template))
     return;
 
-  if (const IdentifierInfo *Id = Dependent->getIdentifier())
+  if (IdentifierInfo const *Id = Dependent->getIdentifier())
     mangleSourceName(Id);
   else
     mangleOperatorName(Dependent->getOperator(), UnknownArity);
@@ -2082,9 +2064,8 @@
   addSubstitution(Template);
 }
 
-void CXXNameMangler::mangleTemplatePrefix(GlobalDecl GD,
-                                          bool NoFunction) {
-  const TemplateDecl *ND = cast<TemplateDecl>(GD.getDecl());
+void CXXNameMangler::mangleTemplatePrefix(GlobalDecl GD, bool NoFunction) {
+  TemplateDecl const *ND = cast<TemplateDecl>(GD.getDecl());
   // <template-prefix> ::= <prefix> <template unqualified-name>
   //                   ::= <template-param>
   //                   ::= <substitution>
@@ -2095,7 +2076,7 @@
     return;
 
   // <template-template-param> ::= <template-param>
-  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
+  if (auto const *TTP = dyn_cast<TemplateTemplateParmDecl>(ND)) {
     mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
   } else {
     manglePrefix(getEffectiveDeclContext(ND), NoFunction);
@@ -2108,12 +2089,12 @@
   addSubstitution(ND);
 }
 
-const NamedDecl *CXXNameMangler::getClosurePrefix(const Decl *ND) {
+NamedDecl const *CXXNameMangler::getClosurePrefix(Decl const *ND) {
   if (getASTContext().getLangOpts().getClangABICompat() <=
       LangOptions::ClangABI::Ver12)
     return nullptr;
 
-  const NamedDecl *Context = nullptr;
+  NamedDecl const *Context = nullptr;
   if (auto *Block = dyn_cast<BlockDecl>(ND)) {
     Context = dyn_cast_or_null<NamedDecl>(Block->getBlockManglingContextDecl());
   } else if (auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
@@ -2132,13 +2113,13 @@
   return nullptr;
 }
 
-void CXXNameMangler::mangleClosurePrefix(const NamedDecl *ND, bool NoFunction) {
+void CXXNameMangler::mangleClosurePrefix(NamedDecl const *ND, bool NoFunction) {
   //  <closure-prefix> ::= [ <prefix> ] <unqualified-name> M
   //                   ::= <template-prefix> <template-args> M
   if (mangleSubstitution(ND))
     return;
 
-  const TemplateArgumentList *TemplateArgs = nullptr;
+  TemplateArgumentList const *TemplateArgs = nullptr;
   if (GlobalDecl TD = isTemplate(ND, TemplateArgs)) {
     mangleTemplatePrefix(TD, NoFunction);
     mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
@@ -2184,7 +2165,7 @@
     llvm_unreachable("can't mangle an overloaded template name as a <type>");
 
   case TemplateName::DependentTemplate: {
-    const DependentTemplateName *Dependent = TN.getAsDependentTemplateName();
+    DependentTemplateName const *Dependent = TN.getAsDependentTemplateName();
     assert(Dependent->isIdentifier());
 
     // <class-enum-type> ::= <name>
@@ -2199,8 +2180,8 @@
     // template.  This will check for the substitution twice, which is
     // fine, but we have to return early so that we don't try to *add*
     // the substitution twice.
-    SubstTemplateTemplateParmStorage *subst
-      = TN.getAsSubstTemplateTemplateParm();
+    SubstTemplateTemplateParmStorage *subst =
+        TN.getAsSubstTemplateTemplateParm();
     mangleType(subst->getReplacement());
     return;
   }
@@ -2295,8 +2276,7 @@
     break;
 
   case Type::UnresolvedUsing:
-    mangleSourceNameWithAbiTags(
-        cast<UnresolvedUsingType>(Ty)->getDecl());
+    mangleSourceNameWithAbiTags(cast<UnresolvedUsingType>(Ty)->getDecl());
     break;
 
   case Type::Enum:
@@ -2305,7 +2285,7 @@
     break;
 
   case Type::TemplateSpecialization: {
-    const TemplateSpecializationType *TST =
+    TemplateSpecializationType const *TST =
         cast<TemplateSpecializationType>(Ty);
     TemplateName TN = TST->getTemplateName();
     switch (TN.getKind()) {
@@ -2355,8 +2335,7 @@
   }
 
   case Type::InjectedClassName:
-    mangleSourceNameWithAbiTags(
-        cast<InjectedClassNameType>(Ty)->getDecl());
+    mangleSourceNameWithAbiTags(cast<InjectedClassNameType>(Ty)->getDecl());
     break;
 
   case Type::DependentName:
@@ -2364,7 +2343,7 @@
     break;
 
   case Type::DependentTemplateSpecialization: {
-    const DependentTemplateSpecializationType *DTST =
+    DependentTemplateSpecializationType const *DTST =
         cast<DependentTemplateSpecializationType>(Ty);
     TemplateName Template = getASTContext().getDependentTemplateName(
         DTST->getQualifier(), DTST->getIdentifier());
@@ -2410,113 +2389,199 @@
   }
 }
 
-void
-CXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO, unsigned Arity) {
+void CXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO,
+                                        unsigned Arity) {
   switch (OO) {
   // <operator-name> ::= nw     # new
-  case OO_New: Out << "nw"; break;
+  case OO_New:
+    Out << "nw";
+    break;
   //              ::= na        # new[]
-  case OO_Array_New: Out << "na"; break;
+  case OO_Array_New:
+    Out << "na";
+    break;
   //              ::= dl        # delete
-  case OO_Delete: Out << "dl"; break;
+  case OO_Delete:
+    Out << "dl";
+    break;
   //              ::= da        # delete[]
-  case OO_Array_Delete: Out << "da"; break;
+  case OO_Array_Delete:
+    Out << "da";
+    break;
   //              ::= ps        # + (unary)
   //              ::= pl        # + (binary or unknown)
   case OO_Plus:
-    Out << (Arity == 1? "ps" : "pl"); break;
+    Out << (Arity == 1 ? "ps" : "pl");
+    break;
   //              ::= ng        # - (unary)
   //              ::= mi        # - (binary or unknown)
   case OO_Minus:
-    Out << (Arity == 1? "ng" : "mi"); break;
+    Out << (Arity == 1 ? "ng" : "mi");
+    break;
   //              ::= ad        # & (unary)
   //              ::= an        # & (binary or unknown)
   case OO_Amp:
-    Out << (Arity == 1? "ad" : "an"); break;
+    Out << (Arity == 1 ? "ad" : "an");
+    break;
   //              ::= de        # * (unary)
   //              ::= ml        # * (binary or unknown)
   case OO_Star:
     // Use binary when unknown.
-    Out << (Arity == 1? "de" : "ml"); break;
+    Out << (Arity == 1 ? "de" : "ml");
+    break;
   //              ::= co        # ~
-  case OO_Tilde: Out << "co"; break;
+  case OO_Tilde:
+    Out << "co";
+    break;
   //              ::= dv        # /
-  case OO_Slash: Out << "dv"; break;
+  case OO_Slash:
+    Out << "dv";
+    break;
   //              ::= rm        # %
-  case OO_Percent: Out << "rm"; break;
+  case OO_Percent:
+    Out << "rm";
+    break;
   //              ::= or        # |
-  case OO_Pipe: Out << "or"; break;
+  case OO_Pipe:
+    Out << "or";
+    break;
   //              ::= eo        # ^
-  case OO_Caret: Out << "eo"; break;
+  case OO_Caret:
+    Out << "eo";
+    break;
   //              ::= aS        # =
-  case OO_Equal: Out << "aS"; break;
+  case OO_Equal:
+    Out << "aS";
+    break;
   //              ::= pL        # +=
-  case OO_PlusEqual: Out << "pL"; break;
+  case OO_PlusEqual:
+    Out << "pL";
+    break;
   //              ::= mI        # -=
-  case OO_MinusEqual: Out << "mI"; break;
+  case OO_MinusEqual:
+    Out << "mI";
+    break;
   //              ::= mL        # *=
-  case OO_StarEqual: Out << "mL"; break;
+  case OO_StarEqual:
+    Out << "mL";
+    break;
   //              ::= dV        # /=
-  case OO_SlashEqual: Out << "dV"; break;
+  case OO_SlashEqual:
+    Out << "dV";
+    break;
   //              ::= rM        # %=
-  case OO_PercentEqual: Out << "rM"; break;
+  case OO_PercentEqual:
+    Out << "rM";
+    break;
   //              ::= aN        # &=
-  case OO_AmpEqual: Out << "aN"; break;
+  case OO_AmpEqual:
+    Out << "aN";
+    break;
   //              ::= oR        # |=
-  case OO_PipeEqual: Out << "oR"; break;
+  case OO_PipeEqual:
+    Out << "oR";
+    break;
   //              ::= eO        # ^=
-  case OO_CaretEqual: Out << "eO"; break;
+  case OO_CaretEqual:
+    Out << "eO";
+    break;
   //              ::= ls        # <<
-  case OO_LessLess: Out << "ls"; break;
+  case OO_LessLess:
+    Out << "ls";
+    break;
   //              ::= rs        # >>
-  case OO_GreaterGreater: Out << "rs"; break;
+  case OO_GreaterGreater:
+    Out << "rs";
+    break;
   //              ::= lS        # <<=
-  case OO_LessLessEqual: Out << "lS"; break;
+  case OO_LessLessEqual:
+    Out << "lS";
+    break;
   //              ::= rS        # >>=
-  case OO_GreaterGreaterEqual: Out << "rS"; break;
+  case OO_GreaterGreaterEqual:
+    Out << "rS";
+    break;
   //              ::= eq        # ==
-  case OO_EqualEqual: Out << "eq"; break;
+  case OO_EqualEqual:
+    Out << "eq";
+    break;
   //              ::= ne        # !=
-  case OO_ExclaimEqual: Out << "ne"; break;
+  case OO_ExclaimEqual:
+    Out << "ne";
+    break;
   //              ::= lt        # <
-  case OO_Less: Out << "lt"; break;
+  case OO_Less:
+    Out << "lt";
+    break;
   //              ::= gt        # >
-  case OO_Greater: Out << "gt"; break;
+  case OO_Greater:
+    Out << "gt";
+    break;
   //              ::= le        # <=
-  case OO_LessEqual: Out << "le"; break;
+  case OO_LessEqual:
+    Out << "le";
+    break;
   //              ::= ge        # >=
-  case OO_GreaterEqual: Out << "ge"; break;
+  case OO_GreaterEqual:
+    Out << "ge";
+    break;
   //              ::= nt        # !
-  case OO_Exclaim: Out << "nt"; break;
+  case OO_Exclaim:
+    Out << "nt";
+    break;
   //              ::= aa        # &&
-  case OO_AmpAmp: Out << "aa"; break;
+  case OO_AmpAmp:
+    Out << "aa";
+    break;
   //              ::= oo        # ||
-  case OO_PipePipe: Out << "oo"; break;
+  case OO_PipePipe:
+    Out << "oo";
+    break;
   //              ::= pp        # ++
-  case OO_PlusPlus: Out << "pp"; break;
+  case OO_PlusPlus:
+    Out << "pp";
+    break;
   //              ::= mm        # --
-  case OO_MinusMinus: Out << "mm"; break;
+  case OO_MinusMinus:
+    Out << "mm";
+    break;
   //              ::= cm        # ,
-  case OO_Comma: Out << "cm"; break;
+  case OO_Comma:
+    Out << "cm";
+    break;
   //              ::= pm        # ->*
-  case OO_ArrowStar: Out << "pm"; break;
+  case OO_ArrowStar:
+    Out << "pm";
+    break;
   //              ::= pt        # ->
-  case OO_Arrow: Out << "pt"; break;
+  case OO_Arrow:
+    Out << "pt";
+    break;
   //              ::= cl        # ()
-  case OO_Call: Out << "cl"; break;
+  case OO_Call:
+    Out << "cl";
+    break;
   //              ::= ix        # []
-  case OO_Subscript: Out << "ix"; break;
+  case OO_Subscript:
+    Out << "ix";
+    break;
 
   //              ::= qu        # ?
   // The conditional operator can't be overloaded, but we still handle it when
   // mangling expressions.
-  case OO_Conditional: Out << "qu"; break;
+  case OO_Conditional:
+    Out << "qu";
+    break;
   // Proposal on cxx-abi-dev, 2015-10-21.
   //              ::= aw        # co_await
-  case OO_Coawait: Out << "aw"; break;
+  case OO_Coawait:
+    Out << "aw";
+    break;
   // Proposed in cxx-abi github issue 43.
   //              ::= ss        # <=>
-  case OO_Spaceship: Out << "ss"; break;
+  case OO_Spaceship:
+    Out << "ss";
+    break;
 
   case OO_None:
   case NUM_OVERLOADED_OPERATORS:
@@ -2524,7 +2589,8 @@
   }
 }
 
-void CXXNameMangler::mangleQualifiers(Qualifiers Quals, const DependentAddressSpaceType *DAST) {
+void CXXNameMangler::mangleQualifiers(Qualifiers Quals,
+                                      DependentAddressSpaceType const *DAST) {
   // Vendor qualifiers come first and if they are order-insensitive they must
   // be emitted in reversed alphabetical order, see Itanium ABI 5.1.5.
 
@@ -2554,7 +2620,8 @@
         ASString = "AS" + llvm::utostr(TargetAS);
     } else {
       switch (AS) {
-      default: llvm_unreachable("Not a language specific address space");
+      default:
+        llvm_unreachable("Not a language specific address space");
       //  <OpenCL-addrspace> ::= "CL" [ "global" | "local" | "constant" |
       //                                "private"| "generic" | "device" |
       //                                "host" ]
@@ -2696,11 +2763,11 @@
   }
 }
 
-void CXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) {
+void CXXNameMangler::mangleObjCMethodName(ObjCMethodDecl const *MD) {
   Context.mangleObjCMethodNameAsSourceName(MD, Out);
 }
 
-static bool isTypeSubstitutable(Qualifiers Quals, const Type *Ty,
+static bool isTypeSubstitutable(Qualifiers Quals, Type const *Ty,
                                 ASTContext &Ctx) {
   if (Quals)
     return true;
@@ -2764,8 +2831,8 @@
     do {
       // Don't desugar through template specialization types that aren't
       // type aliases. We need to mangle the template arguments as written.
-      if (const TemplateSpecializationType *TST
-                                      = dyn_cast<TemplateSpecializationType>(T))
+      if (TemplateSpecializationType const *TST =
+              dyn_cast<TemplateSpecializationType>(T))
         if (!TST->isTypeAlias())
           break;
 
@@ -2773,8 +2840,8 @@
       // instantation-dependent qualifiers. See
       // https://github.com/itanium-cxx-abi/cxx-abi/issues/114.
 
-      QualType Desugared
-        = T.getSingleStepDesugaredType(Context.getASTContext());
+      QualType Desugared =
+          T.getSingleStepDesugaredType(Context.getASTContext());
       if (Desugared == T)
         break;
 
@@ -2783,10 +2850,10 @@
   }
   SplitQualType split = T.split();
   Qualifiers quals = split.Quals;
-  const Type *ty = split.Ty;
+  Type const *ty = split.Ty;
 
   bool isSubstitutable =
-    isTypeSubstitutable(quals, ty, Context.getASTContext());
+      isTypeSubstitutable(quals, ty, Context.getASTContext());
   if (isSubstitutable && mangleSubstitution(T))
     return;
 
@@ -2801,8 +2868,8 @@
   }
 
   if (quals || ty->isDependentAddressSpaceType()) {
-    if (const DependentAddressSpaceType *DAST =
-        dyn_cast<DependentAddressSpaceType>(ty)) {
+    if (DependentAddressSpaceType const *DAST =
+            dyn_cast<DependentAddressSpaceType>(ty)) {
       SplitQualType splitDAST = DAST->getPointeeType().split();
       mangleQualifiers(splitDAST.Quals, DAST);
       mangleType(QualType(splitDAST.Ty, 0));
@@ -2816,14 +2883,14 @@
   } else {
     switch (ty->getTypeClass()) {
 #define ABSTRACT_TYPE(CLASS, PARENT)
-#define NON_CANONICAL_TYPE(CLASS, PARENT) \
-    case Type::CLASS: \
-      llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
-      return;
-#define TYPE(CLASS, PARENT) \
-    case Type::CLASS: \
-      mangleType(static_cast<const CLASS##Type*>(ty)); \
-      break;
+#define NON_CANONICAL_TYPE(CLASS, PARENT)                                      \
+  case Type::CLASS:                                                            \
+    llvm_unreachable("can't mangle non-canonical type " #CLASS "Type");        \
+    return;
+#define TYPE(CLASS, PARENT)                                                    \
+  case Type::CLASS:                                                            \
+    mangleType(static_cast<const CLASS##Type *>(ty));                          \
+    break;
 #include "clang/AST/TypeNodes.inc"
     }
   }
@@ -2833,12 +2900,12 @@
     addSubstitution(T);
 }
 
-void CXXNameMangler::mangleNameOrStandardSubstitution(const NamedDecl *ND) {
+void CXXNameMangler::mangleNameOrStandardSubstitution(NamedDecl const *ND) {
   if (!mangleStandardSubstitution(ND))
     mangleName(ND);
 }
 
-void CXXNameMangler::mangleType(const BuiltinType *T) {
+void CXXNameMangler::mangleType(BuiltinType const *T) {
   //  <type>         ::= <builtin-type>
   //  <builtin-type> ::= v  # void
   //                 ::= w  # wchar_t
@@ -2865,7 +2932,8 @@
   // UNSUPPORTED:    ::= De # IEEE 754r decimal floating point (128 bits)
   // UNSUPPORTED:    ::= Df # IEEE 754r decimal floating point (32 bits)
   //                 ::= Dh # IEEE 754r half-precision floating point (16 bits)
-  //                 ::= DF <number> _ # ISO/IEC TS 18661 binary floating point type _FloatN (N bits);
+  //                 ::= DF <number> _ # ISO/IEC TS 18661 binary floating point
+  //                 type _FloatN (N bits);
   //                 ::= Di # char32_t
   //                 ::= Ds # char16_t
   //                 ::= Dn # std::nullptr_t (i.e., decltype(nullptr))
@@ -2969,7 +3037,7 @@
     Out << 'd';
     break;
   case BuiltinType::LongDouble: {
-    const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
+    TargetInfo const *TI = getASTContext().getLangOpts().OpenMP &&
                                    getASTContext().getLangOpts().OpenMPIsDevice
                                ? getASTContext().getAuxTargetInfo()
                                : &getASTContext().getTargetInfo();
@@ -2977,7 +3045,7 @@
     break;
   }
   case BuiltinType::Float128: {
-    const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
+    TargetInfo const *TI = getASTContext().getLangOpts().OpenMP &&
                                    getASTContext().getLangOpts().OpenMPIsDevice
                                ? getASTContext().getAuxTargetInfo()
                                : &getASTContext().getTargetInfo();
@@ -2985,12 +3053,12 @@
     break;
   }
   case BuiltinType::BFloat16: {
-    const TargetInfo *TI = &getASTContext().getTargetInfo();
+    TargetInfo const *TI = &getASTContext().getTargetInfo();
     Out << TI->getBFloat16Mangling();
     break;
   }
   case BuiltinType::Ibm128: {
-    const TargetInfo *TI = &getASTContext().getTargetInfo();
+    TargetInfo const *TI = &getASTContext().getTargetInfo();
     Out << TI->getIbm128Mangling();
     break;
   }
@@ -2999,8 +3067,7 @@
     break;
 
 #define BUILTIN_TYPE(Id, SingletonId)
-#define PLACEHOLDER_TYPE(Id, SingletonId) \
-  case BuiltinType::Id:
+#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
   case BuiltinType::Dependent:
     if (!NullOut)
@@ -3015,10 +3082,10 @@
   case BuiltinType::ObjCSel:
     Out << "13objc_selector";
     break;
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-  case BuiltinType::Id: \
-    type_name = "ocl_" #ImgType "_" #Suffix; \
-    Out << type_name.size() << type_name; \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
+  case BuiltinType::Id:                                                        \
+    type_name = "ocl_" #ImgType "_" #Suffix;                                   \
+    Out << type_name.size() << type_name;                                      \
     break;
 #include "clang/Basic/OpenCLImageTypes.def"
   case BuiltinType::OCLSampler:
@@ -3036,15 +3103,15 @@
   case BuiltinType::OCLReserveID:
     Out << "13ocl_reserveid";
     break;
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-  case BuiltinType::Id: \
-    type_name = "ocl_" #ExtType; \
-    Out << type_name.size() << type_name; \
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext)                                      \
+  case BuiltinType::Id:                                                        \
+    type_name = "ocl_" #ExtType;                                               \
+    Out << type_name.size() << type_name;                                      \
     break;
 #include "clang/Basic/OpenCLExtensionTypes.def"
-  // The SVE types are effectively target-specific.  The mangling scheme
-  // is defined in the appendices to the Procedure Call Standard for the
-  // Arm Architecture.
+    // The SVE types are effectively target-specific.  The mangling scheme
+    // is defined in the appendices to the Procedure Call Standard for the
+    // Arm Architecture.
 #define SVE_VECTOR_TYPE(InternalName, MangledName, Id, SingletonId, NumEls,    \
                         ElBits, IsSigned, IsFP, IsBF)                          \
   case BuiltinType::Id:                                                        \
@@ -3059,10 +3126,10 @@
         << type_name;                                                          \
     break;
 #include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-  case BuiltinType::Id: \
-    type_name = #Name; \
-    Out << 'u' << type_name.size() << type_name; \
+#define PPC_VECTOR_TYPE(Name, Id, Size)                                        \
+  case BuiltinType::Id:                                                        \
+    type_name = #Name;                                                         \
+    Out << 'u' << type_name.size() << type_name;                               \
     break;
 #include "clang/Basic/PPCTypes.def"
     // TODO: Check the mangling scheme for RISC-V V.
@@ -3118,7 +3185,7 @@
   llvm_unreachable("bad calling convention");
 }
 
-void CXXNameMangler::mangleExtFunctionInfo(const FunctionType *T) {
+void CXXNameMangler::mangleExtFunctionInfo(FunctionType const *T) {
   // Fast path.
   if (T->getExtInfo() == FunctionType::ExtInfo())
     return;
@@ -3135,8 +3202,8 @@
   // FIXME: noreturn
 }
 
-void
-CXXNameMangler::mangleExtParameterInfo(FunctionProtoType::ExtParameterInfo PI) {
+void CXXNameMangler::mangleExtParameterInfo(
+    FunctionProtoType::ExtParameterInfo PI) {
   // Vendor-specific qualifiers are emitted in reverse alphabetical order.
 
   // Note that these are *not* substitution candidates.  Demanglers might
@@ -3165,7 +3232,7 @@
 // <type>          ::= <function-type>
 // <function-type> ::= [<CV-qualifiers>] F [Y]
 //                      <bare-function-type> [<ref-qualifier>] E
-void CXXNameMangler::mangleType(const FunctionProtoType *T) {
+void CXXNameMangler::mangleType(FunctionProtoType const *T) {
   mangleExtFunctionInfo(T);
 
   // Mangle CV-qualifiers, if present.  These are 'this' qualifiers,
@@ -3202,7 +3269,7 @@
   Out << 'E';
 }
 
-void CXXNameMangler::mangleType(const FunctionNoProtoType *T) {
+void CXXNameMangler::mangleType(FunctionNoProtoType const *T) {
   // Function types without prototypes can arise when mangling a function type
   // within an overloadable function in C. We mangle these as the absence of any
   // parameter types (not even an empty parameter list).
@@ -3218,9 +3285,9 @@
   Out << 'E';
 }
 
-void CXXNameMangler::mangleBareFunctionType(const FunctionProtoType *Proto,
+void CXXNameMangler::mangleBareFunctionType(FunctionProtoType const *Proto,
                                             bool MangleReturnType,
-                                            const FunctionDecl *FD) {
+                                            FunctionDecl const *FD) {
   // Record that we're in a function type.  See mangleFunctionParam
   // for details on what we're trying to achieve here.
   FunctionTypeDepthState saved = FunctionTypeDepth.push();
@@ -3285,30 +3352,28 @@
 
 // <type>            ::= <class-enum-type>
 // <class-enum-type> ::= <name>
-void CXXNameMangler::mangleType(const UnresolvedUsingType *T) {
+void CXXNameMangler::mangleType(UnresolvedUsingType const *T) {
   mangleName(T->getDecl());
 }
 
 // <type>            ::= <class-enum-type>
 // <class-enum-type> ::= <name>
-void CXXNameMangler::mangleType(const EnumType *T) {
-  mangleType(static_cast<const TagType*>(T));
-}
-void CXXNameMangler::mangleType(const RecordType *T) {
-  mangleType(static_cast<const TagType*>(T));
+void CXXNameMangler::mangleType(EnumType const *T) {
+  mangleType(static_cast<TagType const *>(T));
 }
-void CXXNameMangler::mangleType(const TagType *T) {
-  mangleName(T->getDecl());
+void CXXNameMangler::mangleType(RecordType const *T) {
+  mangleType(static_cast<TagType const *>(T));
 }
+void CXXNameMangler::mangleType(TagType const *T) { mangleName(T->getDecl()); }
 
 // <type>       ::= <array-type>
 // <array-type> ::= A <positive dimension number> _ <element type>
 //              ::= A [<dimension expression>] _ <element type>
-void CXXNameMangler::mangleType(const ConstantArrayType *T) {
+void CXXNameMangler::mangleType(ConstantArrayType const *T) {
   Out << 'A' << T->getSize() << '_';
   mangleType(T->getElementType());
 }
-void CXXNameMangler::mangleType(const VariableArrayType *T) {
+void CXXNameMangler::mangleType(VariableArrayType const *T) {
   Out << 'A';
   // decayed vla types (size 0) will just be skipped.
   if (T->getSizeExpr())
@@ -3316,7 +3381,7 @@
   Out << '_';
   mangleType(T->getElementType());
 }
-void CXXNameMangler::mangleType(const DependentSizedArrayType *T) {
+void CXXNameMangler::mangleType(DependentSizedArrayType const *T) {
   Out << 'A';
   // A DependentSizedArrayType might not have size expression as below
   //
@@ -3326,18 +3391,18 @@
   Out << '_';
   mangleType(T->getElementType());
 }
-void CXXNameMangler::mangleType(const IncompleteArrayType *T) {
+void CXXNameMangler::mangleType(IncompleteArrayType const *T) {
   Out << "A_";
   mangleType(T->getElementType());
 }
 
 // <type>                   ::= <pointer-to-member-type>
 // <pointer-to-member-type> ::= M <class type> <member type>
-void CXXNameMangler::mangleType(const MemberPointerType *T) {
+void CXXNameMangler::mangleType(MemberPointerType const *T) {
   Out << 'M';
   mangleType(QualType(T->getClass(), 0));
   QualType PointeeType = T->getPointeeType();
-  if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(PointeeType)) {
+  if (FunctionProtoType const *FPT = dyn_cast<FunctionProtoType>(PointeeType)) {
     mangleType(FPT);
 
     // Itanium C++ ABI 5.1.8:
@@ -3362,12 +3427,12 @@
 }
 
 // <type>           ::= <template-param>
-void CXXNameMangler::mangleType(const TemplateTypeParmType *T) {
+void CXXNameMangler::mangleType(TemplateTypeParmType const *T) {
   mangleTemplateParameter(T->getDepth(), T->getIndex());
 }
 
 // <type>           ::= <template-param>
-void CXXNameMangler::mangleType(const SubstTemplateTypeParmPackType *T) {
+void CXXNameMangler::mangleType(SubstTemplateTypeParmPackType const *T) {
   // FIXME: not clear how to mangle this!
   // template <class T...> class A {
   //   template <class U...> void foo(T(*)(U) x...);
@@ -3376,29 +3441,29 @@
 }
 
 // <type> ::= P <type>   # pointer-to
-void CXXNameMangler::mangleType(const PointerType *T) {
+void CXXNameMangler::mangleType(PointerType const *T) {
   Out << 'P';
   mangleType(T->getPointeeType());
 }
-void CXXNameMangler::mangleType(const ObjCObjectPointerType *T) {
+void CXXNameMangler::mangleType(ObjCObjectPointerType const *T) {
   Out << 'P';
   mangleType(T->getPointeeType());
 }
 
 // <type> ::= R <type>   # reference-to
-void CXXNameMangler::mangleType(const LValueReferenceType *T) {
+void CXXNameMangler::mangleType(LValueReferenceType const *T) {
   Out << 'R';
   mangleType(T->getPointeeType());
 }
 
 // <type> ::= O <type>   # rvalue reference-to (C++0x)
-void CXXNameMangler::mangleType(const RValueReferenceType *T) {
+void CXXNameMangler::mangleType(RValueReferenceType const *T) {
   Out << 'O';
   mangleType(T->getPointeeType());
 }
 
 // <type> ::= C <type>   # complex pair (C 2000)
-void CXXNameMangler::mangleType(const ComplexType *T) {
+void CXXNameMangler::mangleType(ComplexType const *T) {
   Out << 'C';
   mangleType(T->getElementType());
 }
@@ -3406,10 +3471,10 @@
 // ARM's ABI for Neon vector types specifies that they should be mangled as
 // if they are structs (to match ARM's initial implementation).  The
 // vector type must be one of the special types predefined by ARM.
-void CXXNameMangler::mangleNeonVectorType(const VectorType *T) {
+void CXXNameMangler::mangleNeonVectorType(VectorType const *T) {
   QualType EltType = T->getElementType();
   assert(EltType->isBuiltinType() && "Neon vector element not a BuiltinType");
-  const char *EltName = nullptr;
+  char const *EltName = nullptr;
   if (T->getVectorKind() == VectorType::NeonPolyVector) {
     switch (cast<BuiltinType>(EltType)->getKind()) {
     case BuiltinType::SChar:
@@ -3424,29 +3489,54 @@
     case BuiltinType::ULongLong:
       EltName = "poly64_t";
       break;
-    default: llvm_unreachable("unexpected Neon polynomial vector element type");
+    default:
+      llvm_unreachable("unexpected Neon polynomial vector element type");
     }
   } else {
     switch (cast<BuiltinType>(EltType)->getKind()) {
-    case BuiltinType::SChar:     EltName = "int8_t"; break;
-    case BuiltinType::UChar:     EltName = "uint8_t"; break;
-    case BuiltinType::Short:     EltName = "int16_t"; break;
-    case BuiltinType::UShort:    EltName = "uint16_t"; break;
-    case BuiltinType::Int:       EltName = "int32_t"; break;
-    case BuiltinType::UInt:      EltName = "uint32_t"; break;
-    case BuiltinType::LongLong:  EltName = "int64_t"; break;
-    case BuiltinType::ULongLong: EltName = "uint64_t"; break;
-    case BuiltinType::Double:    EltName = "float64_t"; break;
-    case BuiltinType::Float:     EltName = "float32_t"; break;
-    case BuiltinType::Half:      EltName = "float16_t"; break;
-    case BuiltinType::BFloat16:  EltName = "bfloat16_t"; break;
+    case BuiltinType::SChar:
+      EltName = "int8_t";
+      break;
+    case BuiltinType::UChar:
+      EltName = "uint8_t";
+      break;
+    case BuiltinType::Short:
+      EltName = "int16_t";
+      break;
+    case BuiltinType::UShort:
+      EltName = "uint16_t";
+      break;
+    case BuiltinType::Int:
+      EltName = "int32_t";
+      break;
+    case BuiltinType::UInt:
+      EltName = "uint32_t";
+      break;
+    case BuiltinType::LongLong:
+      EltName = "int64_t";
+      break;
+    case BuiltinType::ULongLong:
+      EltName = "uint64_t";
+      break;
+    case BuiltinType::Double:
+      EltName = "float64_t";
+      break;
+    case BuiltinType::Float:
+      EltName = "float32_t";
+      break;
+    case BuiltinType::Half:
+      EltName = "float16_t";
+      break;
+    case BuiltinType::BFloat16:
+      EltName = "bfloat16_t";
+      break;
     default:
       llvm_unreachable("unexpected Neon vector element type");
     }
   }
-  const char *BaseName = nullptr;
-  unsigned BitSize = (T->getNumElements() *
-                      getASTContext().getTypeSize(EltType));
+  char const *BaseName = nullptr;
+  unsigned BitSize =
+      (T->getNumElements() * getASTContext().getTypeSize(EltType));
   if (BitSize == 64)
     BaseName = "__simd64_";
   else {
@@ -3457,7 +3547,7 @@
   Out << BaseName << EltName;
 }
 
-void CXXNameMangler::mangleNeonVectorType(const DependentVectorType *T) {
+void CXXNameMangler::mangleNeonVectorType(DependentVectorType const *T) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
       DiagnosticsEngine::Error,
@@ -3465,7 +3555,7 @@
   Diags.Report(T->getAttributeLoc(), DiagID);
 }
 
-static StringRef mangleAArch64VectorBase(const BuiltinType *EltType) {
+static StringRef mangleAArch64VectorBase(BuiltinType const *EltType) {
   switch (EltType->getKind()) {
   case BuiltinType::SChar:
     return "Int8";
@@ -3501,7 +3591,7 @@
 // AArch64's ABI for Neon vector types specifies that they should be mangled as
 // the equivalent internal name. The vector type must be one of the special
 // types predefined by ARM.
-void CXXNameMangler::mangleAArch64NeonVectorType(const VectorType *T) {
+void CXXNameMangler::mangleAArch64NeonVectorType(VectorType const *T) {
   QualType EltType = T->getElementType();
   assert(EltType->isBuiltinType() && "Neon vector element not a BuiltinType");
   unsigned BitSize =
@@ -3534,7 +3624,7 @@
       ("__" + EltName + "x" + Twine(T->getNumElements()) + "_t").str();
   Out << TypeName.length() << TypeName;
 }
-void CXXNameMangler::mangleAArch64NeonVectorType(const DependentVectorType *T) {
+void CXXNameMangler::mangleAArch64NeonVectorType(DependentVectorType const *T) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
       DiagnosticsEngine::Error,
@@ -3566,7 +3656,7 @@
 // scheme is otherwise defined in the appendices to the Procedure Call Standard
 // for the Arm Architecture, see
 // https://github.com/ARM-software/abi-aa/blob/master/aapcs64/aapcs64.rst#appendix-c-mangling
-void CXXNameMangler::mangleAArch64FixedSveVectorType(const VectorType *T) {
+void CXXNameMangler::mangleAArch64FixedSveVectorType(VectorType const *T) {
   assert((T->getVectorKind() == VectorType::SveFixedLengthDataVector ||
           T->getVectorKind() == VectorType::SveFixedLengthPredicateVector) &&
          "expected fixed-length SVE vector!");
@@ -3631,7 +3721,7 @@
 }
 
 void CXXNameMangler::mangleAArch64FixedSveVectorType(
-    const DependentVectorType *T) {
+    DependentVectorType const *T) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
       DiagnosticsEngine::Error,
@@ -3647,14 +3737,14 @@
 // <extended element type> ::= <element type>
 //                         ::= p # AltiVec vector pixel
 //                         ::= b # Altivec vector bool
-void CXXNameMangler::mangleType(const VectorType *T) {
+void CXXNameMangler::mangleType(VectorType const *T) {
   if ((T->getVectorKind() == VectorType::NeonVector ||
        T->getVectorKind() == VectorType::NeonPolyVector)) {
     llvm::Triple Target = getASTContext().getTargetInfo().getTriple();
     llvm::Triple::ArchType Arch =
         getASTContext().getTargetInfo().getTriple().getArch();
-    if ((Arch == llvm::Triple::aarch64 ||
-         Arch == llvm::Triple::aarch64_be) && !Target.isOSDarwin())
+    if ((Arch == llvm::Triple::aarch64 || Arch == llvm::Triple::aarch64_be) &&
+        !Target.isOSDarwin())
       mangleAArch64NeonVectorType(T);
     else
       mangleNeonVectorType(T);
@@ -3673,7 +3763,7 @@
     mangleType(T->getElementType());
 }
 
-void CXXNameMangler::mangleType(const DependentVectorType *T) {
+void CXXNameMangler::mangleType(DependentVectorType const *T) {
   if ((T->getVectorKind() == VectorType::NeonVector ||
        T->getVectorKind() == VectorType::NeonPolyVector)) {
     llvm::Triple Target = getASTContext().getTargetInfo().getTriple();
@@ -3702,17 +3792,17 @@
     mangleType(T->getElementType());
 }
 
-void CXXNameMangler::mangleType(const ExtVectorType *T) {
-  mangleType(static_cast<const VectorType*>(T));
+void CXXNameMangler::mangleType(ExtVectorType const *T) {
+  mangleType(static_cast<VectorType const *>(T));
 }
-void CXXNameMangler::mangleType(const DependentSizedExtVectorType *T) {
+void CXXNameMangler::mangleType(DependentSizedExtVectorType const *T) {
   Out << "Dv";
   mangleExpression(T->getSizeExpr());
   Out << '_';
   mangleType(T->getElementType());
 }
 
-void CXXNameMangler::mangleType(const ConstantMatrixType *T) {
+void CXXNameMangler::mangleType(ConstantMatrixType const *T) {
   // Mangle matrix types as a vendor extended type:
   // u<Len>matrix_typeI<Rows><Columns><element type>E
 
@@ -3732,7 +3822,7 @@
   Out << "E";
 }
 
-void CXXNameMangler::mangleType(const DependentSizedMatrixType *T) {
+void CXXNameMangler::mangleType(DependentSizedMatrixType const *T) {
   // Mangle matrix types as a vendor extended type:
   // u<Len>matrix_typeI<row expr><column expr><element type>E
   StringRef VendorQualifier = "matrix_type";
@@ -3745,23 +3835,23 @@
   Out << "E";
 }
 
-void CXXNameMangler::mangleType(const DependentAddressSpaceType *T) {
+void CXXNameMangler::mangleType(DependentAddressSpaceType const *T) {
   SplitQualType split = T->getPointeeType().split();
   mangleQualifiers(split.Quals, T);
   mangleType(QualType(split.Ty, 0));
 }
 
-void CXXNameMangler::mangleType(const PackExpansionType *T) {
+void CXXNameMangler::mangleType(PackExpansionType const *T) {
   // <type>  ::= Dp <type>          # pack expansion (C++0x)
   Out << "Dp";
   mangleType(T->getPattern());
 }
 
-void CXXNameMangler::mangleType(const ObjCInterfaceType *T) {
+void CXXNameMangler::mangleType(ObjCInterfaceType const *T) {
   mangleSourceName(T->getDecl()->getIdentifier());
 }
 
-void CXXNameMangler::mangleType(const ObjCObjectType *T) {
+void CXXNameMangler::mangleType(ObjCObjectType const *T) {
   // Treat __kindof as a vendor extended type qualifier.
   if (T->isKindOfType())
     Out << "U8__kindof";
@@ -3771,7 +3861,7 @@
     SmallString<64> QualStr;
     llvm::raw_svector_ostream QualOS(QualStr);
     QualOS << "objcproto";
-    for (const auto *I : T->quals()) {
+    for (auto const *I : T->quals()) {
       StringRef name = I->getName();
       QualOS << name.size() << name;
     }
@@ -3789,19 +3879,19 @@
   }
 }
 
-void CXXNameMangler::mangleType(const BlockPointerType *T) {
+void CXXNameMangler::mangleType(BlockPointerType const *T) {
   Out << "U13block_pointer";
   mangleType(T->getPointeeType());
 }
 
-void CXXNameMangler::mangleType(const InjectedClassNameType *T) {
+void CXXNameMangler::mangleType(InjectedClassNameType const *T) {
   // Mangle injected class name types as if the user had written the
   // specialization out fully.  It may not actually be possible to see
   // this mangling, though.
   mangleType(T->getInjectedSpecializationType());
 }
 
-void CXXNameMangler::mangleType(const TemplateSpecializationType *T) {
+void CXXNameMangler::mangleType(TemplateSpecializationType const *T) {
   if (TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl()) {
     mangleTemplateName(TD, T->getArgs(), T->getNumArgs());
   } else {
@@ -3818,7 +3908,7 @@
   }
 }
 
-void CXXNameMangler::mangleType(const DependentNameType *T) {
+void CXXNameMangler::mangleType(DependentNameType const *T) {
   // Proposal by cxx-abi-dev, 2014-03-26
   // <class-enum-type> ::= <name>    # non-dependent or dependent type name or
   //                                 # dependent elaborated type specifier using
@@ -3830,20 +3920,20 @@
   //                   ::= Te <name> # dependent elaborated type specifier using
   //                                 # 'enum'
   switch (T->getKeyword()) {
-    case ETK_None:
-    case ETK_Typename:
-      break;
-    case ETK_Struct:
-    case ETK_Class:
-    case ETK_Interface:
-      Out << "Ts";
-      break;
-    case ETK_Union:
-      Out << "Tu";
-      break;
-    case ETK_Enum:
-      Out << "Te";
-      break;
+  case ETK_None:
+  case ETK_Typename:
+    break;
+  case ETK_Struct:
+  case ETK_Class:
+  case ETK_Interface:
+    Out << "Ts";
+    break;
+  case ETK_Union:
+    Out << "Tu";
+    break;
+  case ETK_Enum:
+    Out << "Te";
+    break;
   }
   // Typename types are always nested
   Out << 'N';
@@ -3852,14 +3942,13 @@
   Out << 'E';
 }
 
-void CXXNameMangler::mangleType(const DependentTemplateSpecializationType *T) {
+void CXXNameMangler::mangleType(DependentTemplateSpecializationType const *T) {
   // Dependently-scoped template types are nested if they have a prefix.
   Out << 'N';
 
   // TODO: avoid making this TemplateName.
-  TemplateName Prefix =
-    getASTContext().getDependentTemplateName(T->getQualifier(),
-                                             T->getIdentifier());
+  TemplateName Prefix = getASTContext().getDependentTemplateName(
+      T->getQualifier(), T->getIdentifier());
   mangleTemplatePrefix(Prefix);
 
   // FIXME: GCC does not appear to mangle the template arguments when
@@ -3869,19 +3958,19 @@
   Out << 'E';
 }
 
-void CXXNameMangler::mangleType(const TypeOfType *T) {
+void CXXNameMangler::mangleType(TypeOfType const *T) {
   // FIXME: this is pretty unsatisfactory, but there isn't an obvious
   // "extension with parameters" mangling.
   Out << "u6typeof";
 }
 
-void CXXNameMangler::mangleType(const TypeOfExprType *T) {
+void CXXNameMangler::mangleType(TypeOfExprType const *T) {
   // FIXME: this is pretty unsatisfactory, but there isn't an obvious
   // "extension with parameters" mangling.
   Out << "u6typeof";
 }
 
-void CXXNameMangler::mangleType(const DecltypeType *T) {
+void CXXNameMangler::mangleType(DecltypeType const *T) {
   Expr *E = T->getUnderlyingExpr();
 
   // type ::= Dt <expression> E  # decltype of an id-expression
@@ -3892,12 +3981,9 @@
   // class member accesses.  Note that we do not ignore parentheses;
   // parentheses change the semantics of decltype for these
   // expressions (and cause the mangler to use the other form).
-  if (isa<DeclRefExpr>(E) ||
-      isa<MemberExpr>(E) ||
-      isa<UnresolvedLookupExpr>(E) ||
-      isa<DependentScopeDeclRefExpr>(E) ||
-      isa<CXXDependentScopeMemberExpr>(E) ||
-      isa<UnresolvedMemberExpr>(E))
+  if (isa<DeclRefExpr>(E) || isa<MemberExpr>(E) ||
+      isa<UnresolvedLookupExpr>(E) || isa<DependentScopeDeclRefExpr>(E) ||
+      isa<CXXDependentScopeMemberExpr>(E) || isa<UnresolvedMemberExpr>(E))
     Out << "Dt";
   else
     Out << "DT";
@@ -3905,23 +3991,23 @@
   Out << 'E';
 }
 
-void CXXNameMangler::mangleType(const UnaryTransformType *T) {
+void CXXNameMangler::mangleType(UnaryTransformType const *T) {
   // If this is dependent, we need to record that. If not, we simply
   // mangle it as the underlying type since they are equivalent.
   if (T->isDependentType()) {
     Out << 'U';
 
     switch (T->getUTTKind()) {
-      case UnaryTransformType::EnumUnderlyingType:
-        Out << "3eut";
-        break;
+    case UnaryTransformType::EnumUnderlyingType:
+      Out << "3eut";
+      break;
     }
   }
 
   mangleType(T->getBaseType());
 }
 
-void CXXNameMangler::mangleType(const AutoType *T) {
+void CXXNameMangler::mangleType(AutoType const *T) {
   assert(T->getDeducedType().isNull() &&
          "Deduced AutoType shouldn't be handled here!");
   assert(T->getKeyword() != AutoTypeKeyword::GNUAutoType &&
@@ -3931,7 +4017,7 @@
   Out << (T->isDecltypeAuto() ? "Dc" : "Da");
 }
 
-void CXXNameMangler::mangleType(const DeducedTemplateSpecializationType *T) {
+void CXXNameMangler::mangleType(DeducedTemplateSpecializationType const *T) {
   QualType Deduced = T->getDeducedType();
   if (!Deduced.isNull())
     return mangleType(Deduced);
@@ -3946,21 +4032,21 @@
   addSubstitution(TD);
 }
 
-void CXXNameMangler::mangleType(const AtomicType *T) {
+void CXXNameMangler::mangleType(AtomicType const *T) {
   // <type> ::= U <source-name> <type>  # vendor extended type qualifier
   // (Until there's a standardized mangling...)
   Out << "U7_Atomic";
   mangleType(T->getValueType());
 }
 
-void CXXNameMangler::mangleType(const PipeType *T) {
+void CXXNameMangler::mangleType(PipeType const *T) {
   // Pipe type mangling rules are described in SPIR 2.0 specification
   // A.1 Data types and A.3 Summary of changes
   // <type> ::= 8ocl_pipe
   Out << "8ocl_pipe";
 }
 
-void CXXNameMangler::mangleType(const ExtIntType *T) {
+void CXXNameMangler::mangleType(ExtIntType const *T) {
   Out << "U7_ExtInt";
   llvm::APSInt BW(32, true);
   BW = T->getNumBits();
@@ -3972,7 +4058,7 @@
     Out << "i";
 }
 
-void CXXNameMangler::mangleType(const DependentExtIntType *T) {
+void CXXNameMangler::mangleType(DependentExtIntType const *T) {
   Out << "U7_ExtInt";
   TemplateArgument TA(T->getNumBitsExpr());
   mangleTemplateArgs(TemplateName(), &TA, 1);
@@ -3983,7 +4069,7 @@
 }
 
 void CXXNameMangler::mangleIntegerLiteral(QualType T,
-                                          const llvm::APSInt &Value) {
+                                          llvm::APSInt const &Value) {
   //  <expr-primary> ::= L <type> <value number> E # integer literal
   Out << 'L';
 
@@ -3995,15 +4081,14 @@
     mangleNumber(Value);
   }
   Out << 'E';
-
 }
 
-void CXXNameMangler::mangleMemberExprBase(const Expr *Base, bool IsArrow) {
+void CXXNameMangler::mangleMemberExprBase(Expr const *Base, bool IsArrow) {
   // Ignore member expressions involving anonymous unions.
-  while (const auto *RT = Base->getType()->getAs<RecordType>()) {
+  while (auto const *RT = Base->getType()->getAs<RecordType>()) {
     if (!RT->getDecl()->isAnonymousStructOrUnion())
       break;
-    const auto *ME = dyn_cast<MemberExpr>(Base);
+    auto const *ME = dyn_cast<MemberExpr>(Base);
     if (!ME)
       break;
     Base = ME->getBase();
@@ -4022,12 +4107,11 @@
 }
 
 /// Mangles a member expression.
-void CXXNameMangler::mangleMemberExpr(const Expr *base,
-                                      bool isArrow,
+void CXXNameMangler::mangleMemberExpr(Expr const *base, bool isArrow,
                                       NestedNameSpecifier *qualifier,
                                       NamedDecl *firstQualifierLookup,
                                       DeclarationName member,
-                                      const TemplateArgumentLoc *TemplateArgs,
+                                      TemplateArgumentLoc const *TemplateArgs,
                                       unsigned NumTemplateArgs,
                                       unsigned arity) {
   // <expression> ::= dt <expression> <unresolved-name>
@@ -4040,77 +4124,95 @@
 /// Look at the callee of the given call expression and determine if
 /// it's a parenthesized id-expression which would have triggered ADL
 /// otherwise.
-static bool isParenthesizedADLCallee(const CallExpr *call) {
-  const Expr *callee = call->getCallee();
-  const Expr *fn = callee->IgnoreParens();
+static bool isParenthesizedADLCallee(CallExpr const *call) {
+  Expr const *callee = call->getCallee();
+  Expr const *fn = callee->IgnoreParens();
 
   // Must be parenthesized.  IgnoreParens() skips __extension__ nodes,
   // too, but for those to appear in the callee, it would have to be
   // parenthesized.
-  if (callee == fn) return false;
+  if (callee == fn)
+    return false;
 
   // Must be an unresolved lookup.
-  const UnresolvedLookupExpr *lookup = dyn_cast<UnresolvedLookupExpr>(fn);
-  if (!lookup) return false;
+  UnresolvedLookupExpr const *lookup = dyn_cast<UnresolvedLookupExpr>(fn);
+  if (!lookup)
+    return false;
 
   assert(!lookup->requiresADL());
 
   // Must be an unqualified lookup.
-  if (lookup->getQualifier()) return false;
+  if (lookup->getQualifier())
+    return false;
 
   // Must not have found a class member.  Note that if one is a class
   // member, they're all class members.
-  if (lookup->getNumDecls() > 0 &&
-      (*lookup->decls_begin())->isCXXClassMember())
+  if (lookup->getNumDecls() > 0 && (*lookup->decls_begin())->isCXXClassMember())
     return false;
 
   // Otherwise, ADL would have been triggered.
   return true;
 }
 
-void CXXNameMangler::mangleCastExpression(const Expr *E, StringRef CastEncoding) {
-  const ExplicitCastExpr *ECE = cast<ExplicitCastExpr>(E);
+void CXXNameMangler::mangleCastExpression(Expr const *E,
+                                          StringRef CastEncoding) {
+  ExplicitCastExpr const *ECE = cast<ExplicitCastExpr>(E);
   Out << CastEncoding;
   mangleType(ECE->getType());
   mangleExpression(ECE->getSubExpr());
 }
 
-void CXXNameMangler::mangleInitListElements(const InitListExpr *InitList) {
+void CXXNameMangler::mangleInitListElements(InitListExpr const *InitList) {
   if (auto *Syntactic = InitList->getSyntacticForm())
     InitList = Syntactic;
   for (unsigned i = 0, e = InitList->getNumInits(); i != e; ++i)
     mangleExpression(InitList->getInit(i));
 }
 
-void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity,
+void CXXNameMangler::mangleExpression(Expr const *E, unsigned Arity,
                                       bool AsTemplateArg) {
   // <expression> ::= <unary operator-name> <expression>
   //              ::= <binary operator-name> <expression> <expression>
-  //              ::= <trinary operator-name> <expression> <expression> <expression>
-  //              ::= cv <type> expression           # conversion with one argument
-  //              ::= cv <type> _ <expression>* E # conversion with a different number of arguments
-  //              ::= dc <type> <expression>         # dynamic_cast<type> (expression)
-  //              ::= sc <type> <expression>         # static_cast<type> (expression)
-  //              ::= cc <type> <expression>         # const_cast<type> (expression)
-  //              ::= rc <type> <expression>         # reinterpret_cast<type> (expression)
+  //              ::= <trinary operator-name> <expression> <expression>
+  //              <expression>
+  //              ::= cv <type> expression           # conversion with one
+  //              argument
+  //              ::= cv <type> _ <expression>* E # conversion with a different
+  //              number of arguments
+  //              ::= dc <type> <expression>         # dynamic_cast<type>
+  //              (expression)
+  //              ::= sc <type> <expression>         # static_cast<type>
+  //              (expression)
+  //              ::= cc <type> <expression>         # const_cast<type>
+  //              (expression)
+  //              ::= rc <type> <expression>         # reinterpret_cast<type>
+  //              (expression)
   //              ::= st <type>                      # sizeof (a type)
   //              ::= at <type>                      # alignof (a type)
   //              ::= <template-param>
   //              ::= <function-param>
-  //              ::= fpT                            # 'this' expression (part of <function-param>)
-  //              ::= sr <type> <unqualified-name>                   # dependent name
-  //              ::= sr <type> <unqualified-name> <template-args>   # dependent template-id
-  //              ::= ds <expression> <expression>                   # expr.*expr
-  //              ::= sZ <template-param>                            # size of a parameter pack
+  //              ::= fpT                            # 'this' expression (part
+  //              of <function-param>)
+  //              ::= sr <type> <unqualified-name>                   # dependent
+  //              name
+  //              ::= sr <type> <unqualified-name> <template-args>   # dependent
+  //              template-id
+  //              ::= ds <expression> <expression>                   #
+  //              expr.*expr
+  //              ::= sZ <template-param>                            # size of a
+  //              parameter pack
   //              ::= sZ <function-param>    # size of a function parameter pack
-  //              ::= u <source-name> <template-arg>* E # vendor extended expression
+  //              ::= u <source-name> <template-arg>* E # vendor extended
+  //              expression
   //              ::= <expr-primary>
   // <expr-primary> ::= L <type> <value number> E    # integer literal
   //                ::= L <type> <value float> E     # floating literal
   //                ::= L <type> <string type> E     # string literal
   //                ::= L <nullptr type> E           # nullptr literal "LDnE"
-  //                ::= L <pointer type> 0 E         # null pointer template argument
-  //                ::= L <type> <real-part float> _ <imag-part float> E    # complex floating point literal (C99); not used by clang
+  //                ::= L <pointer type> 0 E         # null pointer template
+  //                argument
+  //                ::= L <type> <real-part float> _ <imag-part float> E    #
+  //                complex floating point literal (C99); not used by clang
   //                ::= L <mangled-name> E           # external name
   QualType ImplicitlyConvertedToType;
 
@@ -4123,7 +4225,7 @@
     IsPrimaryExpr = false;
   };
 
-  auto MangleDeclRefExpr = [&](const NamedDecl *D) {
+  auto MangleDeclRefExpr = [&](NamedDecl const *D) {
     switch (D->getKind()) {
     default:
       //  <expr-primary> ::= L <mangled-name> E # external name
@@ -4160,8 +4262,7 @@
   case Expr::NoStmtClass:
 #define ABSTRACT_STMT(Type)
 #define EXPR(Type, Base)
-#define STMT(Type, Base) \
-  case Expr::Type##Class:
+#define STMT(Type, Base) case Expr::Type##Class:
 #include "clang/AST/StmtNodes.inc"
     // fallthrough
 
@@ -4224,16 +4325,15 @@
   case Expr::PseudoObjectExprClass:
   case Expr::AtomicExprClass:
   case Expr::SourceLocExprClass:
-  case Expr::BuiltinBitCastExprClass:
-  {
+  case Expr::BuiltinBitCastExprClass: {
     NotPrimaryExpr();
     if (!NullOut) {
       // As bad as this diagnostic is, it's better than crashing.
       DiagnosticsEngine &Diags = Context.getDiags();
-      unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-                                       "cannot yet mangle expression type %0");
+      unsigned DiagID = Diags.getCustomDiagID(
+          DiagnosticsEngine::Error, "cannot yet mangle expression type %0");
       Diags.Report(E->getExprLoc(), DiagID)
-        << E->getStmtClassName() << E->getSourceRange();
+          << E->getStmtClassName() << E->getSourceRange();
       return;
     }
     break;
@@ -4241,7 +4341,7 @@
 
   case Expr::CXXUuidofExprClass: {
     NotPrimaryExpr();
-    const CXXUuidofExpr *UE = cast<CXXUuidofExpr>(E);
+    CXXUuidofExpr const *UE = cast<CXXUuidofExpr>(E);
     // As of clang 12, uuidof uses the vendor extended expression
     // mangling. Previously, it used a special-cased nonstandard extension.
     if (Context.getASTContext().getLangOpts().getClangABICompat() >
@@ -4270,11 +4370,11 @@
   case Expr::BinaryConditionalOperatorClass: {
     NotPrimaryExpr();
     DiagnosticsEngine &Diags = Context.getDiags();
-    unsigned DiagID =
-      Diags.getCustomDiagID(DiagnosticsEngine::Error,
-                "?: operator with omitted middle operand cannot be mangled");
+    unsigned DiagID = Diags.getCustomDiagID(
+        DiagnosticsEngine::Error,
+        "?: operator with omitted middle operand cannot be mangled");
     Diags.Report(E->getExprLoc(), DiagID)
-      << E->getStmtClassName() << E->getSourceRange();
+        << E->getStmtClassName() << E->getSourceRange();
     return;
   }
 
@@ -4293,7 +4393,7 @@
   case Expr::DesignatedInitExprClass: {
     NotPrimaryExpr();
     auto *DIE = cast<DesignatedInitExpr>(E);
-    for (const auto &Designator : DIE->designators()) {
+    for (auto const &Designator : DIE->designators()) {
       if (Designator.isFieldDesignator()) {
         Out << "di";
         mangleSourceName(Designator.getFieldName());
@@ -4334,7 +4434,7 @@
   case Expr::CXXMemberCallExprClass: // fallthrough
   case Expr::CallExprClass: {
     NotPrimaryExpr();
-    const CallExpr *CE = cast<CallExpr>(E);
+    CallExpr const *CE = cast<CallExpr>(E);
 
     // <expression> ::= cp <simple-id> <expression>* E
     // We use this mangling only when the call would use ADL except
@@ -4346,18 +4446,18 @@
       // no qualifier and should always get mangled as a <simple-id>
       // anyway.
 
-    // <expression> ::= cl <expression>* E
+      // <expression> ::= cl <expression>* E
     } else {
       Out << "cl";
     }
 
     unsigned CallArity = CE->getNumArgs();
-    for (const Expr *Arg : CE->arguments())
+    for (Expr const *Arg : CE->arguments())
       if (isa<PackExpansionExpr>(Arg))
         CallArity = UnknownArity;
 
     mangleExpression(CE->getCallee(), CallArity);
-    for (const Expr *Arg : CE->arguments())
+    for (Expr const *Arg : CE->arguments())
       mangleExpression(Arg);
     Out << 'E';
     break;
@@ -4365,11 +4465,13 @@
 
   case Expr::CXXNewExprClass: {
     NotPrimaryExpr();
-    const CXXNewExpr *New = cast<CXXNewExpr>(E);
-    if (New->isGlobalNew()) Out << "gs";
+    CXXNewExpr const *New = cast<CXXNewExpr>(E);
+    if (New->isGlobalNew())
+      Out << "gs";
     Out << (New->isArray() ? "na" : "nw");
     for (CXXNewExpr::const_arg_iterator I = New->placement_arg_begin(),
-           E = New->placement_arg_end(); I != E; ++I)
+                                        E = New->placement_arg_end();
+         I != E; ++I)
       mangleExpression(*I);
     Out << '_';
     mangleType(New->getAllocatedType());
@@ -4378,14 +4480,14 @@
         Out << "il";
       else
         Out << "pi";
-      const Expr *Init = New->getInitializer();
-      if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {
+      Expr const *Init = New->getInitializer();
+      if (CXXConstructExpr const *CCE = dyn_cast<CXXConstructExpr>(Init)) {
         // Directly inline the initializers.
         for (CXXConstructExpr::const_arg_iterator I = CCE->arg_begin(),
                                                   E = CCE->arg_end();
              I != E; ++I)
           mangleExpression(*I);
-      } else if (const ParenListExpr *PLE = dyn_cast<ParenListExpr>(Init)) {
+      } else if (ParenListExpr const *PLE = dyn_cast<ParenListExpr>(Init)) {
         for (unsigned i = 0, e = PLE->getNumExprs(); i != e; ++i)
           mangleExpression(PLE->getExpr(i));
       } else if (New->getInitializationStyle() == CXXNewExpr::ListInit &&
@@ -4401,8 +4503,8 @@
 
   case Expr::CXXPseudoDestructorExprClass: {
     NotPrimaryExpr();
-    const auto *PDE = cast<CXXPseudoDestructorExpr>(E);
-    if (const Expr *Base = PDE->getBase())
+    auto const *PDE = cast<CXXPseudoDestructorExpr>(E);
+    if (Expr const *Base = PDE->getBase())
       mangleMemberExprBase(Base, PDE->isArrow());
     NestedNameSpecifier *Qualifier = PDE->getQualifier();
     if (TypeSourceInfo *ScopeInfo = PDE->getScopeTypeInfo()) {
@@ -4428,42 +4530,37 @@
 
   case Expr::MemberExprClass: {
     NotPrimaryExpr();
-    const MemberExpr *ME = cast<MemberExpr>(E);
-    mangleMemberExpr(ME->getBase(), ME->isArrow(),
-                     ME->getQualifier(), nullptr,
-                     ME->getMemberDecl()->getDeclName(),
-                     ME->getTemplateArgs(), ME->getNumTemplateArgs(),
-                     Arity);
+    MemberExpr const *ME = cast<MemberExpr>(E);
+    mangleMemberExpr(ME->getBase(), ME->isArrow(), ME->getQualifier(), nullptr,
+                     ME->getMemberDecl()->getDeclName(), ME->getTemplateArgs(),
+                     ME->getNumTemplateArgs(), Arity);
     break;
   }
 
   case Expr::UnresolvedMemberExprClass: {
     NotPrimaryExpr();
-    const UnresolvedMemberExpr *ME = cast<UnresolvedMemberExpr>(E);
+    UnresolvedMemberExpr const *ME = cast<UnresolvedMemberExpr>(E);
     mangleMemberExpr(ME->isImplicitAccess() ? nullptr : ME->getBase(),
                      ME->isArrow(), ME->getQualifier(), nullptr,
-                     ME->getMemberName(),
-                     ME->getTemplateArgs(), ME->getNumTemplateArgs(),
-                     Arity);
+                     ME->getMemberName(), ME->getTemplateArgs(),
+                     ME->getNumTemplateArgs(), Arity);
     break;
   }
 
   case Expr::CXXDependentScopeMemberExprClass: {
     NotPrimaryExpr();
-    const CXXDependentScopeMemberExpr *ME
-      = cast<CXXDependentScopeMemberExpr>(E);
+    CXXDependentScopeMemberExpr const *ME =
+        cast<CXXDependentScopeMemberExpr>(E);
     mangleMemberExpr(ME->isImplicitAccess() ? nullptr : ME->getBase(),
                      ME->isArrow(), ME->getQualifier(),
-                     ME->getFirstQualifierFoundInScope(),
-                     ME->getMember(),
-                     ME->getTemplateArgs(), ME->getNumTemplateArgs(),
-                     Arity);
+                     ME->getFirstQualifierFoundInScope(), ME->getMember(),
+                     ME->getTemplateArgs(), ME->getNumTemplateArgs(), Arity);
     break;
   }
 
   case Expr::UnresolvedLookupExprClass: {
     NotPrimaryExpr();
-    const UnresolvedLookupExpr *ULE = cast<UnresolvedLookupExpr>(E);
+    UnresolvedLookupExpr const *ULE = cast<UnresolvedLookupExpr>(E);
     mangleUnresolvedName(ULE->getQualifier(), ULE->getName(),
                          ULE->getTemplateArgs(), ULE->getNumTemplateArgs(),
                          Arity);
@@ -4472,7 +4569,7 @@
 
   case Expr::CXXUnresolvedConstructExprClass: {
     NotPrimaryExpr();
-    const CXXUnresolvedConstructExpr *CE = cast<CXXUnresolvedConstructExpr>(E);
+    CXXUnresolvedConstructExpr const *CE = cast<CXXUnresolvedConstructExpr>(E);
     unsigned N = CE->getNumArgs();
 
     if (CE->isListInitialization()) {
@@ -4487,20 +4584,22 @@
 
     Out << "cv";
     mangleType(CE->getType());
-    if (N != 1) Out << '_';
-    for (unsigned I = 0; I != N; ++I) mangleExpression(CE->getArg(I));
-    if (N != 1) Out << 'E';
+    if (N != 1)
+      Out << '_';
+    for (unsigned I = 0; I != N; ++I)
+      mangleExpression(CE->getArg(I));
+    if (N != 1)
+      Out << 'E';
     break;
   }
 
   case Expr::CXXConstructExprClass: {
     // An implicit cast is silent, thus may contain <expr-primary>.
-    const auto *CE = cast<CXXConstructExpr>(E);
+    auto const *CE = cast<CXXConstructExpr>(E);
     if (!CE->isListInitialization() || CE->isStdInitListInitialization()) {
-      assert(
-          CE->getNumArgs() >= 1 &&
-          (CE->getNumArgs() == 1 || isa<CXXDefaultArgExpr>(CE->getArg(1))) &&
-          "implicit CXXConstructExpr must have one argument");
+      assert(CE->getNumArgs() >= 1 &&
+             (CE->getNumArgs() == 1 || isa<CXXDefaultArgExpr>(CE->getArg(1))) &&
+             "implicit CXXConstructExpr must have one argument");
       E = cast<CXXConstructExpr>(E)->getArg(0);
       goto recurse;
     }
@@ -4514,7 +4613,7 @@
 
   case Expr::CXXTemporaryObjectExprClass: {
     NotPrimaryExpr();
-    const auto *CE = cast<CXXTemporaryObjectExpr>(E);
+    auto const *CE = cast<CXXTemporaryObjectExpr>(E);
     unsigned N = CE->getNumArgs();
     bool List = CE->isListInitialization();
 
@@ -4557,7 +4656,7 @@
 
   case Expr::UnaryExprOrTypeTraitExprClass: {
     // Non-instantiation-dependent traits are an <expr-primary> integer literal.
-    const UnaryExprOrTypeTraitExpr *SAE = cast<UnaryExprOrTypeTraitExpr>(E);
+    UnaryExprOrTypeTraitExpr const *SAE = cast<UnaryExprOrTypeTraitExpr>(E);
 
     if (!SAE->isInstantiationDependent()) {
       // Itanium C++ ABI:
@@ -4569,8 +4668,9 @@
       //   integer type, that type is used for the literal; otherwise, the type
       //   of std::size_t or std::ptrdiff_t is used.
       QualType T = (ImplicitlyConvertedToType.isNull() ||
-                    !ImplicitlyConvertedToType->isIntegerType())? SAE->getType()
-                                                    : ImplicitlyConvertedToType;
+                    !ImplicitlyConvertedToType->isIntegerType())
+                       ? SAE->getType()
+                       : ImplicitlyConvertedToType;
       llvm::APSInt V = SAE->EvaluateKnownConstInt(Context.getASTContext());
       mangleIntegerLiteral(T, V);
       break;
@@ -4588,7 +4688,7 @@
       }
     };
 
-    switch(SAE->getKind()) {
+    switch (SAE->getKind()) {
     case UETT_SizeOf:
       Out << 's';
       MangleAlignofSizeofArg();
@@ -4614,8 +4714,8 @@
       break;
     case UETT_VecStep: {
       DiagnosticsEngine &Diags = Context.getDiags();
-      unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-                                     "cannot yet mangle vec_step expression");
+      unsigned DiagID = Diags.getCustomDiagID(
+          DiagnosticsEngine::Error, "cannot yet mangle vec_step expression");
       Diags.Report(DiagID);
       return;
     }
@@ -4633,7 +4733,7 @@
 
   case Expr::CXXThrowExprClass: {
     NotPrimaryExpr();
-    const CXXThrowExpr *TE = cast<CXXThrowExpr>(E);
+    CXXThrowExpr const *TE = cast<CXXThrowExpr>(E);
     //  <expression> ::= tw <expression>  # throw expression
     //               ::= tr               # rethrow
     if (TE->getSubExpr()) {
@@ -4647,7 +4747,7 @@
 
   case Expr::CXXTypeidExprClass: {
     NotPrimaryExpr();
-    const CXXTypeidExpr *TIE = cast<CXXTypeidExpr>(E);
+    CXXTypeidExpr const *TIE = cast<CXXTypeidExpr>(E);
     //  <expression> ::= ti <type>        # typeid (type)
     //               ::= te <expression>  # typeid (expression)
     if (TIE->isTypeOperand()) {
@@ -4662,10 +4762,11 @@
 
   case Expr::CXXDeleteExprClass: {
     NotPrimaryExpr();
-    const CXXDeleteExpr *DE = cast<CXXDeleteExpr>(E);
+    CXXDeleteExpr const *DE = cast<CXXDeleteExpr>(E);
     //  <expression> ::= [gs] dl <expression>  # [::] delete expr
     //               ::= [gs] da <expression>  # [::] delete [] expr
-    if (DE->isGlobalDelete()) Out << "gs";
+    if (DE->isGlobalDelete())
+      Out << "gs";
     Out << (DE->isArrayForm() ? "da" : "dl");
     mangleExpression(DE->getArgument());
     break;
@@ -4673,7 +4774,7 @@
 
   case Expr::UnaryOperatorClass: {
     NotPrimaryExpr();
-    const UnaryOperator *UO = cast<UnaryOperator>(E);
+    UnaryOperator const *UO = cast<UnaryOperator>(E);
     mangleOperatorName(UnaryOperator::getOverloadedOperator(UO->getOpcode()),
                        /*Arity=*/1);
     mangleExpression(UO->getSubExpr());
@@ -4682,7 +4783,7 @@
 
   case Expr::ArraySubscriptExprClass: {
     NotPrimaryExpr();
-    const ArraySubscriptExpr *AE = cast<ArraySubscriptExpr>(E);
+    ArraySubscriptExpr const *AE = cast<ArraySubscriptExpr>(E);
 
     // Array subscript is treated as a syntactically weird form of
     // binary operator.
@@ -4694,7 +4795,7 @@
 
   case Expr::MatrixSubscriptExprClass: {
     NotPrimaryExpr();
-    const MatrixSubscriptExpr *ME = cast<MatrixSubscriptExpr>(E);
+    MatrixSubscriptExpr const *ME = cast<MatrixSubscriptExpr>(E);
     Out << "ixix";
     mangleExpression(ME->getBase());
     mangleExpression(ME->getRowIdx());
@@ -4705,7 +4806,7 @@
   case Expr::CompoundAssignOperatorClass: // fallthrough
   case Expr::BinaryOperatorClass: {
     NotPrimaryExpr();
-    const BinaryOperator *BO = cast<BinaryOperator>(E);
+    BinaryOperator const *BO = cast<BinaryOperator>(E);
     if (BO->getOpcode() == BO_PtrMemD)
       Out << "ds";
     else
@@ -4730,7 +4831,7 @@
 
   case Expr::ConditionalOperatorClass: {
     NotPrimaryExpr();
-    const ConditionalOperator *CO = cast<ConditionalOperator>(E);
+    ConditionalOperator const *CO = cast<ConditionalOperator>(E);
     mangleOperatorName(OO_Conditional, /*Arity=*/3);
     mangleExpression(CO->getCond());
     mangleExpression(CO->getLHS(), Arity);
@@ -4802,7 +4903,7 @@
 
   case Expr::CXXOperatorCallExprClass: {
     NotPrimaryExpr();
-    const CXXOperatorCallExpr *CE = cast<CXXOperatorCallExpr>(E);
+    CXXOperatorCallExpr const *CE = cast<CXXOperatorCallExpr>(E);
     unsigned NumArgs = CE->getNumArgs();
     // A CXXOperatorCallExpr for OO_Arrow models only semantics, not syntax
     // (the enclosing MemberExpr covers the syntactic portion).
@@ -4846,7 +4947,7 @@
   case Expr::FunctionParmPackExprClass: {
     NotPrimaryExpr();
     // FIXME: not clear how to mangle this!
-    const FunctionParmPackExpr *FPPE = cast<FunctionParmPackExpr>(E);
+    FunctionParmPackExpr const *FPPE = cast<FunctionParmPackExpr>(E);
     Out << "v110_SUBSTPACK";
     MangleDeclRefExpr(FPPE->getParameterPack());
     break;
@@ -4854,7 +4955,7 @@
 
   case Expr::DependentScopeDeclRefExprClass: {
     NotPrimaryExpr();
-    const DependentScopeDeclRefExpr *DRE = cast<DependentScopeDeclRefExpr>(E);
+    DependentScopeDeclRefExpr const *DRE = cast<DependentScopeDeclRefExpr>(E);
     mangleUnresolvedName(DRE->getQualifier(), DRE->getDeclName(),
                          DRE->getTemplateArgs(), DRE->getNumTemplateArgs(),
                          Arity);
@@ -4871,7 +4972,7 @@
 
   case Expr::FloatingLiteralClass: {
     // <expr-primary>
-    const FloatingLiteral *FL = cast<FloatingLiteral>(E);
+    FloatingLiteral const *FL = cast<FloatingLiteral>(E);
     mangleFloatLiteral(FL->getType(), FL->getValue());
     break;
   }
@@ -4915,13 +5016,13 @@
 
   case Expr::ImaginaryLiteralClass: {
     // <expr-primary>
-    const ImaginaryLiteral *IE = cast<ImaginaryLiteral>(E);
+    ImaginaryLiteral const *IE = cast<ImaginaryLiteral>(E);
     // Mangle as if a complex literal.
     // Proposal from David Vandevoorde, 2010.06.30.
     Out << 'L';
     mangleType(E->getType());
-    if (const FloatingLiteral *Imag =
-          dyn_cast<FloatingLiteral>(IE->getSubExpr())) {
+    if (FloatingLiteral const *Imag =
+            dyn_cast<FloatingLiteral>(IE->getSubExpr())) {
       // Mangle a floating-point zero of the appropriate type.
       mangleFloat(llvm::APFloat(Imag->getValue().getSemantics()));
       Out << '_';
@@ -4970,21 +5071,21 @@
     auto *SPE = cast<SizeOfPackExpr>(E);
     if (SPE->isPartiallySubstituted()) {
       Out << "sP";
-      for (const auto &A : SPE->getPartialArguments())
+      for (auto const &A : SPE->getPartialArguments())
         mangleTemplateArg(A, false);
       Out << "E";
       break;
     }
 
     Out << "sZ";
-    const NamedDecl *Pack = SPE->getPack();
-    if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Pack))
+    NamedDecl const *Pack = SPE->getPack();
+    if (TemplateTypeParmDecl const *TTP = dyn_cast<TemplateTypeParmDecl>(Pack))
       mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
-    else if (const NonTypeTemplateParmDecl *NTTP
-                = dyn_cast<NonTypeTemplateParmDecl>(Pack))
+    else if (NonTypeTemplateParmDecl const *NTTP =
+                 dyn_cast<NonTypeTemplateParmDecl>(Pack))
       mangleTemplateParameter(NTTP->getDepth(), NTTP->getIndex());
-    else if (const TemplateTemplateParmDecl *TempTP
-                                    = dyn_cast<TemplateTemplateParmDecl>(Pack))
+    else if (TemplateTemplateParmDecl const *TempTP =
+                 dyn_cast<TemplateTemplateParmDecl>(Pack))
       mangleTemplateParameter(TempTP->getDepth(), TempTP->getIndex());
     else
       mangleFunctionParam(cast<ParmVarDecl>(Pack));
@@ -5043,7 +5144,7 @@
     mangleExpression(cast<CoawaitExpr>(E)->getOperand());
     break;
   case Expr::SYCLUniqueStableNameExprClass: {
-    const auto *USN = cast<SYCLUniqueStableNameExpr>(E);
+    auto const *USN = cast<SYCLUniqueStableNameExpr>(E);
     NotPrimaryExpr();
 
     Out << "u33__builtin_sycl_unique_stable_name";
@@ -5086,7 +5187,7 @@
 /// I is the zero-based index of the parameter within its parameter
 /// declaration clause.  Note that the original ABI document describes
 /// this using 1-based ordinals.
-void CXXNameMangler::mangleFunctionParam(const ParmVarDecl *parm) {
+void CXXNameMangler::mangleFunctionParam(ParmVarDecl const *parm) {
   unsigned parmDepth = parm->getFunctionScopeDepth();
   unsigned parmIndex = parm->getFunctionScopeIndex();
 
@@ -5108,11 +5209,11 @@
   // because parameters declared as arrays should already have been
   // transformed to have pointer type. FIXME: apparently these don't
   // get mangled if used as an rvalue of a known non-class type?
-  assert(!parm->getType()->isArrayType()
-         && "parameter's type is still an array type?");
+  assert(!parm->getType()->isArrayType() &&
+         "parameter's type is still an array type?");
 
-  if (const DependentAddressSpaceType *DAST =
-      dyn_cast<DependentAddressSpaceType>(parm->getType())) {
+  if (DependentAddressSpaceType const *DAST =
+          dyn_cast<DependentAddressSpaceType>(parm->getType())) {
     mangleQualifiers(DAST->getPointeeType().getQualifiers(), DAST);
   } else {
     mangleQualifiers(parm->getType().getQualifiers());
@@ -5126,7 +5227,7 @@
 }
 
 void CXXNameMangler::mangleCXXCtorType(CXXCtorType T,
-                                       const CXXRecordDecl *InheritedFrom) {
+                                       CXXRecordDecl const *InheritedFrom) {
   // <ctor-dtor-name> ::= C1  # complete object constructor
   //                  ::= C2  # base object constructor
   //                  ::= CI1 <type> # complete inheriting constructor
@@ -5182,7 +5283,7 @@
 struct TemplateArgManglingInfo {
   TemplateDecl *ResolvedTemplate = nullptr;
   bool SeenPackExpansionIntoNonPack = false;
-  const NamedDecl *UnresolvedExpandedPack = nullptr;
+  NamedDecl const *UnresolvedExpandedPack = nullptr;
 
   TemplateArgManglingInfo(TemplateName TN) {
     if (TemplateDecl *TD = TN.getAsTemplateDecl())
@@ -5193,14 +5294,14 @@
   ///
   /// This should be called exactly once for each parameter / argument pair, in
   /// order.
-  bool needExactType(unsigned ParamIdx, const TemplateArgument &Arg) {
+  bool needExactType(unsigned ParamIdx, TemplateArgument const &Arg) {
     // We need correct types when the template-name is unresolved or when it
     // names a template that is able to be overloaded.
     if (!ResolvedTemplate || SeenPackExpansionIntoNonPack)
       return true;
 
     // Move to the next parameter.
-    const NamedDecl *Param = UnresolvedExpandedPack;
+    NamedDecl const *Param = UnresolvedExpandedPack;
     if (!Param) {
       assert(ParamIdx < ResolvedTemplate->getTemplateParameters()->size() &&
              "no parameter for argument");
@@ -5246,10 +5347,10 @@
     return NTTP && NTTP->getType()->getContainedDeducedType();
   }
 };
-}
+} // namespace
 
 void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
-                                        const TemplateArgumentLoc *TemplateArgs,
+                                        TemplateArgumentLoc const *TemplateArgs,
                                         unsigned NumTemplateArgs) {
   // <template-args> ::= I <template-arg>+ E
   Out << 'I';
@@ -5261,7 +5362,7 @@
 }
 
 void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
-                                        const TemplateArgumentList &AL) {
+                                        TemplateArgumentList const &AL) {
   // <template-args> ::= I <template-arg>+ E
   Out << 'I';
   TemplateArgManglingInfo Info(TN);
@@ -5271,7 +5372,7 @@
 }
 
 void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
-                                        const TemplateArgument *TemplateArgs,
+                                        TemplateArgument const *TemplateArgs,
                                         unsigned NumTemplateArgs) {
   // <template-args> ::= I <template-arg>+ E
   Out << 'I';
@@ -5355,14 +5456,14 @@
   case TemplateArgument::Pack: {
     //  <template-arg> ::= J <template-arg>* E
     Out << 'J';
-    for (const auto &P : A.pack_elements())
+    for (auto const &P : A.pack_elements())
       mangleTemplateArg(P, NeedExactType);
     Out << 'E';
   }
   }
 }
 
-void CXXNameMangler::mangleTemplateArgExpr(const Expr *E) {
+void CXXNameMangler::mangleTemplateArgExpr(Expr const *E) {
   ASTContext &Ctx = Context.getASTContext();
   if (Ctx.getLangOpts().getClangABICompat() > LangOptions::ClangABI::Ver11) {
     mangleExpression(E, UnknownArity, /*AsTemplateArg=*/true);
@@ -5380,8 +5481,8 @@
   // (subtype of VarDecl) _incorrectly_, and emitted 'L_Z .. E' instead of
   // the proper 'Xfp_E'.
   E = E->IgnoreParenImpCasts();
-  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
-    const ValueDecl *D = DRE->getDecl();
+  if (DeclRefExpr const *DRE = dyn_cast<DeclRefExpr>(E)) {
+    ValueDecl const *D = DRE->getDecl();
     if (isa<VarDecl>(D) || isa<FunctionDecl>(D)) {
       Out << 'L';
       mangle(D);
@@ -5399,7 +5500,7 @@
 ///
 /// Note that this is not in general equivalent to determining whether the
 /// value has an all-zeroes bit pattern.
-static bool isZeroInitialized(QualType T, const APValue &V) {
+static bool isZeroInitialized(QualType T, APValue const &V) {
   // FIXME: mangleValueInTemplateArg has quadratic time complexity in
   // pathological cases due to using this, but it's a little awkward
   // to do this in linear time in general.
@@ -5410,16 +5511,16 @@
     return false;
 
   case APValue::Struct: {
-    const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
+    CXXRecordDecl const *RD = T->getAsCXXRecordDecl();
     assert(RD && "unexpected type for record value");
     unsigned I = 0;
-    for (const CXXBaseSpecifier &BS : RD->bases()) {
+    for (CXXBaseSpecifier const &BS : RD->bases()) {
       if (!isZeroInitialized(BS.getType(), V.getStructBase(I)))
         return false;
       ++I;
     }
     I = 0;
-    for (const FieldDecl *FD : RD->fields()) {
+    for (FieldDecl const *FD : RD->fields()) {
       if (!FD->isUnnamedBitfield() &&
           !isZeroInitialized(FD->getType(), V.getStructField(I)))
         return false;
@@ -5429,10 +5530,10 @@
   }
 
   case APValue::Union: {
-    const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
+    CXXRecordDecl const *RD = T->getAsCXXRecordDecl();
     assert(RD && "unexpected type for union value");
     // Zero-initialization zeroes the first non-unnamed-bitfield field, if any.
-    for (const FieldDecl *FD : RD->fields()) {
+    for (FieldDecl const *FD : RD->fields()) {
       if (!FD->isUnnamedBitfield())
         return V.getUnionField() && declaresSameEntity(FD, V.getUnionField()) &&
                isZeroInitialized(FD->getType(), V.getUnionValue());
@@ -5451,7 +5552,7 @@
   }
 
   case APValue::Vector: {
-    const VectorType *VT = T->castAs<VectorType>();
+    VectorType const *VT = T->castAs<VectorType>();
     for (unsigned I = 0, N = V.getVectorLength(); I != N; ++I)
       if (!isZeroInitialized(VT->getElementType(), V.getVectorElt(I)))
         return false;
@@ -5484,12 +5585,12 @@
   llvm_unreachable("Unhandled APValue::ValueKind enum");
 }
 
-static QualType getLValueType(ASTContext &Ctx, const APValue &LV) {
+static QualType getLValueType(ASTContext &Ctx, APValue const &LV) {
   QualType T = LV.getLValueBase().getType();
   for (APValue::LValuePathEntry E : LV.getLValuePath()) {
-    if (const ArrayType *AT = Ctx.getAsArrayType(T))
+    if (ArrayType const *AT = Ctx.getAsArrayType(T))
       T = AT->getElementType();
-    else if (const FieldDecl *FD =
+    else if (FieldDecl const *FD =
                  dyn_cast<FieldDecl>(E.getAsBaseOrMember().getPointer()))
       T = FD->getType();
     else
@@ -5499,7 +5600,7 @@
   return T;
 }
 
-void CXXNameMangler::mangleValueInTemplateArg(QualType T, const APValue &V,
+void CXXNameMangler::mangleValueInTemplateArg(QualType T, APValue const &V,
                                               bool TopLevel,
                                               bool NeedExactType) {
   // Ignore all top-level cv-qualifiers, to match GCC.
@@ -5527,11 +5628,11 @@
     llvm_unreachable("unexpected value kind in template argument");
 
   case APValue::Struct: {
-    const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
+    CXXRecordDecl const *RD = T->getAsCXXRecordDecl();
     assert(RD && "unexpected type for record value");
 
     // Drop trailing zero-initialized elements.
-    llvm::SmallVector<const FieldDecl *, 16> Fields(RD->field_begin(),
+    llvm::SmallVector<FieldDecl const *, 16> Fields(RD->field_begin(),
                                                     RD->field_end());
     while (
         !Fields.empty() &&
@@ -5567,7 +5668,7 @@
 
   case APValue::Union: {
     assert(T->getAsCXXRecordDecl() && "unexpected type for union value");
-    const FieldDecl *FD = V.getUnionField();
+    FieldDecl const *FD = V.getUnionField();
 
     if (!FD) {
       Out << 'L';
@@ -5605,7 +5706,7 @@
     }
 
     for (unsigned I = 0; I != N; ++I) {
-      const APValue &Elem = I < V.getArrayInitializedElts()
+      APValue const &Elem = I < V.getArrayInitializedElts()
                                 ? V.getArrayInitializedElt(I)
                                 : V.getArrayFiller();
       mangleValueInTemplateArg(ElemT, Elem, false);
@@ -5615,7 +5716,7 @@
   }
 
   case APValue::Vector: {
-    const VectorType *VT = T->castAs<VectorType>();
+    VectorType const *VT = T->castAs<VectorType>();
 
     NotPrimaryExpr();
     Out << "tl";
@@ -5642,7 +5743,7 @@
     break;
 
   case APValue::ComplexFloat: {
-    const ComplexType *CT = T->castAs<ComplexType>();
+    ComplexType const *CT = T->castAs<ComplexType>();
     NotPrimaryExpr();
     Out << "tl";
     mangleType(T);
@@ -5656,7 +5757,7 @@
   }
 
   case APValue::ComplexInt: {
-    const ComplexType *CT = T->castAs<ComplexType>();
+    ComplexType const *CT = T->castAs<ComplexType>();
     NotPrimaryExpr();
     Out << "tl";
     mangleType(T);
@@ -5752,11 +5853,11 @@
     }
 
     QualType TypeSoFar = B.getType();
-    if (auto *VD = B.dyn_cast<const ValueDecl*>()) {
+    if (auto *VD = B.dyn_cast<ValueDecl const *>()) {
       Out << 'L';
       mangle(VD);
       Out << 'E';
-    } else if (auto *E = B.dyn_cast<const Expr*>()) {
+    } else if (auto *E = B.dyn_cast<Expr const *>()) {
       NotPrimaryExpr();
       mangleExpression(E);
     } else if (auto TI = B.dyn_cast<TypeInfoLValue>()) {
@@ -5795,7 +5896,7 @@
             OnePastTheEnd |= CAT->getSize() == E.getAsArrayIndex();
           TypeSoFar = AT->getElementType();
         } else {
-          const Decl *D = E.getAsBaseOrMember().getPointer();
+          Decl const *D = E.getAsBaseOrMember().getPointer();
           if (auto *FD = dyn_cast<FieldDecl>(D)) {
             // <union-selector> ::= _ <number>
             if (FD->getParent()->isUnion()) {
@@ -5899,12 +6000,12 @@
 void CXXNameMangler::mangleExistingSubstitution(TemplateName tname) {
   bool result = mangleSubstitution(tname);
   assert(result && "no existing substitution for template name");
-  (void) result;
+  (void)result;
 }
 
 // <substitution> ::= S <seq-id> _
 //                ::= S_
-bool CXXNameMangler::mangleSubstitution(const NamedDecl *ND) {
+bool CXXNameMangler::mangleSubstitution(NamedDecl const *ND) {
   // Try one of the standard substitutions first.
   if (mangleStandardSubstitution(ND))
     return true;
@@ -5922,7 +6023,7 @@
 
 bool CXXNameMangler::mangleSubstitution(QualType T) {
   if (!hasMangledSubstitutionQualifiers(T)) {
-    if (const RecordType *RT = T->getAs<RecordType>())
+    if (RecordType const *RT = T->getAs<RecordType>())
       return mangleSubstitution(RT->getDecl());
   }
 
@@ -5937,7 +6038,7 @@
 
   Template = Context.getASTContext().getCanonicalTemplateName(Template);
   return mangleSubstitution(
-                      reinterpret_cast<uintptr_t>(Template.getAsVoidPointer()));
+      reinterpret_cast<uintptr_t>(Template.getAsVoidPointer()));
 }
 
 bool CXXNameMangler::mangleSubstitution(uintptr_t Ptr) {
@@ -5957,28 +6058,28 @@
     return false;
 
   return T->isSpecificBuiltinType(BuiltinType::Char_S) ||
-    T->isSpecificBuiltinType(BuiltinType::Char_U);
+         T->isSpecificBuiltinType(BuiltinType::Char_U);
 }
 
 /// Returns whether a given type is a template specialization of a given name
 /// with a single argument of type char.
-static bool isCharSpecialization(QualType T, const char *Name) {
+static bool isCharSpecialization(QualType T, char const *Name) {
   if (T.isNull())
     return false;
 
-  const RecordType *RT = T->getAs<RecordType>();
+  RecordType const *RT = T->getAs<RecordType>();
   if (!RT)
     return false;
 
-  const ClassTemplateSpecializationDecl *SD =
-    dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
+  ClassTemplateSpecializationDecl const *SD =
+      dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl());
   if (!SD)
     return false;
 
   if (!isStdNamespace(getEffectiveDeclContext(SD)))
     return false;
 
-  const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
+  TemplateArgumentList const &TemplateArgs = SD->getTemplateArgs();
   if (TemplateArgs.size() != 1)
     return false;
 
@@ -5989,12 +6090,13 @@
 }
 
 template <std::size_t StrLen>
-static bool isStreamCharSpecialization(const ClassTemplateSpecializationDecl*SD,
-                                       const char (&Str)[StrLen]) {
+static bool
+isStreamCharSpecialization(ClassTemplateSpecializationDecl const *SD,
+                           char const (&Str)[StrLen]) {
   if (!SD->getIdentifier()->isStr(Str))
     return false;
 
-  const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
+  TemplateArgumentList const &TemplateArgs = SD->getTemplateArgs();
   if (TemplateArgs.size() != 2)
     return false;
 
@@ -6007,16 +6109,16 @@
   return true;
 }
 
-bool CXXNameMangler::mangleStandardSubstitution(const NamedDecl *ND) {
+bool CXXNameMangler::mangleStandardSubstitution(NamedDecl const *ND) {
   // <substitution> ::= St # ::std::
-  if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
+  if (NamespaceDecl const *NS = dyn_cast<NamespaceDecl>(ND)) {
     if (isStd(NS)) {
       Out << "St";
       return true;
     }
   }
 
-  if (const ClassTemplateDecl *TD = dyn_cast<ClassTemplateDecl>(ND)) {
+  if (ClassTemplateDecl const *TD = dyn_cast<ClassTemplateDecl>(ND)) {
     if (!isStdNamespace(getEffectiveDeclContext(TD)))
       return false;
 
@@ -6033,8 +6135,8 @@
     }
   }
 
-  if (const ClassTemplateSpecializationDecl *SD =
-        dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
+  if (ClassTemplateSpecializationDecl const *SD =
+          dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
     if (!isStdNamespace(getEffectiveDeclContext(SD)))
       return false;
 
@@ -6042,7 +6144,7 @@
     //                            ::std::char_traits<char>,
     //                            ::std::allocator<char> >
     if (SD->getIdentifier()->isStr("basic_string")) {
-      const TemplateArgumentList &TemplateArgs = SD->getTemplateArgs();
+      TemplateArgumentList const &TemplateArgs = SD->getTemplateArgs();
 
       if (TemplateArgs.size() != 3)
         return false;
@@ -6086,7 +6188,7 @@
 
 void CXXNameMangler::addSubstitution(QualType T) {
   if (!hasMangledSubstitutionQualifiers(T)) {
-    if (const RecordType *RT = T->getAs<RecordType>()) {
+    if (RecordType const *RT = T->getAs<RecordType>()) {
       addSubstitution(RT->getDecl());
       return;
     }
@@ -6109,7 +6211,7 @@
   Substitutions[Ptr] = SeqID++;
 }
 
-void CXXNameMangler::extendSubstitutions(CXXNameMangler* Other) {
+void CXXNameMangler::extendSubstitutions(CXXNameMangler *Other) {
   assert(Other->SeqID >= SeqID && "Must be superset of substitutions!");
   if (Other->SeqID > SeqID) {
     Substitutions.swap(Other->Substitutions);
@@ -6118,7 +6220,7 @@
 }
 
 CXXNameMangler::AbiTagList
-CXXNameMangler::makeFunctionReturnTypeTags(const FunctionDecl *FD) {
+CXXNameMangler::makeFunctionReturnTypeTags(FunctionDecl const *FD) {
   // When derived abi tags are disabled there is no need to make any list.
   if (DisableDerivedAbiTags)
     return AbiTagList();
@@ -6127,7 +6229,7 @@
   CXXNameMangler TrackReturnTypeTags(*this, NullOutStream);
   TrackReturnTypeTags.disableDerivedAbiTags();
 
-  const FunctionProtoType *Proto =
+  FunctionProtoType const *Proto =
       cast<FunctionProtoType>(FD->getType()->getAs<FunctionType>());
   FunctionTypeDepthState saved = TrackReturnTypeTags.FunctionTypeDepth.push();
   TrackReturnTypeTags.FunctionTypeDepth.enterResultType();
@@ -6139,7 +6241,7 @@
 }
 
 CXXNameMangler::AbiTagList
-CXXNameMangler::makeVariableTypeTags(const VarDecl *VD) {
+CXXNameMangler::makeVariableTypeTags(VarDecl const *VD) {
   // When derived abi tags are disabled there is no need to make any list.
   if (DisableDerivedAbiTags)
     return AbiTagList();
@@ -6154,7 +6256,7 @@
 }
 
 bool CXXNameMangler::shouldHaveAbiTags(ItaniumMangleContextImpl &C,
-                                       const VarDecl *VD) {
+                                       VarDecl const *VD) {
   llvm::raw_null_ostream NullOutStream;
   CXXNameMangler TrackAbiTags(C, NullOutStream, nullptr, true);
   TrackAbiTags.mangle(VD);
@@ -6171,9 +6273,8 @@
 /// and this routine will return false. In this case, the caller should just
 /// emit the identifier of the declaration (\c D->getIdentifier()) as its
 /// name.
-void ItaniumMangleContextImpl::mangleCXXName(GlobalDecl GD,
-                                             raw_ostream &Out) {
-  const NamedDecl *D = cast<NamedDecl>(GD.getDecl());
+void ItaniumMangleContextImpl::mangleCXXName(GlobalDecl GD, raw_ostream &Out) {
+  NamedDecl const *D = cast<NamedDecl>(GD.getDecl());
   assert((isa<FunctionDecl, VarDecl, TemplateParamObjectDecl>(D)) &&
          "Invalid mangleName() call, argument is not a variable or function!");
 
@@ -6197,20 +6298,20 @@
   Mangler.mangle(GD);
 }
 
-void ItaniumMangleContextImpl::mangleCXXCtorComdat(const CXXConstructorDecl *D,
+void ItaniumMangleContextImpl::mangleCXXCtorComdat(CXXConstructorDecl const *D,
                                                    raw_ostream &Out) {
   CXXNameMangler Mangler(*this, Out, D, Ctor_Comdat);
   Mangler.mangle(GlobalDecl(D, Ctor_Comdat));
 }
 
-void ItaniumMangleContextImpl::mangleCXXDtorComdat(const CXXDestructorDecl *D,
+void ItaniumMangleContextImpl::mangleCXXDtorComdat(CXXDestructorDecl const *D,
                                                    raw_ostream &Out) {
   CXXNameMangler Mangler(*this, Out, D, Dtor_Comdat);
   Mangler.mangle(GlobalDecl(D, Dtor_Comdat));
 }
 
-void ItaniumMangleContextImpl::mangleThunk(const CXXMethodDecl *MD,
-                                           const ThunkInfo &Thunk,
+void ItaniumMangleContextImpl::mangleThunk(CXXMethodDecl const *MD,
+                                           ThunkInfo const &Thunk,
                                            raw_ostream &Out) {
   //  <special-name> ::= T <call-offset> <base encoding>
   //                      # base is the nominal target function of thunk
@@ -6239,8 +6340,8 @@
 }
 
 void ItaniumMangleContextImpl::mangleCXXDtorThunk(
-    const CXXDestructorDecl *DD, CXXDtorType Type,
-    const ThisAdjustment &ThisAdjustment, raw_ostream &Out) {
+    CXXDestructorDecl const *DD, CXXDtorType Type,
+    ThisAdjustment const &ThisAdjustment, raw_ostream &Out) {
   //  <special-name> ::= T <call-offset> <base encoding>
   //                      # base is the nominal target function of thunk
   CXXNameMangler Mangler(*this, Out, DD, Type);
@@ -6254,7 +6355,7 @@
 }
 
 /// Returns the mangled name for a guard variable for the passed in VarDecl.
-void ItaniumMangleContextImpl::mangleStaticGuardVariable(const VarDecl *D,
+void ItaniumMangleContextImpl::mangleStaticGuardVariable(VarDecl const *D,
                                                          raw_ostream &Out) {
   //  <special-name> ::= GV <object name>       # Guard variable for one-time
   //                                            # initialization
@@ -6265,7 +6366,7 @@
   Mangler.mangleName(D);
 }
 
-void ItaniumMangleContextImpl::mangleDynamicInitializer(const VarDecl *MD,
+void ItaniumMangleContextImpl::mangleDynamicInitializer(VarDecl const *MD,
                                                         raw_ostream &Out) {
   // These symbols are internal in the Itanium ABI, so the names don't matter.
   // Clang has traditionally used this symbol and allowed LLVM to adjust it to
@@ -6273,7 +6374,7 @@
   Out << "__cxx_global_var_init";
 }
 
-void ItaniumMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D,
+void ItaniumMangleContextImpl::mangleDynamicAtExitDestructor(VarDecl const *D,
                                                              raw_ostream &Out) {
   // Prefix the mangling of D with __dtor_.
   CXXNameMangler Mangler(*this, Out);
@@ -6284,7 +6385,7 @@
     Mangler.getStream() << D->getName();
 }
 
-void ItaniumMangleContextImpl::mangleDynamicStermFinalizer(const VarDecl *D,
+void ItaniumMangleContextImpl::mangleDynamicStermFinalizer(VarDecl const *D,
                                                            raw_ostream &Out) {
   // Clang generates these internal-linkage functions as part of its
   // implementation of the XL ABI.
@@ -6297,7 +6398,7 @@
 }
 
 void ItaniumMangleContextImpl::mangleSEHFilterExpression(
-    const NamedDecl *EnclosingDecl, raw_ostream &Out) {
+    NamedDecl const *EnclosingDecl, raw_ostream &Out) {
   CXXNameMangler Mangler(*this, Out);
   Mangler.getStream() << "__filt_";
   if (shouldMangleDeclName(EnclosingDecl))
@@ -6307,7 +6408,7 @@
 }
 
 void ItaniumMangleContextImpl::mangleSEHFinallyBlock(
-    const NamedDecl *EnclosingDecl, raw_ostream &Out) {
+    NamedDecl const *EnclosingDecl, raw_ostream &Out) {
   CXXNameMangler Mangler(*this, Out);
   Mangler.getStream() << "__fin_";
   if (shouldMangleDeclName(EnclosingDecl))
@@ -6316,7 +6417,7 @@
     Mangler.getStream() << EnclosingDecl->getName();
 }
 
-void ItaniumMangleContextImpl::mangleItaniumThreadLocalInit(const VarDecl *D,
+void ItaniumMangleContextImpl::mangleItaniumThreadLocalInit(VarDecl const *D,
                                                             raw_ostream &Out) {
   //  <special-name> ::= TH <object name>
   CXXNameMangler Mangler(*this, Out);
@@ -6324,16 +6425,15 @@
   Mangler.mangleName(D);
 }
 
-void
-ItaniumMangleContextImpl::mangleItaniumThreadLocalWrapper(const VarDecl *D,
-                                                          raw_ostream &Out) {
+void ItaniumMangleContextImpl::mangleItaniumThreadLocalWrapper(
+    VarDecl const *D, raw_ostream &Out) {
   //  <special-name> ::= TW <object name>
   CXXNameMangler Mangler(*this, Out);
   Mangler.getStream() << "_ZTW";
   Mangler.mangleName(D);
 }
 
-void ItaniumMangleContextImpl::mangleReferenceTemporary(const VarDecl *D,
+void ItaniumMangleContextImpl::mangleReferenceTemporary(VarDecl const *D,
                                                         unsigned ManglingNumber,
                                                         raw_ostream &Out) {
   // We match the GCC mangling here.
@@ -6345,7 +6445,7 @@
   Mangler.mangleSeqID(ManglingNumber - 1);
 }
 
-void ItaniumMangleContextImpl::mangleCXXVTable(const CXXRecordDecl *RD,
+void ItaniumMangleContextImpl::mangleCXXVTable(CXXRecordDecl const *RD,
                                                raw_ostream &Out) {
   // <special-name> ::= TV <type>  # virtual table
   CXXNameMangler Mangler(*this, Out);
@@ -6353,7 +6453,7 @@
   Mangler.mangleNameOrStandardSubstitution(RD);
 }
 
-void ItaniumMangleContextImpl::mangleCXXVTT(const CXXRecordDecl *RD,
+void ItaniumMangleContextImpl::mangleCXXVTT(CXXRecordDecl const *RD,
                                             raw_ostream &Out) {
   // <special-name> ::= TT <type>  # VTT structure
   CXXNameMangler Mangler(*this, Out);
@@ -6361,9 +6461,9 @@
   Mangler.mangleNameOrStandardSubstitution(RD);
 }
 
-void ItaniumMangleContextImpl::mangleCXXCtorVTable(const CXXRecordDecl *RD,
+void ItaniumMangleContextImpl::mangleCXXCtorVTable(CXXRecordDecl const *RD,
                                                    int64_t Offset,
-                                                   const CXXRecordDecl *Type,
+                                                   CXXRecordDecl const *Type,
                                                    raw_ostream &Out) {
   // <special-name> ::= TC <type> <offset number> _ <base type>
   CXXNameMangler Mangler(*this, Out);
@@ -6394,11 +6494,12 @@
   mangleCXXRTTIName(Ty, Out);
 }
 
-void ItaniumMangleContextImpl::mangleStringLiteral(const StringLiteral *, raw_ostream &) {
+void ItaniumMangleContextImpl::mangleStringLiteral(StringLiteral const *,
+                                                   raw_ostream &) {
   llvm_unreachable("Can't mangle string literals");
 }
 
-void ItaniumMangleContextImpl::mangleLambdaSig(const CXXRecordDecl *Lambda,
+void ItaniumMangleContextImpl::mangleLambdaSig(CXXRecordDecl const *Lambda,
                                                raw_ostream &Out) {
   CXXNameMangler Mangler(*this, Out);
   Mangler.mangleLambdaSig(Lambda);
@@ -6408,7 +6509,7 @@
                                                    DiagnosticsEngine &Diags) {
   return new ItaniumMangleContextImpl(
       Context, Diags,
-      [](ASTContext &, const NamedDecl *) -> llvm::Optional<unsigned> {
+      [](ASTContext &, NamedDecl const *) -> llvm::Optional<unsigned> {
         return llvm::None;
       });
 }
Index: clang/lib/AST/JSONNodeDumper.cpp
===================================================================
--- clang/lib/AST/JSONNodeDumper.cpp
+++ clang/lib/AST/JSONNodeDumper.cpp
@@ -6,7 +6,7 @@
 
 using namespace clang;
 
-void JSONNodeDumper::addPreviousDeclaration(const Decl *D) {
+void JSONNodeDumper::addPreviousDeclaration(Decl const *D) {
   switch (D->getKind()) {
 #define DECL(DERIVED, BASE)                                                    \
   case Decl::DERIVED:                                                          \
@@ -19,12 +19,12 @@
   llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
 }
 
-void JSONNodeDumper::Visit(const Attr *A) {
-  const char *AttrName = nullptr;
+void JSONNodeDumper::Visit(Attr const *A) {
+  char const *AttrName = nullptr;
   switch (A->getKind()) {
 #define ATTR(X)                                                                \
   case attr::X:                                                                \
-    AttrName = #X"Attr";                                                       \
+    AttrName = #X "Attr";                                                      \
     break;
 #include "clang/Basic/AttrList.inc"
 #undef ATTR
@@ -39,12 +39,12 @@
   // the actual spelling. This would allow us to distinguish between the
   // various attribute syntaxes, but we don't currently track that information
   // within the AST.
-  //JOS.attribute("spelling", A->getSpelling());
+  // JOS.attribute("spelling", A->getSpelling());
 
   InnerAttrVisitor::Visit(A);
 }
 
-void JSONNodeDumper::Visit(const Stmt *S) {
+void JSONNodeDumper::Visit(Stmt const *S) {
   if (!S)
     return;
 
@@ -53,12 +53,16 @@
   JOS.attributeObject("range",
                       [S, this] { writeSourceRange(S->getSourceRange()); });
 
-  if (const auto *E = dyn_cast<Expr>(S)) {
+  if (auto const *E = dyn_cast<Expr>(S)) {
     JOS.attribute("type", createQualType(E->getType()));
-    const char *Category = nullptr;
+    char const *Category = nullptr;
     switch (E->getValueKind()) {
-    case VK_LValue: Category = "lvalue"; break;
-    case VK_XValue: Category = "xvalue"; break;
+    case VK_LValue:
+      Category = "lvalue";
+      break;
+    case VK_XValue:
+      Category = "xvalue";
+      break;
     case VK_PRValue:
       Category = "prvalue";
       break;
@@ -68,7 +72,7 @@
   InnerStmtVisitor::Visit(S);
 }
 
-void JSONNodeDumper::Visit(const Type *T) {
+void JSONNodeDumper::Visit(Type const *T) {
   JOS.attribute("id", createPointerRepresentation(T));
 
   if (!T)
@@ -94,7 +98,7 @@
   JOS.attribute("qualifiers", T.split().Quals.getAsString());
 }
 
-void JSONNodeDumper::Visit(const Decl *D) {
+void JSONNodeDumper::Visit(Decl const *D) {
   JOS.attribute("id", createPointerRepresentation(D));
 
   if (!D)
@@ -113,14 +117,14 @@
   else if (D->isThisDeclarationReferenced())
     JOS.attribute("isReferenced", true);
 
-  if (const auto *ND = dyn_cast<NamedDecl>(D))
+  if (auto const *ND = dyn_cast<NamedDecl>(D))
     attributeOnlyIfTrue("isHidden", !ND->isUnconditionallyVisible());
 
   if (D->getLexicalDeclContext() != D->getDeclContext()) {
     // Because of multiple inheritance, a DeclContext pointer does not produce
     // the same pointer representation as a Decl pointer that references the
     // same AST Node.
-    const auto *ParentDeclContextDecl = dyn_cast<Decl>(D->getDeclContext());
+    auto const *ParentDeclContextDecl = dyn_cast<Decl>(D->getDeclContext());
     JOS.attribute("parentDeclContextId",
                   createPointerRepresentation(ParentDeclContextDecl));
   }
@@ -129,8 +133,8 @@
   InnerDeclVisitor::Visit(D);
 }
 
-void JSONNodeDumper::Visit(const comments::Comment *C,
-                           const comments::FullComment *FC) {
+void JSONNodeDumper::Visit(comments::Comment const *C,
+                           comments::FullComment const *FC) {
   if (!C)
     return;
 
@@ -144,8 +148,8 @@
   InnerCommentVisitor::visit(C, FC);
 }
 
-void JSONNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
-                           const Decl *From, StringRef Label) {
+void JSONNodeDumper::Visit(TemplateArgument const &TA, SourceRange R,
+                           Decl const *From, StringRef Label) {
   JOS.attribute("kind", "TemplateArgument");
   if (R.isValid())
     JOS.attributeObject("range", [R, this] { writeSourceRange(R); });
@@ -156,7 +160,7 @@
   InnerTemplateArgVisitor::Visit(TA);
 }
 
-void JSONNodeDumper::Visit(const CXXCtorInitializer *Init) {
+void JSONNodeDumper::Visit(CXXCtorInitializer const *Init) {
   JOS.attribute("kind", "CXXCtorInitializer");
   if (Init->isAnyMemberInitializer())
     JOS.attribute("anyInit", createBareDeclRef(Init->getAnyMember()));
@@ -170,9 +174,9 @@
     llvm_unreachable("Unknown initializer type");
 }
 
-void JSONNodeDumper::Visit(const OMPClause *C) {}
+void JSONNodeDumper::Visit(OMPClause const *C) {}
 
-void JSONNodeDumper::Visit(const BlockDecl::Capture &C) {
+void JSONNodeDumper::Visit(BlockDecl::Capture const &C) {
   JOS.attribute("kind", "Capture");
   attributeOnlyIfTrue("byref", C.isByRef());
   attributeOnlyIfTrue("nested", C.isNested());
@@ -180,12 +184,12 @@
     JOS.attribute("var", createBareDeclRef(C.getVariable()));
 }
 
-void JSONNodeDumper::Visit(const GenericSelectionExpr::ConstAssociation &A) {
+void JSONNodeDumper::Visit(GenericSelectionExpr::ConstAssociation const &A) {
   JOS.attribute("associationKind", A.getTypeSourceInfo() ? "case" : "default");
   attributeOnlyIfTrue("selected", A.isSelected());
 }
 
-void JSONNodeDumper::Visit(const concepts::Requirement *R) {
+void JSONNodeDumper::Visit(concepts::Requirement const *R) {
   if (!R)
     return;
 
@@ -214,7 +218,7 @@
                       R->containsUnexpandedParameterPack());
 }
 
-void JSONNodeDumper::Visit(const APValue &Value, QualType Ty) {
+void JSONNodeDumper::Visit(APValue const &Value, QualType Ty) {
   std::string Str;
   llvm::raw_string_ostream OS(Str);
   Value.printPretty(OS, Ctx, Ty);
@@ -304,7 +308,7 @@
   JOS.attributeObject("end", [R, this] { writeSourceLocation(R.getEnd()); });
 }
 
-std::string JSONNodeDumper::createPointerRepresentation(const void *Ptr) {
+std::string JSONNodeDumper::createPointerRepresentation(void const *Ptr) {
   // Because JSON stores integer values as signed 64-bit integers, trying to
   // represent them as such makes for very ugly pointer values in the resulting
   // output. Instead, we convert the value to hex and treat it as a string.
@@ -319,45 +323,45 @@
     SplitQualType DSQT = QT.getSplitDesugaredType();
     if (DSQT != SQT)
       Ret["desugaredQualType"] = QualType::getAsString(DSQT, PrintPolicy);
-    if (const auto *TT = QT->getAs<TypedefType>())
+    if (auto const *TT = QT->getAs<TypedefType>())
       Ret["typeAliasDeclId"] = createPointerRepresentation(TT->getDecl());
   }
   return Ret;
 }
 
-void JSONNodeDumper::writeBareDeclRef(const Decl *D) {
+void JSONNodeDumper::writeBareDeclRef(Decl const *D) {
   JOS.attribute("id", createPointerRepresentation(D));
   if (!D)
     return;
 
   JOS.attribute("kind", (llvm::Twine(D->getDeclKindName()) + "Decl").str());
-  if (const auto *ND = dyn_cast<NamedDecl>(D))
+  if (auto const *ND = dyn_cast<NamedDecl>(D))
     JOS.attribute("name", ND->getDeclName().getAsString());
-  if (const auto *VD = dyn_cast<ValueDecl>(D))
+  if (auto const *VD = dyn_cast<ValueDecl>(D))
     JOS.attribute("type", createQualType(VD->getType()));
 }
 
-llvm::json::Object JSONNodeDumper::createBareDeclRef(const Decl *D) {
+llvm::json::Object JSONNodeDumper::createBareDeclRef(Decl const *D) {
   llvm::json::Object Ret{{"id", createPointerRepresentation(D)}};
   if (!D)
     return Ret;
 
   Ret["kind"] = (llvm::Twine(D->getDeclKindName()) + "Decl").str();
-  if (const auto *ND = dyn_cast<NamedDecl>(D))
+  if (auto const *ND = dyn_cast<NamedDecl>(D))
     Ret["name"] = ND->getDeclName().getAsString();
-  if (const auto *VD = dyn_cast<ValueDecl>(D))
+  if (auto const *VD = dyn_cast<ValueDecl>(D))
     Ret["type"] = createQualType(VD->getType());
   return Ret;
 }
 
-llvm::json::Array JSONNodeDumper::createCastPath(const CastExpr *C) {
+llvm::json::Array JSONNodeDumper::createCastPath(CastExpr const *C) {
   llvm::json::Array Ret;
   if (C->path_empty())
     return Ret;
 
   for (auto I = C->path_begin(), E = C->path_end(); I != E; ++I) {
-    const CXXBaseSpecifier *Base = *I;
-    const auto *RD =
+    CXXBaseSpecifier const *Base = *I;
+    auto const *RD =
         cast<CXXRecordDecl>(Base->getType()->castAs<RecordType>()->getDecl());
 
     llvm::json::Object Val{{"name", RD->getName()}};
@@ -368,11 +372,13 @@
   return Ret;
 }
 
-#define FIELD2(Name, Flag)  if (RD->Flag()) Ret[Name] = true
-#define FIELD1(Flag)        FIELD2(#Flag, Flag)
+#define FIELD2(Name, Flag)                                                     \
+  if (RD->Flag())                                                              \
+  Ret[Name] = true
+#define FIELD1(Flag) FIELD2(#Flag, Flag)
 
 static llvm::json::Object
-createDefaultConstructorDefinitionData(const CXXRecordDecl *RD) {
+createDefaultConstructorDefinitionData(CXXRecordDecl const *RD) {
   llvm::json::Object Ret;
 
   FIELD2("exists", hasDefaultConstructor);
@@ -387,7 +393,7 @@
 }
 
 static llvm::json::Object
-createCopyConstructorDefinitionData(const CXXRecordDecl *RD) {
+createCopyConstructorDefinitionData(CXXRecordDecl const *RD) {
   llvm::json::Object Ret;
 
   FIELD2("simple", hasSimpleCopyConstructor);
@@ -405,7 +411,7 @@
 }
 
 static llvm::json::Object
-createMoveConstructorDefinitionData(const CXXRecordDecl *RD) {
+createMoveConstructorDefinitionData(CXXRecordDecl const *RD) {
   llvm::json::Object Ret;
 
   FIELD2("exists", hasMoveConstructor);
@@ -422,7 +428,7 @@
 }
 
 static llvm::json::Object
-createCopyAssignmentDefinitionData(const CXXRecordDecl *RD) {
+createCopyAssignmentDefinitionData(CXXRecordDecl const *RD) {
   llvm::json::Object Ret;
 
   FIELD2("simple", hasSimpleCopyAssignment);
@@ -438,7 +444,7 @@
 }
 
 static llvm::json::Object
-createMoveAssignmentDefinitionData(const CXXRecordDecl *RD) {
+createMoveAssignmentDefinitionData(CXXRecordDecl const *RD) {
   llvm::json::Object Ret;
 
   FIELD2("exists", hasMoveAssignment);
@@ -453,7 +459,7 @@
 }
 
 static llvm::json::Object
-createDestructorDefinitionData(const CXXRecordDecl *RD) {
+createDestructorDefinitionData(CXXRecordDecl const *RD) {
   llvm::json::Object Ret;
 
   FIELD2("simple", hasSimpleDestructor);
@@ -470,7 +476,7 @@
 }
 
 llvm::json::Object
-JSONNodeDumper::createCXXRecordDefinitionData(const CXXRecordDecl *RD) {
+JSONNodeDumper::createCXXRecordDefinitionData(CXXRecordDecl const *RD) {
   llvm::json::Object Ret;
 
   // This data is common to all C++ classes.
@@ -506,14 +512,14 @@
 #undef FIELD2
 
 std::string JSONNodeDumper::createAccessSpecifier(AccessSpecifier AS) {
-  const auto AccessSpelling = getAccessSpelling(AS);
+  auto const AccessSpelling = getAccessSpelling(AS);
   if (AccessSpelling.empty())
     return "none";
   return AccessSpelling.str();
 }
 
 llvm::json::Object
-JSONNodeDumper::createCXXBaseSpecifier(const CXXBaseSpecifier &BS) {
+JSONNodeDumper::createCXXBaseSpecifier(CXXBaseSpecifier const &BS) {
   llvm::json::Object Ret;
 
   Ret["type"] = createQualType(BS.getType());
@@ -528,11 +534,11 @@
   return Ret;
 }
 
-void JSONNodeDumper::VisitTypedefType(const TypedefType *TT) {
+void JSONNodeDumper::VisitTypedefType(TypedefType const *TT) {
   JOS.attribute("decl", createBareDeclRef(TT->getDecl()));
 }
 
-void JSONNodeDumper::VisitFunctionType(const FunctionType *T) {
+void JSONNodeDumper::VisitFunctionType(FunctionType const *T) {
   FunctionType::ExtInfo E = T->getExtInfo();
   attributeOnlyIfTrue("noreturn", E.getNoReturn());
   attributeOnlyIfTrue("producesResult", E.getProducesResult());
@@ -541,7 +547,7 @@
   JOS.attribute("cc", FunctionType::getNameForCallConv(E.getCC()));
 }
 
-void JSONNodeDumper::VisitFunctionProtoType(const FunctionProtoType *T) {
+void JSONNodeDumper::VisitFunctionProtoType(FunctionProtoType const *T) {
   FunctionProtoType::ExtProtoInfo E = T->getExtProtoInfo();
   attributeOnlyIfTrue("trailingReturn", E.HasTrailingReturn);
   attributeOnlyIfTrue("const", T->isConst());
@@ -549,9 +555,14 @@
   attributeOnlyIfTrue("restrict", T->isRestrict());
   attributeOnlyIfTrue("variadic", E.Variadic);
   switch (E.RefQualifier) {
-  case RQ_LValue: JOS.attribute("refQualifier", "&"); break;
-  case RQ_RValue: JOS.attribute("refQualifier", "&&"); break;
-  case RQ_None: break;
+  case RQ_LValue:
+    JOS.attribute("refQualifier", "&");
+    break;
+  case RQ_RValue:
+    JOS.attribute("refQualifier", "&&");
+    break;
+  case RQ_None:
+    break;
   }
   switch (E.ExceptionSpec.Type) {
   case EST_DynamicNone:
@@ -573,9 +584,10 @@
   case EST_NoexceptFalse:
     JOS.attribute("exceptionSpec", "noexcept");
     JOS.attribute("conditionEvaluatesTo",
-                E.ExceptionSpec.Type == EST_NoexceptTrue);
-    //JOS.attributeWithCall("exceptionSpecExpr",
-    //                    [this, E]() { Visit(E.ExceptionSpec.NoexceptExpr); });
+                  E.ExceptionSpec.Type == EST_NoexceptTrue);
+    // JOS.attributeWithCall("exceptionSpecExpr",
+    //                     [this, E]() { Visit(E.ExceptionSpec.NoexceptExpr);
+    //                     });
     break;
   case EST_NoThrow:
     JOS.attribute("exceptionSpec", "nothrow");
@@ -588,16 +600,17 @@
   case EST_Unevaluated:
   case EST_Uninstantiated:
   case EST_Unparsed:
-  case EST_None: break;
+  case EST_None:
+    break;
   }
   VisitFunctionType(T);
 }
 
-void JSONNodeDumper::VisitRValueReferenceType(const ReferenceType *RT) {
+void JSONNodeDumper::VisitRValueReferenceType(ReferenceType const *RT) {
   attributeOnlyIfTrue("spelledAsLValue", RT->isSpelledAsLValue());
 }
 
-void JSONNodeDumper::VisitArrayType(const ArrayType *AT) {
+void JSONNodeDumper::VisitArrayType(ArrayType const *AT) {
   switch (AT->getSizeModifier()) {
   case ArrayType::Star:
     JOS.attribute("sizeModifier", "*");
@@ -614,7 +627,7 @@
     JOS.attribute("indexTypeQualifiers", Str);
 }
 
-void JSONNodeDumper::VisitConstantArrayType(const ConstantArrayType *CAT) {
+void JSONNodeDumper::VisitConstantArrayType(ConstantArrayType const *CAT) {
   // FIXME: this should use ZExt instead of SExt, but JSON doesn't allow a
   // narrowing conversion to int64_t so it cannot be expressed.
   JOS.attribute("size", CAT->getSize().getSExtValue());
@@ -622,12 +635,12 @@
 }
 
 void JSONNodeDumper::VisitDependentSizedExtVectorType(
-    const DependentSizedExtVectorType *VT) {
+    DependentSizedExtVectorType const *VT) {
   JOS.attributeObject(
       "attrLoc", [VT, this] { writeSourceLocation(VT->getAttributeLoc()); });
 }
 
-void JSONNodeDumper::VisitVectorType(const VectorType *VT) {
+void JSONNodeDumper::VisitVectorType(VectorType const *VT) {
   JOS.attribute("numElements", VT->getNumElements());
   switch (VT->getVectorKind()) {
   case VectorType::GenericVector:
@@ -656,11 +669,11 @@
   }
 }
 
-void JSONNodeDumper::VisitUnresolvedUsingType(const UnresolvedUsingType *UUT) {
+void JSONNodeDumper::VisitUnresolvedUsingType(UnresolvedUsingType const *UUT) {
   JOS.attribute("decl", createBareDeclRef(UUT->getDecl()));
 }
 
-void JSONNodeDumper::VisitUnaryTransformType(const UnaryTransformType *UTT) {
+void JSONNodeDumper::VisitUnaryTransformType(UnaryTransformType const *UTT) {
   switch (UTT->getUTTKind()) {
   case UnaryTransformType::EnumUnderlyingType:
     JOS.attribute("transformKind", "underlying_type");
@@ -668,19 +681,19 @@
   }
 }
 
-void JSONNodeDumper::VisitTagType(const TagType *TT) {
+void JSONNodeDumper::VisitTagType(TagType const *TT) {
   JOS.attribute("decl", createBareDeclRef(TT->getDecl()));
 }
 
 void JSONNodeDumper::VisitTemplateTypeParmType(
-    const TemplateTypeParmType *TTPT) {
+    TemplateTypeParmType const *TTPT) {
   JOS.attribute("depth", TTPT->getDepth());
   JOS.attribute("index", TTPT->getIndex());
   attributeOnlyIfTrue("isPack", TTPT->isParameterPack());
   JOS.attribute("decl", createBareDeclRef(TTPT->getDecl()));
 }
 
-void JSONNodeDumper::VisitAutoType(const AutoType *AT) {
+void JSONNodeDumper::VisitAutoType(AutoType const *AT) {
   JOS.attribute("undeduced", !AT->isDeduced());
   switch (AT->getKeyword()) {
   case AutoTypeKeyword::Auto:
@@ -696,7 +709,7 @@
 }
 
 void JSONNodeDumper::VisitTemplateSpecializationType(
-    const TemplateSpecializationType *TST) {
+    TemplateSpecializationType const *TST) {
   attributeOnlyIfTrue("isAlias", TST->isTypeAlias());
 
   std::string Str;
@@ -706,40 +719,40 @@
 }
 
 void JSONNodeDumper::VisitInjectedClassNameType(
-    const InjectedClassNameType *ICNT) {
+    InjectedClassNameType const *ICNT) {
   JOS.attribute("decl", createBareDeclRef(ICNT->getDecl()));
 }
 
-void JSONNodeDumper::VisitObjCInterfaceType(const ObjCInterfaceType *OIT) {
+void JSONNodeDumper::VisitObjCInterfaceType(ObjCInterfaceType const *OIT) {
   JOS.attribute("decl", createBareDeclRef(OIT->getDecl()));
 }
 
-void JSONNodeDumper::VisitPackExpansionType(const PackExpansionType *PET) {
+void JSONNodeDumper::VisitPackExpansionType(PackExpansionType const *PET) {
   if (llvm::Optional<unsigned> N = PET->getNumExpansions())
     JOS.attribute("numExpansions", *N);
 }
 
-void JSONNodeDumper::VisitElaboratedType(const ElaboratedType *ET) {
-  if (const NestedNameSpecifier *NNS = ET->getQualifier()) {
+void JSONNodeDumper::VisitElaboratedType(ElaboratedType const *ET) {
+  if (NestedNameSpecifier const *NNS = ET->getQualifier()) {
     std::string Str;
     llvm::raw_string_ostream OS(Str);
     NNS->print(OS, PrintPolicy, /*ResolveTemplateArgs*/ true);
     JOS.attribute("qualifier", OS.str());
   }
-  if (const TagDecl *TD = ET->getOwnedTagDecl())
+  if (TagDecl const *TD = ET->getOwnedTagDecl())
     JOS.attribute("ownedTagDecl", createBareDeclRef(TD));
 }
 
-void JSONNodeDumper::VisitMacroQualifiedType(const MacroQualifiedType *MQT) {
+void JSONNodeDumper::VisitMacroQualifiedType(MacroQualifiedType const *MQT) {
   JOS.attribute("macroName", MQT->getMacroIdentifier()->getName());
 }
 
-void JSONNodeDumper::VisitMemberPointerType(const MemberPointerType *MPT) {
+void JSONNodeDumper::VisitMemberPointerType(MemberPointerType const *MPT) {
   attributeOnlyIfTrue("isData", MPT->isMemberDataPointer());
   attributeOnlyIfTrue("isFunction", MPT->isMemberFunctionPointer());
 }
 
-void JSONNodeDumper::VisitNamedDecl(const NamedDecl *ND) {
+void JSONNodeDumper::VisitNamedDecl(NamedDecl const *ND) {
   if (ND && ND->getDeclName()) {
     JOS.attribute("name", ND->getNameAsString());
     // FIXME: There are likely other contexts in which it makes no sense to ask
@@ -752,17 +765,17 @@
   }
 }
 
-void JSONNodeDumper::VisitTypedefDecl(const TypedefDecl *TD) {
+void JSONNodeDumper::VisitTypedefDecl(TypedefDecl const *TD) {
   VisitNamedDecl(TD);
   JOS.attribute("type", createQualType(TD->getUnderlyingType()));
 }
 
-void JSONNodeDumper::VisitTypeAliasDecl(const TypeAliasDecl *TAD) {
+void JSONNodeDumper::VisitTypeAliasDecl(TypeAliasDecl const *TAD) {
   VisitNamedDecl(TAD);
   JOS.attribute("type", createQualType(TAD->getUnderlyingType()));
 }
 
-void JSONNodeDumper::VisitNamespaceDecl(const NamespaceDecl *ND) {
+void JSONNodeDumper::VisitNamespaceDecl(NamespaceDecl const *ND) {
   VisitNamedDecl(ND);
   attributeOnlyIfTrue("isInline", ND->isInline());
   if (!ND->isOriginalNamespace())
@@ -770,20 +783,20 @@
                   createBareDeclRef(ND->getOriginalNamespace()));
 }
 
-void JSONNodeDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *UDD) {
+void JSONNodeDumper::VisitUsingDirectiveDecl(UsingDirectiveDecl const *UDD) {
   JOS.attribute("nominatedNamespace",
                 createBareDeclRef(UDD->getNominatedNamespace()));
 }
 
-void JSONNodeDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *NAD) {
+void JSONNodeDumper::VisitNamespaceAliasDecl(NamespaceAliasDecl const *NAD) {
   VisitNamedDecl(NAD);
   JOS.attribute("aliasedNamespace",
                 createBareDeclRef(NAD->getAliasedNamespace()));
 }
 
-void JSONNodeDumper::VisitUsingDecl(const UsingDecl *UD) {
+void JSONNodeDumper::VisitUsingDecl(UsingDecl const *UD) {
   std::string Name;
-  if (const NestedNameSpecifier *NNS = UD->getQualifier()) {
+  if (NestedNameSpecifier const *NNS = UD->getQualifier()) {
     llvm::raw_string_ostream SOS(Name);
     NNS->print(SOS, UD->getASTContext().getPrintingPolicy());
   }
@@ -791,15 +804,15 @@
   JOS.attribute("name", Name);
 }
 
-void JSONNodeDumper::VisitUsingEnumDecl(const UsingEnumDecl *UED) {
+void JSONNodeDumper::VisitUsingEnumDecl(UsingEnumDecl const *UED) {
   JOS.attribute("target", createBareDeclRef(UED->getEnumDecl()));
 }
 
-void JSONNodeDumper::VisitUsingShadowDecl(const UsingShadowDecl *USD) {
+void JSONNodeDumper::VisitUsingShadowDecl(UsingShadowDecl const *USD) {
   JOS.attribute("target", createBareDeclRef(USD->getTargetDecl()));
 }
 
-void JSONNodeDumper::VisitVarDecl(const VarDecl *VD) {
+void JSONNodeDumper::VisitVarDecl(VarDecl const *VD) {
   VisitNamedDecl(VD);
   JOS.attribute("type", createQualType(VD->getType()));
 
@@ -807,9 +820,14 @@
   if (SC != SC_None)
     JOS.attribute("storageClass", VarDecl::getStorageClassSpecifierString(SC));
   switch (VD->getTLSKind()) {
-  case VarDecl::TLS_Dynamic: JOS.attribute("tls", "dynamic"); break;
-  case VarDecl::TLS_Static: JOS.attribute("tls", "static"); break;
-  case VarDecl::TLS_None: break;
+  case VarDecl::TLS_Dynamic:
+    JOS.attribute("tls", "dynamic");
+    break;
+  case VarDecl::TLS_Static:
+    JOS.attribute("tls", "static");
+    break;
+  case VarDecl::TLS_None:
+    break;
   }
   attributeOnlyIfTrue("nrvo", VD->isNRVOVariable());
   attributeOnlyIfTrue("inline", VD->isInline());
@@ -817,15 +835,21 @@
   attributeOnlyIfTrue("modulePrivate", VD->isModulePrivate());
   if (VD->hasInit()) {
     switch (VD->getInitStyle()) {
-    case VarDecl::CInit: JOS.attribute("init", "c");  break;
-    case VarDecl::CallInit: JOS.attribute("init", "call"); break;
-    case VarDecl::ListInit: JOS.attribute("init", "list"); break;
+    case VarDecl::CInit:
+      JOS.attribute("init", "c");
+      break;
+    case VarDecl::CallInit:
+      JOS.attribute("init", "call");
+      break;
+    case VarDecl::ListInit:
+      JOS.attribute("init", "list");
+      break;
     }
   }
   attributeOnlyIfTrue("isParameterPack", VD->isParameterPack());
 }
 
-void JSONNodeDumper::VisitFieldDecl(const FieldDecl *FD) {
+void JSONNodeDumper::VisitFieldDecl(FieldDecl const *FD) {
   VisitNamedDecl(FD);
   JOS.attribute("type", createQualType(FD->getType()));
   attributeOnlyIfTrue("mutable", FD->isMutable());
@@ -834,7 +858,7 @@
   attributeOnlyIfTrue("hasInClassInitializer", FD->hasInClassInitializer());
 }
 
-void JSONNodeDumper::VisitFunctionDecl(const FunctionDecl *FD) {
+void JSONNodeDumper::VisitFunctionDecl(FunctionDecl const *FD) {
   VisitNamedDecl(FD);
   JOS.attribute("type", createQualType(FD->getType()));
   StorageClass SC = FD->getStorageClass();
@@ -852,7 +876,7 @@
                   FD->isDeleted() ? "deleted" : "default");
 }
 
-void JSONNodeDumper::VisitEnumDecl(const EnumDecl *ED) {
+void JSONNodeDumper::VisitEnumDecl(EnumDecl const *ED) {
   VisitNamedDecl(ED);
   if (ED->isFixed())
     JOS.attribute("fixedUnderlyingType", createQualType(ED->getIntegerType()));
@@ -860,17 +884,17 @@
     JOS.attribute("scopedEnumTag",
                   ED->isScopedUsingClassTag() ? "class" : "struct");
 }
-void JSONNodeDumper::VisitEnumConstantDecl(const EnumConstantDecl *ECD) {
+void JSONNodeDumper::VisitEnumConstantDecl(EnumConstantDecl const *ECD) {
   VisitNamedDecl(ECD);
   JOS.attribute("type", createQualType(ECD->getType()));
 }
 
-void JSONNodeDumper::VisitRecordDecl(const RecordDecl *RD) {
+void JSONNodeDumper::VisitRecordDecl(RecordDecl const *RD) {
   VisitNamedDecl(RD);
   JOS.attribute("tagUsed", RD->getKindName());
   attributeOnlyIfTrue("completeDefinition", RD->isCompleteDefinition());
 }
-void JSONNodeDumper::VisitCXXRecordDecl(const CXXRecordDecl *RD) {
+void JSONNodeDumper::VisitCXXRecordDecl(CXXRecordDecl const *RD) {
   VisitRecordDecl(RD);
 
   // All other information requires a complete definition.
@@ -886,7 +910,7 @@
   }
 }
 
-void JSONNodeDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
+void JSONNodeDumper::VisitTemplateTypeParmDecl(TemplateTypeParmDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("tagUsed", D->wasDeclaredWithTypename() ? "typename" : "class");
   JOS.attribute("depth", D->getDepth());
@@ -902,7 +926,7 @@
 }
 
 void JSONNodeDumper::VisitNonTypeTemplateParmDecl(
-    const NonTypeTemplateParmDecl *D) {
+    NonTypeTemplateParmDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("type", createQualType(D->getType()));
   JOS.attribute("depth", D->getDepth());
@@ -918,7 +942,7 @@
 }
 
 void JSONNodeDumper::VisitTemplateTemplateParmDecl(
-    const TemplateTemplateParmDecl *D) {
+    TemplateTemplateParmDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("depth", D->getDepth());
   JOS.attribute("index", D->getIndex());
@@ -934,46 +958,60 @@
     });
 }
 
-void JSONNodeDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *LSD) {
+void JSONNodeDumper::VisitLinkageSpecDecl(LinkageSpecDecl const *LSD) {
   StringRef Lang;
   switch (LSD->getLanguage()) {
-  case LinkageSpecDecl::lang_c: Lang = "C"; break;
-  case LinkageSpecDecl::lang_cxx: Lang = "C++"; break;
+  case LinkageSpecDecl::lang_c:
+    Lang = "C";
+    break;
+  case LinkageSpecDecl::lang_cxx:
+    Lang = "C++";
+    break;
   }
   JOS.attribute("language", Lang);
   attributeOnlyIfTrue("hasBraces", LSD->hasBraces());
 }
 
-void JSONNodeDumper::VisitAccessSpecDecl(const AccessSpecDecl *ASD) {
+void JSONNodeDumper::VisitAccessSpecDecl(AccessSpecDecl const *ASD) {
   JOS.attribute("access", createAccessSpecifier(ASD->getAccess()));
 }
 
-void JSONNodeDumper::VisitFriendDecl(const FriendDecl *FD) {
-  if (const TypeSourceInfo *T = FD->getFriendType())
+void JSONNodeDumper::VisitFriendDecl(FriendDecl const *FD) {
+  if (TypeSourceInfo const *T = FD->getFriendType())
     JOS.attribute("type", createQualType(T->getType()));
 }
 
-void JSONNodeDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
+void JSONNodeDumper::VisitObjCIvarDecl(ObjCIvarDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("type", createQualType(D->getType()));
   attributeOnlyIfTrue("synthesized", D->getSynthesize());
   switch (D->getAccessControl()) {
-  case ObjCIvarDecl::None: JOS.attribute("access", "none"); break;
-  case ObjCIvarDecl::Private: JOS.attribute("access", "private"); break;
-  case ObjCIvarDecl::Protected: JOS.attribute("access", "protected"); break;
-  case ObjCIvarDecl::Public: JOS.attribute("access", "public"); break;
-  case ObjCIvarDecl::Package: JOS.attribute("access", "package"); break;
+  case ObjCIvarDecl::None:
+    JOS.attribute("access", "none");
+    break;
+  case ObjCIvarDecl::Private:
+    JOS.attribute("access", "private");
+    break;
+  case ObjCIvarDecl::Protected:
+    JOS.attribute("access", "protected");
+    break;
+  case ObjCIvarDecl::Public:
+    JOS.attribute("access", "public");
+    break;
+  case ObjCIvarDecl::Package:
+    JOS.attribute("access", "package");
+    break;
   }
 }
 
-void JSONNodeDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
+void JSONNodeDumper::VisitObjCMethodDecl(ObjCMethodDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("returnType", createQualType(D->getReturnType()));
   JOS.attribute("instance", D->isInstanceMethod());
   attributeOnlyIfTrue("variadic", D->isVariadic());
 }
 
-void JSONNodeDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
+void JSONNodeDumper::VisitObjCTypeParamDecl(ObjCTypeParamDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("type", createQualType(D->getUnderlyingType()));
   attributeOnlyIfTrue("bounded", D->hasExplicitBound());
@@ -989,67 +1027,72 @@
   }
 }
 
-void JSONNodeDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
+void JSONNodeDumper::VisitObjCCategoryDecl(ObjCCategoryDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("interface", createBareDeclRef(D->getClassInterface()));
   JOS.attribute("implementation", createBareDeclRef(D->getImplementation()));
 
   llvm::json::Array Protocols;
-  for (const auto* P : D->protocols())
+  for (auto const *P : D->protocols())
     Protocols.push_back(createBareDeclRef(P));
   if (!Protocols.empty())
     JOS.attribute("protocols", std::move(Protocols));
 }
 
-void JSONNodeDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
+void JSONNodeDumper::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("interface", createBareDeclRef(D->getClassInterface()));
   JOS.attribute("categoryDecl", createBareDeclRef(D->getCategoryDecl()));
 }
 
-void JSONNodeDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
+void JSONNodeDumper::VisitObjCProtocolDecl(ObjCProtocolDecl const *D) {
   VisitNamedDecl(D);
 
   llvm::json::Array Protocols;
-  for (const auto *P : D->protocols())
+  for (auto const *P : D->protocols())
     Protocols.push_back(createBareDeclRef(P));
   if (!Protocols.empty())
     JOS.attribute("protocols", std::move(Protocols));
 }
 
-void JSONNodeDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
+void JSONNodeDumper::VisitObjCInterfaceDecl(ObjCInterfaceDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("super", createBareDeclRef(D->getSuperClass()));
   JOS.attribute("implementation", createBareDeclRef(D->getImplementation()));
 
   llvm::json::Array Protocols;
-  for (const auto* P : D->protocols())
+  for (auto const *P : D->protocols())
     Protocols.push_back(createBareDeclRef(P));
   if (!Protocols.empty())
     JOS.attribute("protocols", std::move(Protocols));
 }
 
 void JSONNodeDumper::VisitObjCImplementationDecl(
-    const ObjCImplementationDecl *D) {
+    ObjCImplementationDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("super", createBareDeclRef(D->getSuperClass()));
   JOS.attribute("interface", createBareDeclRef(D->getClassInterface()));
 }
 
 void JSONNodeDumper::VisitObjCCompatibleAliasDecl(
-    const ObjCCompatibleAliasDecl *D) {
+    ObjCCompatibleAliasDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("interface", createBareDeclRef(D->getClassInterface()));
 }
 
-void JSONNodeDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
+void JSONNodeDumper::VisitObjCPropertyDecl(ObjCPropertyDecl const *D) {
   VisitNamedDecl(D);
   JOS.attribute("type", createQualType(D->getType()));
 
   switch (D->getPropertyImplementation()) {
-  case ObjCPropertyDecl::None: break;
-  case ObjCPropertyDecl::Required: JOS.attribute("control", "required"); break;
-  case ObjCPropertyDecl::Optional: JOS.attribute("control", "optional"); break;
+  case ObjCPropertyDecl::None:
+    break;
+  case ObjCPropertyDecl::Required:
+    JOS.attribute("control", "required");
+    break;
+  case ObjCPropertyDecl::Optional:
+    JOS.attribute("control", "optional");
+    break;
   }
 
   ObjCPropertyAttribute::Kind Attrs = D->getPropertyAttributes();
@@ -1081,7 +1124,7 @@
   }
 }
 
-void JSONNodeDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
+void JSONNodeDumper::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl const *D) {
   VisitNamedDecl(D->getPropertyDecl());
   JOS.attribute("implKind", D->getPropertyImplementation() ==
                                     ObjCPropertyImplDecl::Synthesize
@@ -1091,16 +1134,16 @@
   JOS.attribute("ivarDecl", createBareDeclRef(D->getPropertyIvarDecl()));
 }
 
-void JSONNodeDumper::VisitBlockDecl(const BlockDecl *D) {
+void JSONNodeDumper::VisitBlockDecl(BlockDecl const *D) {
   attributeOnlyIfTrue("variadic", D->isVariadic());
   attributeOnlyIfTrue("capturesThis", D->capturesCXXThis());
 }
 
-void JSONNodeDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *OEE) {
+void JSONNodeDumper::VisitObjCEncodeExpr(ObjCEncodeExpr const *OEE) {
   JOS.attribute("encodedType", createQualType(OEE->getEncodedType()));
 }
 
-void JSONNodeDumper::VisitObjCMessageExpr(const ObjCMessageExpr *OME) {
+void JSONNodeDumper::VisitObjCMessageExpr(ObjCMessageExpr const *OME) {
   std::string Str;
   llvm::raw_string_ostream OS(Str);
 
@@ -1130,8 +1173,8 @@
     JOS.attribute("callReturnType", createQualType(CallReturnTy));
 }
 
-void JSONNodeDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *OBE) {
-  if (const ObjCMethodDecl *MD = OBE->getBoxingMethod()) {
+void JSONNodeDumper::VisitObjCBoxedExpr(ObjCBoxedExpr const *OBE) {
+  if (ObjCMethodDecl const *MD = OBE->getBoxingMethod()) {
     std::string Str;
     llvm::raw_string_ostream OS(Str);
 
@@ -1140,7 +1183,7 @@
   }
 }
 
-void JSONNodeDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *OSE) {
+void JSONNodeDumper::VisitObjCSelectorExpr(ObjCSelectorExpr const *OSE) {
   std::string Str;
   llvm::raw_string_ostream OS(Str);
 
@@ -1148,16 +1191,16 @@
   JOS.attribute("selector", OS.str());
 }
 
-void JSONNodeDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *OPE) {
+void JSONNodeDumper::VisitObjCProtocolExpr(ObjCProtocolExpr const *OPE) {
   JOS.attribute("protocol", createBareDeclRef(OPE->getProtocol()));
 }
 
-void JSONNodeDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *OPRE) {
+void JSONNodeDumper::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr const *OPRE) {
   if (OPRE->isImplicitProperty()) {
     JOS.attribute("propertyKind", "implicit");
-    if (const ObjCMethodDecl *MD = OPRE->getImplicitPropertyGetter())
+    if (ObjCMethodDecl const *MD = OPRE->getImplicitPropertyGetter())
       JOS.attribute("getter", createBareDeclRef(MD));
-    if (const ObjCMethodDecl *MD = OPRE->getImplicitPropertySetter())
+    if (ObjCMethodDecl const *MD = OPRE->getImplicitPropertySetter())
       JOS.attribute("setter", createBareDeclRef(MD));
   } else {
     JOS.attribute("propertyKind", "explicit");
@@ -1170,69 +1213,76 @@
 }
 
 void JSONNodeDumper::VisitObjCSubscriptRefExpr(
-    const ObjCSubscriptRefExpr *OSRE) {
+    ObjCSubscriptRefExpr const *OSRE) {
   JOS.attribute("subscriptKind",
                 OSRE->isArraySubscriptRefExpr() ? "array" : "dictionary");
 
-  if (const ObjCMethodDecl *MD = OSRE->getAtIndexMethodDecl())
+  if (ObjCMethodDecl const *MD = OSRE->getAtIndexMethodDecl())
     JOS.attribute("getter", createBareDeclRef(MD));
-  if (const ObjCMethodDecl *MD = OSRE->setAtIndexMethodDecl())
+  if (ObjCMethodDecl const *MD = OSRE->setAtIndexMethodDecl())
     JOS.attribute("setter", createBareDeclRef(MD));
 }
 
-void JSONNodeDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *OIRE) {
+void JSONNodeDumper::VisitObjCIvarRefExpr(ObjCIvarRefExpr const *OIRE) {
   JOS.attribute("decl", createBareDeclRef(OIRE->getDecl()));
   attributeOnlyIfTrue("isFreeIvar", OIRE->isFreeIvar());
   JOS.attribute("isArrow", OIRE->isArrow());
 }
 
-void JSONNodeDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *OBLE) {
+void JSONNodeDumper::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr const *OBLE) {
   JOS.attribute("value", OBLE->getValue() ? "__objc_yes" : "__objc_no");
 }
 
-void JSONNodeDumper::VisitDeclRefExpr(const DeclRefExpr *DRE) {
+void JSONNodeDumper::VisitDeclRefExpr(DeclRefExpr const *DRE) {
   JOS.attribute("referencedDecl", createBareDeclRef(DRE->getDecl()));
   if (DRE->getDecl() != DRE->getFoundDecl())
     JOS.attribute("foundReferencedDecl",
                   createBareDeclRef(DRE->getFoundDecl()));
   switch (DRE->isNonOdrUse()) {
-  case NOUR_None: break;
-  case NOUR_Unevaluated: JOS.attribute("nonOdrUseReason", "unevaluated"); break;
-  case NOUR_Constant: JOS.attribute("nonOdrUseReason", "constant"); break;
-  case NOUR_Discarded: JOS.attribute("nonOdrUseReason", "discarded"); break;
+  case NOUR_None:
+    break;
+  case NOUR_Unevaluated:
+    JOS.attribute("nonOdrUseReason", "unevaluated");
+    break;
+  case NOUR_Constant:
+    JOS.attribute("nonOdrUseReason", "constant");
+    break;
+  case NOUR_Discarded:
+    JOS.attribute("nonOdrUseReason", "discarded");
+    break;
   }
 }
 
 void JSONNodeDumper::VisitSYCLUniqueStableNameExpr(
-    const SYCLUniqueStableNameExpr *E) {
+    SYCLUniqueStableNameExpr const *E) {
   JOS.attribute("typeSourceInfo",
                 createQualType(E->getTypeSourceInfo()->getType()));
 }
 
-void JSONNodeDumper::VisitPredefinedExpr(const PredefinedExpr *PE) {
+void JSONNodeDumper::VisitPredefinedExpr(PredefinedExpr const *PE) {
   JOS.attribute("name", PredefinedExpr::getIdentKindName(PE->getIdentKind()));
 }
 
-void JSONNodeDumper::VisitUnaryOperator(const UnaryOperator *UO) {
+void JSONNodeDumper::VisitUnaryOperator(UnaryOperator const *UO) {
   JOS.attribute("isPostfix", UO->isPostfix());
   JOS.attribute("opcode", UnaryOperator::getOpcodeStr(UO->getOpcode()));
   if (!UO->canOverflow())
     JOS.attribute("canOverflow", false);
 }
 
-void JSONNodeDumper::VisitBinaryOperator(const BinaryOperator *BO) {
+void JSONNodeDumper::VisitBinaryOperator(BinaryOperator const *BO) {
   JOS.attribute("opcode", BinaryOperator::getOpcodeStr(BO->getOpcode()));
 }
 
 void JSONNodeDumper::VisitCompoundAssignOperator(
-    const CompoundAssignOperator *CAO) {
+    CompoundAssignOperator const *CAO) {
   VisitBinaryOperator(CAO);
   JOS.attribute("computeLHSType", createQualType(CAO->getComputationLHSType()));
   JOS.attribute("computeResultType",
                 createQualType(CAO->getComputationResultType()));
 }
 
-void JSONNodeDumper::VisitMemberExpr(const MemberExpr *ME) {
+void JSONNodeDumper::VisitMemberExpr(MemberExpr const *ME) {
   // Note, we always write this Boolean field because the information it conveys
   // is critical to understanding the AST node.
   ValueDecl *VD = ME->getMemberDecl();
@@ -1240,72 +1290,84 @@
   JOS.attribute("isArrow", ME->isArrow());
   JOS.attribute("referencedMemberDecl", createPointerRepresentation(VD));
   switch (ME->isNonOdrUse()) {
-  case NOUR_None: break;
-  case NOUR_Unevaluated: JOS.attribute("nonOdrUseReason", "unevaluated"); break;
-  case NOUR_Constant: JOS.attribute("nonOdrUseReason", "constant"); break;
-  case NOUR_Discarded: JOS.attribute("nonOdrUseReason", "discarded"); break;
+  case NOUR_None:
+    break;
+  case NOUR_Unevaluated:
+    JOS.attribute("nonOdrUseReason", "unevaluated");
+    break;
+  case NOUR_Constant:
+    JOS.attribute("nonOdrUseReason", "constant");
+    break;
+  case NOUR_Discarded:
+    JOS.attribute("nonOdrUseReason", "discarded");
+    break;
   }
 }
 
-void JSONNodeDumper::VisitCXXNewExpr(const CXXNewExpr *NE) {
+void JSONNodeDumper::VisitCXXNewExpr(CXXNewExpr const *NE) {
   attributeOnlyIfTrue("isGlobal", NE->isGlobalNew());
   attributeOnlyIfTrue("isArray", NE->isArray());
   attributeOnlyIfTrue("isPlacement", NE->getNumPlacementArgs() != 0);
   switch (NE->getInitializationStyle()) {
-  case CXXNewExpr::NoInit: break;
-  case CXXNewExpr::CallInit: JOS.attribute("initStyle", "call"); break;
-  case CXXNewExpr::ListInit: JOS.attribute("initStyle", "list"); break;
+  case CXXNewExpr::NoInit:
+    break;
+  case CXXNewExpr::CallInit:
+    JOS.attribute("initStyle", "call");
+    break;
+  case CXXNewExpr::ListInit:
+    JOS.attribute("initStyle", "list");
+    break;
   }
-  if (const FunctionDecl *FD = NE->getOperatorNew())
+  if (FunctionDecl const *FD = NE->getOperatorNew())
     JOS.attribute("operatorNewDecl", createBareDeclRef(FD));
-  if (const FunctionDecl *FD = NE->getOperatorDelete())
+  if (FunctionDecl const *FD = NE->getOperatorDelete())
     JOS.attribute("operatorDeleteDecl", createBareDeclRef(FD));
 }
-void JSONNodeDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *DE) {
+void JSONNodeDumper::VisitCXXDeleteExpr(CXXDeleteExpr const *DE) {
   attributeOnlyIfTrue("isGlobal", DE->isGlobalDelete());
   attributeOnlyIfTrue("isArray", DE->isArrayForm());
   attributeOnlyIfTrue("isArrayAsWritten", DE->isArrayFormAsWritten());
-  if (const FunctionDecl *FD = DE->getOperatorDelete())
+  if (FunctionDecl const *FD = DE->getOperatorDelete())
     JOS.attribute("operatorDeleteDecl", createBareDeclRef(FD));
 }
 
-void JSONNodeDumper::VisitCXXThisExpr(const CXXThisExpr *TE) {
+void JSONNodeDumper::VisitCXXThisExpr(CXXThisExpr const *TE) {
   attributeOnlyIfTrue("implicit", TE->isImplicit());
 }
 
-void JSONNodeDumper::VisitCastExpr(const CastExpr *CE) {
+void JSONNodeDumper::VisitCastExpr(CastExpr const *CE) {
   JOS.attribute("castKind", CE->getCastKindName());
   llvm::json::Array Path = createCastPath(CE);
   if (!Path.empty())
     JOS.attribute("path", std::move(Path));
   // FIXME: This may not be useful information as it can be obtusely gleaned
   // from the inner[] array.
-  if (const NamedDecl *ND = CE->getConversionFunction())
+  if (NamedDecl const *ND = CE->getConversionFunction())
     JOS.attribute("conversionFunc", createBareDeclRef(ND));
 }
 
-void JSONNodeDumper::VisitImplicitCastExpr(const ImplicitCastExpr *ICE) {
+void JSONNodeDumper::VisitImplicitCastExpr(ImplicitCastExpr const *ICE) {
   VisitCastExpr(ICE);
   attributeOnlyIfTrue("isPartOfExplicitCast", ICE->isPartOfExplicitCast());
 }
 
-void JSONNodeDumper::VisitCallExpr(const CallExpr *CE) {
+void JSONNodeDumper::VisitCallExpr(CallExpr const *CE) {
   attributeOnlyIfTrue("adl", CE->usesADL());
 }
 
 void JSONNodeDumper::VisitUnaryExprOrTypeTraitExpr(
-    const UnaryExprOrTypeTraitExpr *TTE) {
+    UnaryExprOrTypeTraitExpr const *TTE) {
   JOS.attribute("name", getTraitSpelling(TTE->getKind()));
   if (TTE->isArgumentType())
     JOS.attribute("argType", createQualType(TTE->getArgumentType()));
 }
 
-void JSONNodeDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *SOPE) {
+void JSONNodeDumper::VisitSizeOfPackExpr(SizeOfPackExpr const *SOPE) {
   VisitNamedDecl(SOPE->getPack());
 }
 
 void JSONNodeDumper::VisitUnresolvedLookupExpr(
-    const UnresolvedLookupExpr *ULE) {
+    UnresolvedLookupExpr const *ULE) {
   JOS.attribute("usesADL", ULE->requiresADL());
   JOS.attribute("name", ULE->getName().getAsString());
 
@@ -1315,12 +1377,12 @@
   });
 }
 
-void JSONNodeDumper::VisitAddrLabelExpr(const AddrLabelExpr *ALE) {
+void JSONNodeDumper::VisitAddrLabelExpr(AddrLabelExpr const *ALE) {
   JOS.attribute("name", ALE->getLabel()->getName());
   JOS.attribute("labelDeclId", createPointerRepresentation(ALE->getLabel()));
 }
 
-void JSONNodeDumper::VisitCXXTypeidExpr(const CXXTypeidExpr *CTE) {
+void JSONNodeDumper::VisitCXXTypeidExpr(CXXTypeidExpr const *CTE) {
   if (CTE->isTypeOperand()) {
     QualType Adjusted = CTE->getTypeOperand(Ctx);
     QualType Unadjusted = CTE->getTypeOperandSourceInfo()->getType();
@@ -1330,29 +1392,29 @@
   }
 }
 
-void JSONNodeDumper::VisitConstantExpr(const ConstantExpr *CE) {
+void JSONNodeDumper::VisitConstantExpr(ConstantExpr const *CE) {
   if (CE->getResultAPValueKind() != APValue::None)
     Visit(CE->getAPValueResult(), CE->getType());
 }
 
-void JSONNodeDumper::VisitInitListExpr(const InitListExpr *ILE) {
-  if (const FieldDecl *FD = ILE->getInitializedFieldInUnion())
+void JSONNodeDumper::VisitInitListExpr(InitListExpr const *ILE) {
+  if (FieldDecl const *FD = ILE->getInitializedFieldInUnion())
     JOS.attribute("field", createBareDeclRef(FD));
 }
 
 void JSONNodeDumper::VisitGenericSelectionExpr(
-    const GenericSelectionExpr *GSE) {
+    GenericSelectionExpr const *GSE) {
   attributeOnlyIfTrue("resultDependent", GSE->isResultDependent());
 }
 
 void JSONNodeDumper::VisitCXXUnresolvedConstructExpr(
-    const CXXUnresolvedConstructExpr *UCE) {
+    CXXUnresolvedConstructExpr const *UCE) {
   if (UCE->getType() != UCE->getTypeAsWritten())
     JOS.attribute("typeAsWritten", createQualType(UCE->getTypeAsWritten()));
   attributeOnlyIfTrue("list", UCE->isListInitialization());
 }
 
-void JSONNodeDumper::VisitCXXConstructExpr(const CXXConstructExpr *CE) {
+void JSONNodeDumper::VisitCXXConstructExpr(CXXConstructExpr const *CE) {
   CXXConstructorDecl *Ctor = CE->getConstructor();
   JOS.attribute("ctorType", createQualType(Ctor->getType()));
   attributeOnlyIfTrue("elidable", CE->isElidable());
@@ -1377,7 +1439,7 @@
   }
 }
 
-void JSONNodeDumper::VisitExprWithCleanups(const ExprWithCleanups *EWC) {
+void JSONNodeDumper::VisitExprWithCleanups(ExprWithCleanups const *EWC) {
   attributeOnlyIfTrue("cleanupsHaveSideEffects",
                       EWC->cleanupsHaveSideEffects());
   if (EWC->getNumObjects()) {
@@ -1398,16 +1460,16 @@
 }
 
 void JSONNodeDumper::VisitCXXBindTemporaryExpr(
-    const CXXBindTemporaryExpr *BTE) {
-  const CXXTemporary *Temp = BTE->getTemporary();
+    CXXBindTemporaryExpr const *BTE) {
+  CXXTemporary const *Temp = BTE->getTemporary();
   JOS.attribute("temp", createPointerRepresentation(Temp));
-  if (const CXXDestructorDecl *Dtor = Temp->getDestructor())
+  if (CXXDestructorDecl const *Dtor = Temp->getDestructor())
     JOS.attribute("dtor", createBareDeclRef(Dtor));
 }
 
 void JSONNodeDumper::VisitMaterializeTemporaryExpr(
-    const MaterializeTemporaryExpr *MTE) {
-  if (const ValueDecl *VD = MTE->getExtendingDecl())
+    MaterializeTemporaryExpr const *MTE) {
+  if (ValueDecl const *VD = MTE->getExtendingDecl())
     JOS.attribute("extendingDecl", createBareDeclRef(VD));
 
   switch (MTE->getStorageDuration()) {
@@ -1432,7 +1494,7 @@
 }
 
 void JSONNodeDumper::VisitCXXDependentScopeMemberExpr(
-    const CXXDependentScopeMemberExpr *DSME) {
+    CXXDependentScopeMemberExpr const *DSME) {
   JOS.attribute("isArrow", DSME->isArrow());
   JOS.attribute("member", DSME->getMember().getAsString());
   attributeOnlyIfTrue("hasTemplateKeyword", DSME->hasTemplateKeyword());
@@ -1448,127 +1510,127 @@
   }
 }
 
-void JSONNodeDumper::VisitRequiresExpr(const RequiresExpr *RE) {
+void JSONNodeDumper::VisitRequiresExpr(RequiresExpr const *RE) {
   if (!RE->isValueDependent())
     JOS.attribute("satisfied", RE->isSatisfied());
 }
 
-void JSONNodeDumper::VisitIntegerLiteral(const IntegerLiteral *IL) {
+void JSONNodeDumper::VisitIntegerLiteral(IntegerLiteral const *IL) {
   llvm::SmallString<16> Buffer;
   IL->getValue().toString(Buffer,
                           /*Radix=*/10, IL->getType()->isSignedIntegerType());
   JOS.attribute("value", Buffer);
 }
-void JSONNodeDumper::VisitCharacterLiteral(const CharacterLiteral *CL) {
+void JSONNodeDumper::VisitCharacterLiteral(CharacterLiteral const *CL) {
   // FIXME: This should probably print the character literal as a string,
   // rather than as a numerical value. It would be nice if the behavior matched
   // what we do to print a string literal; right now, it is impossible to tell
   // the difference between 'a' and L'a' in C from the JSON output.
   JOS.attribute("value", CL->getValue());
 }
-void JSONNodeDumper::VisitFixedPointLiteral(const FixedPointLiteral *FPL) {
+void JSONNodeDumper::VisitFixedPointLiteral(FixedPointLiteral const *FPL) {
   JOS.attribute("value", FPL->getValueAsString(/*Radix=*/10));
 }
-void JSONNodeDumper::VisitFloatingLiteral(const FloatingLiteral *FL) {
+void JSONNodeDumper::VisitFloatingLiteral(FloatingLiteral const *FL) {
   llvm::SmallString<16> Buffer;
   FL->getValue().toString(Buffer);
   JOS.attribute("value", Buffer);
 }
-void JSONNodeDumper::VisitStringLiteral(const StringLiteral *SL) {
+void JSONNodeDumper::VisitStringLiteral(StringLiteral const *SL) {
   std::string Buffer;
   llvm::raw_string_ostream SS(Buffer);
   SL->outputString(SS);
   JOS.attribute("value", SS.str());
 }
-void JSONNodeDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *BLE) {
+void JSONNodeDumper::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr const *BLE) {
   JOS.attribute("value", BLE->getValue());
 }
 
-void JSONNodeDumper::VisitIfStmt(const IfStmt *IS) {
+void JSONNodeDumper::VisitIfStmt(IfStmt const *IS) {
   attributeOnlyIfTrue("hasInit", IS->hasInitStorage());
   attributeOnlyIfTrue("hasVar", IS->hasVarStorage());
   attributeOnlyIfTrue("hasElse", IS->hasElseStorage());
   attributeOnlyIfTrue("isConstexpr", IS->isConstexpr());
 }
 
-void JSONNodeDumper::VisitSwitchStmt(const SwitchStmt *SS) {
+void JSONNodeDumper::VisitSwitchStmt(SwitchStmt const *SS) {
   attributeOnlyIfTrue("hasInit", SS->hasInitStorage());
   attributeOnlyIfTrue("hasVar", SS->hasVarStorage());
 }
-void JSONNodeDumper::VisitCaseStmt(const CaseStmt *CS) {
+void JSONNodeDumper::VisitCaseStmt(CaseStmt const *CS) {
   attributeOnlyIfTrue("isGNURange", CS->caseStmtIsGNURange());
 }
 
-void JSONNodeDumper::VisitLabelStmt(const LabelStmt *LS) {
+void JSONNodeDumper::VisitLabelStmt(LabelStmt const *LS) {
   JOS.attribute("name", LS->getName());
   JOS.attribute("declId", createPointerRepresentation(LS->getDecl()));
   attributeOnlyIfTrue("sideEntry", LS->isSideEntry());
 }
-void JSONNodeDumper::VisitGotoStmt(const GotoStmt *GS) {
+void JSONNodeDumper::VisitGotoStmt(GotoStmt const *GS) {
   JOS.attribute("targetLabelDeclId",
                 createPointerRepresentation(GS->getLabel()));
 }
 
-void JSONNodeDumper::VisitWhileStmt(const WhileStmt *WS) {
+void JSONNodeDumper::VisitWhileStmt(WhileStmt const *WS) {
   attributeOnlyIfTrue("hasVar", WS->hasVarStorage());
 }
 
-void JSONNodeDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt* OACS) {
+void JSONNodeDumper::VisitObjCAtCatchStmt(ObjCAtCatchStmt const *OACS) {
   // FIXME: it would be nice for the ASTNodeTraverser would handle the catch
   // parameter the same way for C++ and ObjC rather. In this case, C++ gets a
   // null child node and ObjC gets no child node.
   attributeOnlyIfTrue("isCatchAll", OACS->getCatchParamDecl() == nullptr);
 }
 
-void JSONNodeDumper::VisitNullTemplateArgument(const TemplateArgument &TA) {
+void JSONNodeDumper::VisitNullTemplateArgument(TemplateArgument const &TA) {
   JOS.attribute("isNull", true);
 }
-void JSONNodeDumper::VisitTypeTemplateArgument(const TemplateArgument &TA) {
+void JSONNodeDumper::VisitTypeTemplateArgument(TemplateArgument const &TA) {
   JOS.attribute("type", createQualType(TA.getAsType()));
 }
 void JSONNodeDumper::VisitDeclarationTemplateArgument(
-    const TemplateArgument &TA) {
+    TemplateArgument const &TA) {
   JOS.attribute("decl", createBareDeclRef(TA.getAsDecl()));
 }
-void JSONNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &TA) {
+void JSONNodeDumper::VisitNullPtrTemplateArgument(TemplateArgument const &TA) {
   JOS.attribute("isNullptr", true);
 }
-void JSONNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
+void JSONNodeDumper::VisitIntegralTemplateArgument(TemplateArgument const &TA) {
   JOS.attribute("value", TA.getAsIntegral().getSExtValue());
 }
-void JSONNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
+void JSONNodeDumper::VisitTemplateTemplateArgument(TemplateArgument const &TA) {
   // FIXME: cannot just call dump() on the argument, as that doesn't specify
   // the output format.
 }
 void JSONNodeDumper::VisitTemplateExpansionTemplateArgument(
-    const TemplateArgument &TA) {
+    TemplateArgument const &TA) {
   // FIXME: cannot just call dump() on the argument, as that doesn't specify
   // the output format.
 }
 void JSONNodeDumper::VisitExpressionTemplateArgument(
-    const TemplateArgument &TA) {
+    TemplateArgument const &TA) {
   JOS.attribute("isExpr", true);
 }
-void JSONNodeDumper::VisitPackTemplateArgument(const TemplateArgument &TA) {
+void JSONNodeDumper::VisitPackTemplateArgument(TemplateArgument const &TA) {
   JOS.attribute("isPack", true);
 }
 
 StringRef JSONNodeDumper::getCommentCommandName(unsigned CommandID) const {
   if (Traits)
     return Traits->getCommandInfo(CommandID)->Name;
-  if (const comments::CommandInfo *Info =
+  if (comments::CommandInfo const *Info =
           comments::CommandTraits::getBuiltinCommandInfo(CommandID))
     return Info->Name;
   return "<invalid>";
 }
 
-void JSONNodeDumper::visitTextComment(const comments::TextComment *C,
-                                      const comments::FullComment *) {
+void JSONNodeDumper::visitTextComment(comments::TextComment const *C,
+                                      comments::FullComment const *) {
   JOS.attribute("text", C->getText());
 }
 
 void JSONNodeDumper::visitInlineCommandComment(
-    const comments::InlineCommandComment *C, const comments::FullComment *) {
+    comments::InlineCommandComment const *C, comments::FullComment const *) {
   JOS.attribute("name", getCommentCommandName(C->getCommandID()));
 
   switch (C->getRenderKind()) {
@@ -1598,7 +1660,7 @@
 }
 
 void JSONNodeDumper::visitHTMLStartTagComment(
-    const comments::HTMLStartTagComment *C, const comments::FullComment *) {
+    comments::HTMLStartTagComment const *C, comments::FullComment const *) {
   JOS.attribute("name", C->getTagName());
   attributeOnlyIfTrue("selfClosing", C->isSelfClosing());
   attributeOnlyIfTrue("malformed", C->isMalformed());
@@ -1613,12 +1675,12 @@
 }
 
 void JSONNodeDumper::visitHTMLEndTagComment(
-    const comments::HTMLEndTagComment *C, const comments::FullComment *) {
+    comments::HTMLEndTagComment const *C, comments::FullComment const *) {
   JOS.attribute("name", C->getTagName());
 }
 
 void JSONNodeDumper::visitBlockCommandComment(
-    const comments::BlockCommandComment *C, const comments::FullComment *) {
+    comments::BlockCommandComment const *C, comments::FullComment const *) {
   JOS.attribute("name", getCommentCommandName(C->getCommandID()));
 
   llvm::json::Array Args;
@@ -1630,7 +1692,7 @@
 }
 
 void JSONNodeDumper::visitParamCommandComment(
-    const comments::ParamCommandComment *C, const comments::FullComment *FC) {
+    comments::ParamCommandComment const *C, comments::FullComment const *FC) {
   switch (C->getDirection()) {
   case comments::ParamCommandComment::In:
     JOS.attribute("direction", "in");
@@ -1653,7 +1715,7 @@
 }
 
 void JSONNodeDumper::visitTParamCommandComment(
-    const comments::TParamCommandComment *C, const comments::FullComment *FC) {
+    comments::TParamCommandComment const *C, comments::FullComment const *FC) {
   if (C->hasParamName())
     JOS.attribute("param", C->isPositionValid() ? C->getParamName(FC)
                                                 : C->getParamNameAsWritten());
@@ -1668,18 +1730,18 @@
 }
 
 void JSONNodeDumper::visitVerbatimBlockComment(
-    const comments::VerbatimBlockComment *C, const comments::FullComment *) {
+    comments::VerbatimBlockComment const *C, comments::FullComment const *) {
   JOS.attribute("name", getCommentCommandName(C->getCommandID()));
   JOS.attribute("closeName", C->getCloseName());
 }
 
 void JSONNodeDumper::visitVerbatimBlockLineComment(
-    const comments::VerbatimBlockLineComment *C,
-    const comments::FullComment *) {
+    comments::VerbatimBlockLineComment const *C,
+    comments::FullComment const *) {
   JOS.attribute("text", C->getText());
 }
 
 void JSONNodeDumper::visitVerbatimLineComment(
-    const comments::VerbatimLineComment *C, const comments::FullComment *) {
+    comments::VerbatimLineComment const *C, comments::FullComment const *) {
   JOS.attribute("text", C->getText());
 }
Index: clang/lib/AST/Mangle.cpp
===================================================================
--- clang/lib/AST/Mangle.cpp
+++ clang/lib/AST/Mangle.cpp
@@ -9,14 +9,14 @@
 // Implements generic name mangling support for blocks and Objective-C.
 //
 //===----------------------------------------------------------------------===//
-#include "clang/AST/Attr.h"
+#include "clang/AST/Mangle.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
-#include "clang/AST/Mangle.h"
 #include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/SourceManager.h"
@@ -33,18 +33,16 @@
 // FIXME: For blocks we currently mimic GCC's mangling scheme, which leaves
 // much to be desired. Come up with a better mangling scheme.
 
-static void mangleFunctionBlock(MangleContext &Context,
-                                StringRef Outer,
-                                const BlockDecl *BD,
-                                raw_ostream &Out) {
+static void mangleFunctionBlock(MangleContext &Context, StringRef Outer,
+                                BlockDecl const *BD, raw_ostream &Out) {
   unsigned discriminator = Context.getBlockId(BD, true);
   if (discriminator == 0)
     Out << "__" << Outer << "_block_invoke";
   else
-    Out << "__" << Outer << "_block_invoke_" << discriminator+1;
+    Out << "__" << Outer << "_block_invoke_" << discriminator + 1;
 }
 
-void MangleContext::anchor() { }
+void MangleContext::anchor() {}
 
 enum CCMangling {
   CCM_Other,
@@ -55,25 +53,25 @@
   CCM_WasmMainArgcArgv
 };
 
-static bool isExternC(const NamedDecl *ND) {
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
+static bool isExternC(NamedDecl const *ND) {
+  if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(ND))
     return FD->isExternC();
-  if (const VarDecl *VD = dyn_cast<VarDecl>(ND))
+  if (VarDecl const *VD = dyn_cast<VarDecl>(ND))
     return VD->isExternC();
   return false;
 }
 
-static CCMangling getCallingConvMangling(const ASTContext &Context,
-                                         const NamedDecl *ND) {
-  const TargetInfo &TI = Context.getTargetInfo();
-  const llvm::Triple &Triple = TI.getTriple();
+static CCMangling getCallingConvMangling(ASTContext const &Context,
+                                         NamedDecl const *ND) {
+  TargetInfo const &TI = Context.getTargetInfo();
+  llvm::Triple const &Triple = TI.getTriple();
 
   // On wasm, the argc/argv form of "main" is renamed so that the startup code
   // can call it with the correct function signature.
   // On Emscripten, users may be exporting "main" and expecting to call it
   // themselves, so we can't mangle it.
   if (Triple.isWasm() && !Triple.isOSEmscripten())
-    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
+    if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(ND))
       if (FD->isMain() && FD->hasPrototype() && FD->param_size() == 2)
         return CCM_WasmMainArgcArgv;
 
@@ -84,12 +82,12 @@
       TI.getCXXABI() == TargetCXXABI::Microsoft)
     return CCM_Other;
 
-  const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND);
+  FunctionDecl const *FD = dyn_cast<FunctionDecl>(ND);
   if (!FD)
     return CCM_Other;
   QualType T = FD->getType();
 
-  const FunctionType *FT = T->castAs<FunctionType>();
+  FunctionType const *FT = T->castAs<FunctionType>();
 
   CallingConv CC = FT->getCallConv();
   switch (CC) {
@@ -104,8 +102,8 @@
   }
 }
 
-bool MangleContext::shouldMangleDeclName(const NamedDecl *D) {
-  const ASTContext &ASTContext = getASTContext();
+bool MangleContext::shouldMangleDeclName(NamedDecl const *D) {
+  ASTContext const &ASTContext = getASTContext();
 
   CCMangling CC = getCallingConvMangling(ASTContext, D);
   if (CC != CCM_Other)
@@ -139,12 +137,12 @@
 }
 
 void MangleContext::mangleName(GlobalDecl GD, raw_ostream &Out) {
-  const ASTContext &ASTContext = getASTContext();
-  const NamedDecl *D = cast<NamedDecl>(GD.getDecl());
+  ASTContext const &ASTContext = getASTContext();
+  NamedDecl const *D = cast<NamedDecl>(GD.getDecl());
 
   // Any decl can be declared with __asm("foo") on it, and this takes precedence
   // over all other naming in the .o file.
-  if (const AsmLabelAttr *ALA = D->getAttr<AsmLabelAttr>()) {
+  if (AsmLabelAttr const *ALA = D->getAttr<AsmLabelAttr>()) {
     // If we have an asm name, then we use it as the mangling.
 
     // If the label isn't literal, or if this is an alias for an LLVM intrinsic,
@@ -186,9 +184,9 @@
   }
 
   bool MCXX = shouldMangleCXXName(D);
-  const TargetInfo &TI = Context.getTargetInfo();
+  TargetInfo const &TI = Context.getTargetInfo();
   if (CC == CCM_Other || (MCXX && TI.getCXXABI() == TargetCXXABI::Microsoft)) {
-    if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D))
+    if (ObjCMethodDecl const *OMD = dyn_cast<ObjCMethodDecl>(D))
       mangleObjCMethodNameAsSourceName(OMD, Out);
     else
       mangleCXXName(GD, Out);
@@ -205,14 +203,14 @@
 
   if (!MCXX)
     Out << D->getIdentifier()->getName();
-  else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D))
+  else if (ObjCMethodDecl const *OMD = dyn_cast<ObjCMethodDecl>(D))
     mangleObjCMethodNameAsSourceName(OMD, Out);
   else
     mangleCXXName(GD, Out);
 
-  const FunctionDecl *FD = cast<FunctionDecl>(D);
-  const FunctionType *FT = FD->getType()->castAs<FunctionType>();
-  const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT);
+  FunctionDecl const *FD = cast<FunctionDecl>(D);
+  FunctionType const *FT = FD->getType()->castAs<FunctionType>();
+  FunctionProtoType const *Proto = dyn_cast<FunctionProtoType>(FT);
   if (CC == CCM_Vector)
     Out << '@';
   Out << '@';
@@ -222,10 +220,10 @@
   }
   assert(!Proto->isVariadic());
   unsigned ArgWords = 0;
-  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
+  if (CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(FD))
     if (!MD->isStatic())
       ++ArgWords;
-  for (const auto &AT : Proto->param_types())
+  for (auto const &AT : Proto->param_types())
     // Size should be aligned to pointer size.
     ArgWords +=
         llvm::alignTo(ASTContext.getTypeSize(AT), TI.getPointerWidth(0)) /
@@ -233,7 +231,7 @@
   Out << ((TI.getPointerWidth(0) / 8) * ArgWords);
 }
 
-void MangleContext::mangleMSGuidDecl(const MSGuidDecl *GD, raw_ostream &Out) {
+void MangleContext::mangleMSGuidDecl(MSGuidDecl const *GD, raw_ostream &Out) {
   // For now, follow the MSVC naming convention for GUID objects on all
   // targets.
   MSGuidDecl::Parts P = GD->getParts();
@@ -247,8 +245,7 @@
   }
 }
 
-void MangleContext::mangleGlobalBlock(const BlockDecl *BD,
-                                      const NamedDecl *ID,
+void MangleContext::mangleGlobalBlock(BlockDecl const *BD, NamedDecl const *ID,
                                       raw_ostream &Out) {
   unsigned discriminator = getBlockId(BD, false);
   if (ID) {
@@ -261,11 +258,11 @@
   if (discriminator == 0)
     Out << "_block_invoke";
   else
-    Out << "_block_invoke_" << discriminator+1;
+    Out << "_block_invoke_" << discriminator + 1;
 }
 
-void MangleContext::mangleCtorBlock(const CXXConstructorDecl *CD,
-                                    CXXCtorType CT, const BlockDecl *BD,
+void MangleContext::mangleCtorBlock(CXXConstructorDecl const *CD,
+                                    CXXCtorType CT, BlockDecl const *BD,
                                     raw_ostream &ResStream) {
   SmallString<64> Buffer;
   llvm::raw_svector_ostream Out(Buffer);
@@ -273,8 +270,8 @@
   mangleFunctionBlock(*this, Buffer, BD, ResStream);
 }
 
-void MangleContext::mangleDtorBlock(const CXXDestructorDecl *DD,
-                                    CXXDtorType DT, const BlockDecl *BD,
+void MangleContext::mangleDtorBlock(CXXDestructorDecl const *DD, CXXDtorType DT,
+                                    BlockDecl const *BD,
                                     raw_ostream &ResStream) {
   SmallString<64> Buffer;
   llvm::raw_svector_ostream Out(Buffer);
@@ -282,25 +279,25 @@
   mangleFunctionBlock(*this, Buffer, BD, ResStream);
 }
 
-void MangleContext::mangleBlock(const DeclContext *DC, const BlockDecl *BD,
+void MangleContext::mangleBlock(DeclContext const *DC, BlockDecl const *BD,
                                 raw_ostream &Out) {
   assert(!isa<CXXConstructorDecl>(DC) && !isa<CXXDestructorDecl>(DC));
 
   SmallString<64> Buffer;
   llvm::raw_svector_ostream Stream(Buffer);
-  if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) {
+  if (ObjCMethodDecl const *Method = dyn_cast<ObjCMethodDecl>(DC)) {
     mangleObjCMethodNameAsSourceName(Method, Stream);
   } else {
     assert((isa<NamedDecl>(DC) || isa<BlockDecl>(DC)) &&
            "expected a NamedDecl or BlockDecl");
     if (isa<BlockDecl>(DC))
       for (; DC && isa<BlockDecl>(DC); DC = DC->getParent())
-        (void) getBlockId(cast<BlockDecl>(DC), true);
+        (void)getBlockId(cast<BlockDecl>(DC), true);
     assert((isa<TranslationUnitDecl>(DC) || isa<NamedDecl>(DC)) &&
            "expected a TranslationUnitDecl or a NamedDecl");
-    if (const auto *CD = dyn_cast<CXXConstructorDecl>(DC))
+    if (auto const *CD = dyn_cast<CXXConstructorDecl>(DC))
       mangleCtorBlock(CD, /*CT*/ Ctor_Complete, BD, Out);
-    else if (const auto *DD = dyn_cast<CXXDestructorDecl>(DC))
+    else if (auto const *DD = dyn_cast<CXXDestructorDecl>(DC))
       mangleDtorBlock(DD, /*DT*/ Dtor_Complete, BD, Out);
     else if (auto ND = dyn_cast<NamedDecl>(DC)) {
       if (!shouldMangleDeclName(ND) && ND->getIdentifier())
@@ -318,7 +315,7 @@
   mangleFunctionBlock(*this, Buffer, BD, Out);
 }
 
-void MangleContext::mangleObjCMethodName(const ObjCMethodDecl *MD,
+void MangleContext::mangleObjCMethodName(ObjCMethodDecl const *MD,
                                          raw_ostream &OS,
                                          bool includePrefixByte,
                                          bool includeCategoryNamespace) {
@@ -337,10 +334,9 @@
     OS << '_';
 
     auto selector = MD->getSelector();
-    for (unsigned slotIndex = 0,
-                  numArgs = selector.getNumArgs(),
+    for (unsigned slotIndex = 0, numArgs = selector.getNumArgs(),
                   slotEnd = std::max(numArgs, 1U);
-           slotIndex != slotEnd; ++slotIndex) {
+         slotIndex != slotEnd; ++slotIndex) {
       if (auto name = selector.getIdentifierInfoForSlot(slotIndex))
         OS << name->getName();
 
@@ -359,12 +355,12 @@
     OS << '\01';
   }
   OS << (MD->isInstanceMethod() ? '-' : '+') << '[';
-  if (const auto *CID = MD->getCategory()) {
+  if (auto const *CID = MD->getCategory()) {
     OS << CID->getClassInterface()->getName();
     if (includeCategoryNamespace) {
       OS << '(' << *CID << ')';
     }
-  } else if (const auto *CD =
+  } else if (auto const *CD =
                  dyn_cast<ObjCContainerDecl>(MD->getDeclContext())) {
     OS << CD->getName();
   } else {
@@ -375,7 +371,7 @@
   OS << ']';
 }
 
-void MangleContext::mangleObjCMethodNameAsSourceName(const ObjCMethodDecl *MD,
+void MangleContext::mangleObjCMethodNameAsSourceName(ObjCMethodDecl const *MD,
                                                      raw_ostream &Out) {
   SmallString<64> Name;
   llvm::raw_svector_ostream OS(Name);
@@ -394,7 +390,7 @@
       : MC(Ctx.createMangleContext()),
         DL(Ctx.getTargetInfo().getDataLayoutString()) {}
 
-  bool writeName(const Decl *D, raw_ostream &OS) {
+  bool writeName(Decl const *D, raw_ostream &OS) {
     // First apply frontend mangling.
     SmallString<128> FrontendBuf;
     llvm::raw_svector_ostream FrontendBufOS(FrontendBuf);
@@ -421,7 +417,7 @@
     return false;
   }
 
-  std::string getName(const Decl *D) {
+  std::string getName(Decl const *D) {
     std::string Name;
     {
       llvm::raw_string_ostream OS(Name);
@@ -436,17 +432,17 @@
   };
 
   static StringRef getClassSymbolPrefix(ObjCKind Kind,
-                                        const ASTContext &Context) {
+                                        ASTContext const &Context) {
     if (Context.getLangOpts().ObjCRuntime.isGNUFamily())
       return Kind == ObjCMetaclass ? "_OBJC_METACLASS_" : "_OBJC_CLASS_";
     return Kind == ObjCMetaclass ? "OBJC_METACLASS_$_" : "OBJC_CLASS_$_";
   }
 
-  std::vector<std::string> getAllManglings(const ObjCContainerDecl *OCD) {
+  std::vector<std::string> getAllManglings(ObjCContainerDecl const *OCD) {
     StringRef ClassName;
-    if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
+    if (auto const *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
       ClassName = OID->getObjCRuntimeNameAsString();
-    else if (const auto *OID = dyn_cast<ObjCImplementationDecl>(OCD))
+    else if (auto const *OID = dyn_cast<ObjCImplementationDecl>(OCD))
       ClassName = OID->getObjCRuntimeNameAsString();
 
     if (ClassName.empty())
@@ -465,28 +461,28 @@
     };
   }
 
-  std::vector<std::string> getAllManglings(const Decl *D) {
-    if (const auto *OCD = dyn_cast<ObjCContainerDecl>(D))
+  std::vector<std::string> getAllManglings(Decl const *D) {
+    if (auto const *OCD = dyn_cast<ObjCContainerDecl>(D))
       return getAllManglings(OCD);
 
     if (!(isa<CXXRecordDecl>(D) || isa<CXXMethodDecl>(D)))
       return {};
 
-    const NamedDecl *ND = cast<NamedDecl>(D);
+    NamedDecl const *ND = cast<NamedDecl>(D);
 
     ASTContext &Ctx = ND->getASTContext();
     std::unique_ptr<MangleContext> M(Ctx.createMangleContext());
 
     std::vector<std::string> Manglings;
 
-    auto hasDefaultCXXMethodCC = [](ASTContext &C, const CXXMethodDecl *MD) {
+    auto hasDefaultCXXMethodCC = [](ASTContext &C, CXXMethodDecl const *MD) {
       auto DefaultCC = C.getDefaultCallingConvention(/*IsVariadic=*/false,
                                                      /*IsCXXMethod=*/true);
       auto CC = MD->getType()->castAs<FunctionProtoType>()->getCallConv();
       return CC == DefaultCC;
     };
 
-    if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND)) {
+    if (auto const *CD = dyn_cast_or_null<CXXConstructorDecl>(ND)) {
       Manglings.emplace_back(getMangledStructor(CD, Ctor_Base));
 
       if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily())
@@ -497,18 +493,18 @@
         if (CD->hasAttr<DLLExportAttr>() && CD->isDefaultConstructor())
           if (!(hasDefaultCXXMethodCC(Ctx, CD) && CD->getNumParams() == 0))
             Manglings.emplace_back(getMangledStructor(CD, Ctor_DefaultClosure));
-    } else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND)) {
+    } else if (auto const *DD = dyn_cast_or_null<CXXDestructorDecl>(ND)) {
       Manglings.emplace_back(getMangledStructor(DD, Dtor_Base));
       if (Ctx.getTargetInfo().getCXXABI().isItaniumFamily()) {
         Manglings.emplace_back(getMangledStructor(DD, Dtor_Complete));
         if (DD->isVirtual())
           Manglings.emplace_back(getMangledStructor(DD, Dtor_Deleting));
       }
-    } else if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(ND)) {
+    } else if (auto const *MD = dyn_cast_or_null<CXXMethodDecl>(ND)) {
       Manglings.emplace_back(getName(ND));
       if (MD->isVirtual())
-        if (const auto *TIV = Ctx.getVTableContext()->getThunkInfo(MD))
-          for (const auto &T : *TIV)
+        if (auto const *TIV = Ctx.getVTableContext()->getThunkInfo(MD))
+          for (auto const &T : *TIV)
             Manglings.emplace_back(getMangledThunk(MD, T));
     }
 
@@ -516,12 +512,12 @@
   }
 
 private:
-  bool writeFuncOrVarName(const NamedDecl *D, raw_ostream &OS) {
+  bool writeFuncOrVarName(NamedDecl const *D, raw_ostream &OS) {
     if (MC->shouldMangleDeclName(D)) {
       GlobalDecl GD;
-      if (const auto *CtorD = dyn_cast<CXXConstructorDecl>(D))
+      if (auto const *CtorD = dyn_cast<CXXConstructorDecl>(D))
         GD = GlobalDecl(CtorD, Ctor_Complete);
-      else if (const auto *DtorD = dyn_cast<CXXDestructorDecl>(D))
+      else if (auto const *DtorD = dyn_cast<CXXDestructorDecl>(D))
         GD = GlobalDecl(DtorD, Dtor_Complete);
       else if (D->hasAttr<CUDAGlobalAttr>())
         GD = GlobalDecl(cast<FunctionDecl>(D));
@@ -538,19 +534,19 @@
     }
   }
 
-  void writeObjCClassName(const ObjCInterfaceDecl *D, raw_ostream &OS) {
+  void writeObjCClassName(ObjCInterfaceDecl const *D, raw_ostream &OS) {
     OS << getClassSymbolPrefix(ObjCClass, D->getASTContext());
     OS << D->getObjCRuntimeNameAsString();
   }
 
-  std::string getMangledStructor(const NamedDecl *ND, unsigned StructorType) {
+  std::string getMangledStructor(NamedDecl const *ND, unsigned StructorType) {
     std::string FrontendBuf;
     llvm::raw_string_ostream FOS(FrontendBuf);
 
     GlobalDecl GD;
-    if (const auto *CD = dyn_cast_or_null<CXXConstructorDecl>(ND))
+    if (auto const *CD = dyn_cast_or_null<CXXConstructorDecl>(ND))
       GD = GlobalDecl(CD, static_cast<CXXCtorType>(StructorType));
-    else if (const auto *DD = dyn_cast_or_null<CXXDestructorDecl>(ND))
+    else if (auto const *DD = dyn_cast_or_null<CXXDestructorDecl>(ND))
       GD = GlobalDecl(DD, static_cast<CXXDtorType>(StructorType));
     MC->mangleName(GD, FOS);
 
@@ -562,7 +558,7 @@
     return BOS.str();
   }
 
-  std::string getMangledThunk(const CXXMethodDecl *MD, const ThunkInfo &T) {
+  std::string getMangledThunk(CXXMethodDecl const *MD, ThunkInfo const &T) {
     std::string FrontendBuf;
     llvm::raw_string_ostream FOS(FrontendBuf);
 
@@ -582,14 +578,14 @@
 
 ASTNameGenerator::~ASTNameGenerator() {}
 
-bool ASTNameGenerator::writeName(const Decl *D, raw_ostream &OS) {
+bool ASTNameGenerator::writeName(Decl const *D, raw_ostream &OS) {
   return Impl->writeName(D, OS);
 }
 
-std::string ASTNameGenerator::getName(const Decl *D) {
+std::string ASTNameGenerator::getName(Decl const *D) {
   return Impl->getName(D);
 }
 
-std::vector<std::string> ASTNameGenerator::getAllManglings(const Decl *D) {
+std::vector<std::string> ASTNameGenerator::getAllManglings(Decl const *D) {
   return Impl->getAllManglings(D);
 }
Index: clang/lib/AST/MicrosoftCXXABI.cpp
===================================================================
--- clang/lib/AST/MicrosoftCXXABI.cpp
+++ clang/lib/AST/MicrosoftCXXABI.cpp
@@ -29,37 +29,37 @@
 /// Numbers things which need to correspond across multiple TUs.
 /// Typically these are things like static locals, lambdas, or blocks.
 class MicrosoftNumberingContext : public MangleNumberingContext {
-  llvm::DenseMap<const Type *, unsigned> ManglingNumbers;
+  llvm::DenseMap<Type const *, unsigned> ManglingNumbers;
   unsigned LambdaManglingNumber;
   unsigned StaticLocalNumber;
   unsigned StaticThreadlocalNumber;
 
 public:
   MicrosoftNumberingContext()
-      : MangleNumberingContext(), LambdaManglingNumber(0),
-        StaticLocalNumber(0), StaticThreadlocalNumber(0) {}
+      : MangleNumberingContext(), LambdaManglingNumber(0), StaticLocalNumber(0),
+        StaticThreadlocalNumber(0) {}
 
-  unsigned getManglingNumber(const CXXMethodDecl *CallOperator) override {
+  unsigned getManglingNumber(CXXMethodDecl const *CallOperator) override {
     return ++LambdaManglingNumber;
   }
 
-  unsigned getManglingNumber(const BlockDecl *BD) override {
-    const Type *Ty = nullptr;
+  unsigned getManglingNumber(BlockDecl const *BD) override {
+    Type const *Ty = nullptr;
     return ++ManglingNumbers[Ty];
   }
 
-  unsigned getStaticLocalNumber(const VarDecl *VD) override {
+  unsigned getStaticLocalNumber(VarDecl const *VD) override {
     if (VD->getTLSKind())
       return ++StaticThreadlocalNumber;
     return ++StaticLocalNumber;
   }
 
-  unsigned getManglingNumber(const VarDecl *VD,
+  unsigned getManglingNumber(VarDecl const *VD,
                              unsigned MSLocalManglingNumber) override {
     return MSLocalManglingNumber;
   }
 
-  unsigned getManglingNumber(const TagDecl *TD,
+  unsigned getManglingNumber(TagDecl const *TD,
                              unsigned MSLocalManglingNumber) override {
     return MSLocalManglingNumber;
   }
@@ -73,7 +73,7 @@
     DeviceCtx = createItaniumNumberingContext(DeviceMangler);
   }
 
-  unsigned getDeviceManglingNumber(const CXXMethodDecl *CallOperator) override {
+  unsigned getDeviceManglingNumber(CXXMethodDecl const *CallOperator) override {
     return DeviceCtx->getManglingNumber(CallOperator);
   }
 };
@@ -103,7 +103,7 @@
   }
 
   MemberPointerInfo
-  getMemberPointerInfo(const MemberPointerType *MPT) const override;
+  getMemberPointerInfo(MemberPointerType const *MPT) const override;
 
   CallingConv getDefaultMethodCallConv(bool isVariadic) const override {
     if (!isVariadic &&
@@ -112,18 +112,17 @@
     return Context.getTargetInfo().getDefaultCallingConv();
   }
 
-  bool isNearlyEmpty(const CXXRecordDecl *RD) const override {
+  bool isNearlyEmpty(CXXRecordDecl const *RD) const override {
     llvm_unreachable("unapplicable to the MS ABI");
   }
 
-  const CXXConstructorDecl *
+  CXXConstructorDecl const *
   getCopyConstructorForExceptionObject(CXXRecordDecl *RD) override {
     return RecordToCopyCtor[RD];
   }
 
-  void
-  addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
-                                       CXXConstructorDecl *CD) override {
+  void addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
+                                            CXXConstructorDecl *CD) override {
     assert(CD != nullptr);
     assert(RecordToCopyCtor[RD] == nullptr || RecordToCopyCtor[RD] == CD);
     RecordToCopyCtor[RD] = CD;
@@ -138,7 +137,7 @@
       I = DD;
   }
 
-  TypedefNameDecl *getTypedefNameForUnnamedTagDecl(const TagDecl *TD) override {
+  TypedefNameDecl *getTypedefNameForUnnamedTagDecl(TagDecl const *TD) override {
     return UnnamedTagDeclToTypedefNameDecl.lookup(
         const_cast<TagDecl *>(TD->getCanonicalDecl()));
   }
@@ -152,7 +151,7 @@
       I = DD;
   }
 
-  DeclaratorDecl *getDeclaratorForUnnamedTagDecl(const TagDecl *TD) override {
+  DeclaratorDecl *getDeclaratorForUnnamedTagDecl(TagDecl const *TD) override {
     return UnnamedTagDeclToDeclaratorDecl.lookup(
         const_cast<TagDecl *>(TD->getCanonicalDecl()));
   }
@@ -166,17 +165,17 @@
     return std::make_unique<MicrosoftNumberingContext>();
   }
 };
-}
+} // namespace
 
 // getNumBases() seems to only give us the number of direct bases, and not the
 // total.  This function tells us if we inherit from anybody that uses MI, or if
 // we have a non-primary base class, which uses the multiple inheritance model.
-static bool usesMultipleInheritanceModel(const CXXRecordDecl *RD) {
+static bool usesMultipleInheritanceModel(CXXRecordDecl const *RD) {
   while (RD->getNumBases() > 0) {
     if (RD->getNumBases() > 1)
       return true;
     assert(RD->getNumBases() == 1);
-    const CXXRecordDecl *Base =
+    CXXRecordDecl const *Base =
         RD->bases_begin()->getType()->getAsCXXRecordDecl();
     if (RD->isPolymorphic() && !Base->isPolymorphic())
       return true;
@@ -243,8 +242,8 @@
 //     int VirtualBaseAdjustmentOffset;
 //   };
 static std::pair<unsigned, unsigned>
-getMSMemberPointerSlots(const MemberPointerType *MPT) {
-  const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
+getMSMemberPointerSlots(MemberPointerType const *MPT) {
+  CXXRecordDecl const *RD = MPT->getMostRecentCXXRecordDecl();
   MSInheritanceModel Inheritance = RD->getMSInheritanceModel();
   unsigned Ptrs = 0;
   unsigned Ints = 0;
@@ -253,7 +252,7 @@
   else
     Ints = 1;
   if (inheritanceModelHasNVOffsetField(MPT->isMemberFunctionPointer(),
-                                          Inheritance))
+                                       Inheritance))
     Ints++;
   if (inheritanceModelHasVBPtrOffsetField(Inheritance))
     Ints++;
@@ -262,11 +261,11 @@
   return std::make_pair(Ptrs, Ints);
 }
 
-CXXABI::MemberPointerInfo MicrosoftCXXABI::getMemberPointerInfo(
-    const MemberPointerType *MPT) const {
+CXXABI::MemberPointerInfo
+MicrosoftCXXABI::getMemberPointerInfo(MemberPointerType const *MPT) const {
   // The nominal struct is laid out with pointers followed by ints and aligned
   // to a pointer width if any are present and an int width otherwise.
-  const TargetInfo &Target = Context.getTargetInfo();
+  TargetInfo const &Target = Context.getTargetInfo();
   unsigned PtrSize = Target.getPointerWidth(0);
   unsigned IntSize = Target.getIntWidth();
 
Index: clang/lib/AST/MicrosoftMangle.cpp
===================================================================
--- clang/lib/AST/MicrosoftMangle.cpp
+++ clang/lib/AST/MicrosoftMangle.cpp
@@ -69,11 +69,10 @@
   }
 };
 
-static const DeclContext *
-getLambdaDefaultArgumentDeclContext(const Decl *D) {
-  if (const auto *RD = dyn_cast<CXXRecordDecl>(D))
+static DeclContext const *getLambdaDefaultArgumentDeclContext(Decl const *D) {
+  if (auto const *RD = dyn_cast<CXXRecordDecl>(D))
     if (RD->isLambda())
-      if (const auto *Parm =
+      if (auto const *Parm =
               dyn_cast_or_null<ParmVarDecl>(RD->getLambdaContextDecl()))
         return Parm->getDeclContext();
   return nullptr;
@@ -81,24 +80,24 @@
 
 /// Retrieve the declaration context that should be used when mangling
 /// the given declaration.
-static const DeclContext *getEffectiveDeclContext(const Decl *D) {
+static DeclContext const *getEffectiveDeclContext(Decl const *D) {
   // The ABI assumes that lambda closure types that occur within
   // default arguments live in the context of the function. However, due to
   // the way in which Clang parses and creates function declarations, this is
   // not the case: the lambda closure type ends up living in the context
   // where the function itself resides, because the function declaration itself
   // had not yet been created. Fix the context here.
-  if (const auto *LDADC = getLambdaDefaultArgumentDeclContext(D))
+  if (auto const *LDADC = getLambdaDefaultArgumentDeclContext(D))
     return LDADC;
 
   // Perform the same check for block literals.
-  if (const BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
+  if (BlockDecl const *BD = dyn_cast<BlockDecl>(D)) {
     if (ParmVarDecl *ContextParam =
             dyn_cast_or_null<ParmVarDecl>(BD->getBlockManglingContextDecl()))
       return ContextParam->getDeclContext();
   }
 
-  const DeclContext *DC = D->getDeclContext();
+  DeclContext const *DC = D->getDeclContext();
   if (isa<CapturedDecl>(DC) || isa<OMPDeclareReductionDecl>(DC) ||
       isa<OMPDeclareMapperDecl>(DC)) {
     return getEffectiveDeclContext(cast<Decl>(DC));
@@ -107,16 +106,16 @@
   return DC->getRedeclContext();
 }
 
-static const DeclContext *getEffectiveParentContext(const DeclContext *DC) {
+static DeclContext const *getEffectiveParentContext(DeclContext const *DC) {
   return getEffectiveDeclContext(cast<Decl>(DC));
 }
 
-static const FunctionDecl *getStructor(const NamedDecl *ND) {
-  if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(ND))
+static FunctionDecl const *getStructor(NamedDecl const *ND) {
+  if (auto const *FTD = dyn_cast<FunctionTemplateDecl>(ND))
     return FTD->getTemplatedDecl()->getCanonicalDecl();
 
-  const auto *FD = cast<FunctionDecl>(ND);
-  if (const auto *FTD = FD->getPrimaryTemplate())
+  auto const *FD = cast<FunctionDecl>(ND);
+  if (auto const *FTD = FD->getPrimaryTemplate())
     return FTD->getTemplatedDecl()->getCanonicalDecl();
 
   return FD->getCanonicalDecl();
@@ -125,81 +124,81 @@
 /// MicrosoftMangleContextImpl - Overrides the default MangleContext for the
 /// Microsoft Visual C++ ABI.
 class MicrosoftMangleContextImpl : public MicrosoftMangleContext {
-  typedef std::pair<const DeclContext *, IdentifierInfo *> DiscriminatorKeyTy;
+  typedef std::pair<DeclContext const *, IdentifierInfo *> DiscriminatorKeyTy;
   llvm::DenseMap<DiscriminatorKeyTy, unsigned> Discriminator;
-  llvm::DenseMap<const NamedDecl *, unsigned> Uniquifier;
-  llvm::DenseMap<const CXXRecordDecl *, unsigned> LambdaIds;
-  llvm::DenseMap<const NamedDecl *, unsigned> SEHFilterIds;
-  llvm::DenseMap<const NamedDecl *, unsigned> SEHFinallyIds;
+  llvm::DenseMap<NamedDecl const *, unsigned> Uniquifier;
+  llvm::DenseMap<CXXRecordDecl const *, unsigned> LambdaIds;
+  llvm::DenseMap<NamedDecl const *, unsigned> SEHFilterIds;
+  llvm::DenseMap<NamedDecl const *, unsigned> SEHFinallyIds;
   SmallString<16> AnonymousNamespaceHash;
 
 public:
   MicrosoftMangleContextImpl(ASTContext &Context, DiagnosticsEngine &Diags);
-  bool shouldMangleCXXName(const NamedDecl *D) override;
-  bool shouldMangleStringLiteral(const StringLiteral *SL) override;
+  bool shouldMangleCXXName(NamedDecl const *D) override;
+  bool shouldMangleStringLiteral(StringLiteral const *SL) override;
   void mangleCXXName(GlobalDecl GD, raw_ostream &Out) override;
-  void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
-                                const MethodVFTableLocation &ML,
+  void mangleVirtualMemPtrThunk(CXXMethodDecl const *MD,
+                                MethodVFTableLocation const &ML,
                                 raw_ostream &Out) override;
-  void mangleThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk,
+  void mangleThunk(CXXMethodDecl const *MD, ThunkInfo const &Thunk,
                    raw_ostream &) override;
-  void mangleCXXDtorThunk(const CXXDestructorDecl *DD, CXXDtorType Type,
-                          const ThisAdjustment &ThisAdjustment,
+  void mangleCXXDtorThunk(CXXDestructorDecl const *DD, CXXDtorType Type,
+                          ThisAdjustment const &ThisAdjustment,
                           raw_ostream &) override;
-  void mangleCXXVFTable(const CXXRecordDecl *Derived,
-                        ArrayRef<const CXXRecordDecl *> BasePath,
+  void mangleCXXVFTable(CXXRecordDecl const *Derived,
+                        ArrayRef<CXXRecordDecl const *> BasePath,
                         raw_ostream &Out) override;
-  void mangleCXXVBTable(const CXXRecordDecl *Derived,
-                        ArrayRef<const CXXRecordDecl *> BasePath,
+  void mangleCXXVBTable(CXXRecordDecl const *Derived,
+                        ArrayRef<CXXRecordDecl const *> BasePath,
                         raw_ostream &Out) override;
-  void mangleCXXVirtualDisplacementMap(const CXXRecordDecl *SrcRD,
-                                       const CXXRecordDecl *DstRD,
+  void mangleCXXVirtualDisplacementMap(CXXRecordDecl const *SrcRD,
+                                       CXXRecordDecl const *DstRD,
                                        raw_ostream &Out) override;
   void mangleCXXThrowInfo(QualType T, bool IsConst, bool IsVolatile,
                           bool IsUnaligned, uint32_t NumEntries,
                           raw_ostream &Out) override;
   void mangleCXXCatchableTypeArray(QualType T, uint32_t NumEntries,
                                    raw_ostream &Out) override;
-  void mangleCXXCatchableType(QualType T, const CXXConstructorDecl *CD,
+  void mangleCXXCatchableType(QualType T, CXXConstructorDecl const *CD,
                               CXXCtorType CT, uint32_t Size, uint32_t NVOffset,
                               int32_t VBPtrOffset, uint32_t VBIndex,
                               raw_ostream &Out) override;
   void mangleCXXRTTI(QualType T, raw_ostream &Out) override;
   void mangleCXXRTTIName(QualType T, raw_ostream &Out) override;
-  void mangleCXXRTTIBaseClassDescriptor(const CXXRecordDecl *Derived,
+  void mangleCXXRTTIBaseClassDescriptor(CXXRecordDecl const *Derived,
                                         uint32_t NVOffset, int32_t VBPtrOffset,
                                         uint32_t VBTableOffset, uint32_t Flags,
                                         raw_ostream &Out) override;
-  void mangleCXXRTTIBaseClassArray(const CXXRecordDecl *Derived,
+  void mangleCXXRTTIBaseClassArray(CXXRecordDecl const *Derived,
                                    raw_ostream &Out) override;
-  void mangleCXXRTTIClassHierarchyDescriptor(const CXXRecordDecl *Derived,
+  void mangleCXXRTTIClassHierarchyDescriptor(CXXRecordDecl const *Derived,
                                              raw_ostream &Out) override;
   void
-  mangleCXXRTTICompleteObjectLocator(const CXXRecordDecl *Derived,
-                                     ArrayRef<const CXXRecordDecl *> BasePath,
+  mangleCXXRTTICompleteObjectLocator(CXXRecordDecl const *Derived,
+                                     ArrayRef<CXXRecordDecl const *> BasePath,
                                      raw_ostream &Out) override;
   void mangleTypeName(QualType T, raw_ostream &) override;
-  void mangleReferenceTemporary(const VarDecl *, unsigned ManglingNumber,
+  void mangleReferenceTemporary(VarDecl const *, unsigned ManglingNumber,
                                 raw_ostream &) override;
-  void mangleStaticGuardVariable(const VarDecl *D, raw_ostream &Out) override;
-  void mangleThreadSafeStaticGuardVariable(const VarDecl *D, unsigned GuardNum,
+  void mangleStaticGuardVariable(VarDecl const *D, raw_ostream &Out) override;
+  void mangleThreadSafeStaticGuardVariable(VarDecl const *D, unsigned GuardNum,
                                            raw_ostream &Out) override;
-  void mangleDynamicInitializer(const VarDecl *D, raw_ostream &Out) override;
-  void mangleDynamicAtExitDestructor(const VarDecl *D,
+  void mangleDynamicInitializer(VarDecl const *D, raw_ostream &Out) override;
+  void mangleDynamicAtExitDestructor(VarDecl const *D,
                                      raw_ostream &Out) override;
-  void mangleSEHFilterExpression(const NamedDecl *EnclosingDecl,
+  void mangleSEHFilterExpression(NamedDecl const *EnclosingDecl,
                                  raw_ostream &Out) override;
-  void mangleSEHFinallyBlock(const NamedDecl *EnclosingDecl,
+  void mangleSEHFinallyBlock(NamedDecl const *EnclosingDecl,
                              raw_ostream &Out) override;
-  void mangleStringLiteral(const StringLiteral *SL, raw_ostream &Out) override;
-  bool getNextDiscriminator(const NamedDecl *ND, unsigned &disc) {
-    const DeclContext *DC = getEffectiveDeclContext(ND);
+  void mangleStringLiteral(StringLiteral const *SL, raw_ostream &Out) override;
+  bool getNextDiscriminator(NamedDecl const *ND, unsigned &disc) {
+    DeclContext const *DC = getEffectiveDeclContext(ND);
     if (!DC->isFunctionOrMethod())
       return false;
 
     // Lambda closure types are already numbered, give out a phony number so
     // that they demangle nicely.
-    if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
+    if (auto const *RD = dyn_cast<CXXRecordDecl>(ND)) {
       if (RD->isLambda()) {
         disc = 1;
         return true;
@@ -213,7 +212,7 @@
     }
 
     // Anonymous tags are already numbered.
-    if (const TagDecl *Tag = dyn_cast<TagDecl>(ND)) {
+    if (TagDecl const *Tag = dyn_cast<TagDecl>(ND)) {
       if (!Tag->hasNameForLinkage() &&
           !getASTContext().getDeclaratorForUnnamedTagDecl(Tag) &&
           !getASTContext().getTypedefNameForUnnamedTagDecl(Tag))
@@ -228,15 +227,15 @@
     return true;
   }
 
-  std::string getLambdaString(const CXXRecordDecl *Lambda) override {
+  std::string getLambdaString(CXXRecordDecl const *Lambda) override {
     assert(Lambda->isLambda() && "RD must be a lambda!");
     std::string Name("<lambda_");
 
     Decl *LambdaContextDecl = Lambda->getLambdaContextDecl();
     unsigned LambdaManglingNumber = Lambda->getLambdaManglingNumber();
     unsigned LambdaId;
-    const ParmVarDecl *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
-    const FunctionDecl *Func =
+    ParmVarDecl const *Parm = dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
+    FunctionDecl const *Func =
         Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr;
 
     if (Func) {
@@ -256,22 +255,22 @@
     return Name;
   }
 
-  unsigned getLambdaId(const CXXRecordDecl *RD) {
+  unsigned getLambdaId(CXXRecordDecl const *RD) {
     assert(RD->isLambda() && "RD must be a lambda!");
     assert(!RD->isExternallyVisible() && "RD must not be visible!");
     assert(RD->getLambdaManglingNumber() == 0 &&
            "RD must not have a mangling number!");
-    std::pair<llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator, bool>
+    std::pair<llvm::DenseMap<CXXRecordDecl const *, unsigned>::iterator, bool>
         Result = LambdaIds.insert(std::make_pair(RD, LambdaIds.size()));
     return Result.first->second;
   }
 
-  unsigned getLambdaIdForDebugInfo(const CXXRecordDecl *RD) {
+  unsigned getLambdaIdForDebugInfo(CXXRecordDecl const *RD) {
     assert(RD->isLambda() && "RD must be a lambda!");
     assert(!RD->isExternallyVisible() && "RD must not be visible!");
     assert(RD->getLambdaManglingNumber() == 0 &&
            "RD must not have a mangling number!");
-    llvm::DenseMap<const CXXRecordDecl *, unsigned>::iterator Result =
+    llvm::DenseMap<CXXRecordDecl const *, unsigned>::iterator Result =
         LambdaIds.find(RD);
     // The lambda should exist, but return 0 in case it doesn't.
     if (Result == LambdaIds.end())
@@ -281,12 +280,10 @@
 
   /// Return a character sequence that is (somewhat) unique to the TU suitable
   /// for mangling anonymous namespaces.
-  StringRef getAnonymousNamespaceHash() const {
-    return AnonymousNamespaceHash;
-  }
+  StringRef getAnonymousNamespaceHash() const { return AnonymousNamespaceHash; }
 
 private:
-  void mangleInitFiniStub(const VarDecl *D, char CharCode, raw_ostream &Out);
+  void mangleInitFiniStub(VarDecl const *D, char CharCode, raw_ostream &Out);
 };
 
 /// MicrosoftCXXNameMangler - Manage the mangling of a single name for the
@@ -298,17 +295,17 @@
   /// The "structor" is the top-level declaration being mangled, if
   /// that's not a template specialization; otherwise it's the pattern
   /// for that specialization.
-  const NamedDecl *Structor;
+  NamedDecl const *Structor;
   unsigned StructorType;
 
   typedef llvm::SmallVector<std::string, 10> BackRefVec;
   BackRefVec NameBackReferences;
 
-  typedef llvm::DenseMap<const void *, unsigned> ArgBackRefMap;
+  typedef llvm::DenseMap<void const *, unsigned> ArgBackRefMap;
   ArgBackRefMap FunArgBackReferences;
   ArgBackRefMap TemplateArgBackReferences;
 
-  typedef llvm::DenseMap<const void *, StringRef> TemplateArgStringMap;
+  typedef llvm::DenseMap<void const *, StringRef> TemplateArgStringMap;
   TemplateArgStringMap TemplateArgStrings;
   llvm::StringSaver TemplateArgStringStorage;
   llvm::BumpPtrAllocator TemplateArgStringStorageAlloc;
@@ -318,7 +315,7 @@
 
   ASTContext &getASTContext() const { return Context.getASTContext(); }
 
-  const bool PointersAre64Bit;
+  bool const PointersAre64Bit;
 
 public:
   enum QualifierMangleMode { QMM_Drop, QMM_Mangle, QMM_Escape, QMM_Result };
@@ -330,14 +327,14 @@
                          64) {}
 
   MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
-                          const CXXConstructorDecl *D, CXXCtorType Type)
+                          CXXConstructorDecl const *D, CXXCtorType Type)
       : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
         TemplateArgStringStorage(TemplateArgStringStorageAlloc),
         PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
                          64) {}
 
   MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
-                          const CXXDestructorDecl *D, CXXDtorType Type)
+                          CXXDestructorDecl const *D, CXXDtorType Type)
       : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
         TemplateArgStringStorage(TemplateArgStringStorageAlloc),
         PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
@@ -345,35 +342,35 @@
 
   raw_ostream &getStream() const { return Out; }
 
-  void mangle(const NamedDecl *D, StringRef Prefix = "?");
-  void mangleName(const NamedDecl *ND);
-  void mangleFunctionEncoding(const FunctionDecl *FD, bool ShouldMangle);
-  void mangleVariableEncoding(const VarDecl *VD);
-  void mangleMemberDataPointer(const CXXRecordDecl *RD, const ValueDecl *VD,
+  void mangle(NamedDecl const *D, StringRef Prefix = "?");
+  void mangleName(NamedDecl const *ND);
+  void mangleFunctionEncoding(FunctionDecl const *FD, bool ShouldMangle);
+  void mangleVariableEncoding(VarDecl const *VD);
+  void mangleMemberDataPointer(CXXRecordDecl const *RD, ValueDecl const *VD,
                                StringRef Prefix = "$");
-  void mangleMemberFunctionPointer(const CXXRecordDecl *RD,
-                                   const CXXMethodDecl *MD,
+  void mangleMemberFunctionPointer(CXXRecordDecl const *RD,
+                                   CXXMethodDecl const *MD,
                                    StringRef Prefix = "$");
-  void mangleVirtualMemPtrThunk(const CXXMethodDecl *MD,
-                                const MethodVFTableLocation &ML);
+  void mangleVirtualMemPtrThunk(CXXMethodDecl const *MD,
+                                MethodVFTableLocation const &ML);
   void mangleNumber(int64_t Number);
   void mangleNumber(llvm::APSInt Number);
   void mangleFloat(llvm::APFloat Number);
   void mangleBits(llvm::APInt Number);
   void mangleTagTypeKind(TagTypeKind TK);
   void mangleArtificialTagType(TagTypeKind TK, StringRef UnqualifiedName,
-                              ArrayRef<StringRef> NestedNames = None);
+                               ArrayRef<StringRef> NestedNames = None);
   void mangleAddressSpaceType(QualType T, Qualifiers Quals, SourceRange Range);
   void mangleType(QualType T, SourceRange Range,
                   QualifierMangleMode QMM = QMM_Mangle);
-  void mangleFunctionType(const FunctionType *T,
-                          const FunctionDecl *D = nullptr,
+  void mangleFunctionType(FunctionType const *T,
+                          FunctionDecl const *D = nullptr,
                           bool ForceThisQuals = false,
                           bool MangleExceptionSpec = true);
-  void mangleNestedName(const NamedDecl *ND);
+  void mangleNestedName(NamedDecl const *ND);
 
 private:
-  bool isStructorDecl(const NamedDecl *ND) const {
+  bool isStructorDecl(NamedDecl const *ND) const {
     return ND == Structor || getStructor(ND) == Structor;
   }
 
@@ -384,10 +381,10 @@
                                   AddrSpace == LangAS::ptr32_uptr));
   }
 
-  void mangleUnqualifiedName(const NamedDecl *ND) {
+  void mangleUnqualifiedName(NamedDecl const *ND) {
     mangleUnqualifiedName(ND, ND->getDeclName());
   }
-  void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name);
+  void mangleUnqualifiedName(NamedDecl const *ND, DeclarationName Name);
   void mangleSourceName(StringRef Name);
   void mangleOperatorName(OverloadedOperatorKind OO, SourceLocation Loc);
   void mangleCXXDtorType(CXXDtorType T);
@@ -396,54 +393,53 @@
   void manglePointerCVQualifiers(Qualifiers Quals);
   void manglePointerExtQualifiers(Qualifiers Quals, QualType PointeeType);
 
-  void mangleUnscopedTemplateName(const TemplateDecl *ND);
+  void mangleUnscopedTemplateName(TemplateDecl const *ND);
   void
-  mangleTemplateInstantiationName(const TemplateDecl *TD,
-                                  const TemplateArgumentList &TemplateArgs);
-  void mangleObjCMethodName(const ObjCMethodDecl *MD);
+  mangleTemplateInstantiationName(TemplateDecl const *TD,
+                                  TemplateArgumentList const &TemplateArgs);
+  void mangleObjCMethodName(ObjCMethodDecl const *MD);
 
   void mangleFunctionArgumentType(QualType T, SourceRange Range);
-  void manglePassObjectSizeArg(const PassObjectSizeAttr *POSA);
+  void manglePassObjectSizeArg(PassObjectSizeAttr const *POSA);
 
   bool isArtificialTagType(QualType T) const;
 
   // Declare manglers for every type class.
 #define ABSTRACT_TYPE(CLASS, PARENT)
 #define NON_CANONICAL_TYPE(CLASS, PARENT)
-#define TYPE(CLASS, PARENT) void mangleType(const CLASS##Type *T, \
-                                            Qualifiers Quals, \
-                                            SourceRange Range);
+#define TYPE(CLASS, PARENT)                                                    \
+  void mangleType(const CLASS##Type *T, Qualifiers Quals, SourceRange Range);
 #include "clang/AST/TypeNodes.inc"
 #undef ABSTRACT_TYPE
 #undef NON_CANONICAL_TYPE
 #undef TYPE
 
-  void mangleType(const TagDecl *TD);
-  void mangleDecayedArrayType(const ArrayType *T);
-  void mangleArrayType(const ArrayType *T);
-  void mangleFunctionClass(const FunctionDecl *FD);
+  void mangleType(TagDecl const *TD);
+  void mangleDecayedArrayType(ArrayType const *T);
+  void mangleArrayType(ArrayType const *T);
+  void mangleFunctionClass(FunctionDecl const *FD);
   void mangleCallingConvention(CallingConv CC);
-  void mangleCallingConvention(const FunctionType *T);
-  void mangleIntegerLiteral(const llvm::APSInt &Number,
-                            const NonTypeTemplateParmDecl *PD = nullptr,
+  void mangleCallingConvention(FunctionType const *T);
+  void mangleIntegerLiteral(llvm::APSInt const &Number,
+                            NonTypeTemplateParmDecl const *PD = nullptr,
                             QualType TemplateArgType = QualType());
-  void mangleExpression(const Expr *E, const NonTypeTemplateParmDecl *PD);
-  void mangleThrowSpecification(const FunctionProtoType *T);
-
-  void mangleTemplateArgs(const TemplateDecl *TD,
-                          const TemplateArgumentList &TemplateArgs);
-  void mangleTemplateArg(const TemplateDecl *TD, const TemplateArgument &TA,
-                         const NamedDecl *Parm);
-  void mangleTemplateArgValue(QualType T, const APValue &V,
+  void mangleExpression(Expr const *E, NonTypeTemplateParmDecl const *PD);
+  void mangleThrowSpecification(FunctionProtoType const *T);
+
+  void mangleTemplateArgs(TemplateDecl const *TD,
+                          TemplateArgumentList const &TemplateArgs);
+  void mangleTemplateArg(TemplateDecl const *TD, TemplateArgument const &TA,
+                         NamedDecl const *Parm);
+  void mangleTemplateArgValue(QualType T, APValue const &V,
                               bool WithScalarType = false);
 
-  void mangleObjCProtocol(const ObjCProtocolDecl *PD);
+  void mangleObjCProtocol(ObjCProtocolDecl const *PD);
   void mangleObjCLifetime(const QualType T, Qualifiers Quals,
                           SourceRange Range);
-  void mangleObjCKindOfType(const ObjCObjectType *T, Qualifiers Quals,
+  void mangleObjCKindOfType(ObjCObjectType const *T, Qualifiers Quals,
                             SourceRange Range);
 };
-}
+} // namespace
 
 MicrosoftMangleContextImpl::MicrosoftMangleContextImpl(ASTContext &Context,
                                                        DiagnosticsEngine &Diags)
@@ -463,7 +459,7 @@
   // The generated names are intended to look similar to what MSVC generates,
   // which are something like "?A0x01234567@".
   SourceManager &SM = Context.getSourceManager();
-  if (const FileEntry *FE = SM.getFileEntryForID(SM.getMainFileID())) {
+  if (FileEntry const *FE = SM.getFileEntryForID(SM.getMainFileID())) {
     // Truncate the hash so we get 8 characters of hexadecimal.
     uint32_t TruncatedHash = uint32_t(xxHash64(FE->getName()));
     AnonymousNamespaceHash = llvm::utohexstr(TruncatedHash);
@@ -473,8 +469,8 @@
   }
 }
 
-bool MicrosoftMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) {
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+bool MicrosoftMangleContextImpl::shouldMangleCXXName(NamedDecl const *D) {
+  if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(D)) {
     LanguageLinkage L = FD->getLanguageLinkage();
     // Overloadable functions need mangling.
     if (FD->hasAttr<OverloadableAttr>())
@@ -506,34 +502,33 @@
   if (!getASTContext().getLangOpts().CPlusPlus)
     return false;
 
-  const VarDecl *VD = dyn_cast<VarDecl>(D);
+  VarDecl const *VD = dyn_cast<VarDecl>(D);
   if (VD && !isa<DecompositionDecl>(D)) {
     // C variables are not mangled.
     if (VD->isExternC())
       return false;
 
     // Variables at global scope with internal linkage are not mangled.
-    const DeclContext *DC = getEffectiveDeclContext(D);
+    DeclContext const *DC = getEffectiveDeclContext(D);
     // Check for extern variable declared locally.
     if (DC->isFunctionOrMethod() && D->hasLinkage())
       while (!DC->isNamespace() && !DC->isTranslationUnit())
         DC = getEffectiveParentContext(DC);
 
     if (DC->isTranslationUnit() && D->getFormalLinkage() == InternalLinkage &&
-        !isa<VarTemplateSpecializationDecl>(D) &&
-        D->getIdentifier() != nullptr)
+        !isa<VarTemplateSpecializationDecl>(D) && D->getIdentifier() != nullptr)
       return false;
   }
 
   return true;
 }
 
-bool
-MicrosoftMangleContextImpl::shouldMangleStringLiteral(const StringLiteral *SL) {
+bool MicrosoftMangleContextImpl::shouldMangleStringLiteral(
+    StringLiteral const *SL) {
   return true;
 }
 
-void MicrosoftCXXNameMangler::mangle(const NamedDecl *D, StringRef Prefix) {
+void MicrosoftCXXNameMangler::mangle(NamedDecl const *D, StringRef Prefix) {
   // MSVC doesn't mangle C++ names the same way it mangles extern "C" names.
   // Therefore it's really important that we don't decorate the
   // name with leading underscores or leading/trailing at signs. So, by
@@ -543,9 +538,9 @@
   // <mangled-name> ::= ? <name> <type-encoding>
   Out << Prefix;
   mangleName(D);
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
+  if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(D))
     mangleFunctionEncoding(FD, Context.shouldMangleDeclName(FD));
-  else if (const VarDecl *VD = dyn_cast<VarDecl>(D))
+  else if (VarDecl const *VD = dyn_cast<VarDecl>(D))
     mangleVariableEncoding(VD);
   else if (isa<MSGuidDecl>(D))
     // MSVC appears to mangle GUIDs as if they were variables of type
@@ -558,7 +553,7 @@
     llvm_unreachable("Tried to mangle unexpected NamedDecl!");
 }
 
-void MicrosoftCXXNameMangler::mangleFunctionEncoding(const FunctionDecl *FD,
+void MicrosoftCXXNameMangler::mangleFunctionEncoding(FunctionDecl const *FD,
                                                      bool ShouldMangle) {
   // <type-encoding> ::= <function-class> <function-type>
 
@@ -569,7 +564,7 @@
 
   // We should never ever see a FunctionNoProtoType at this point.
   // We don't even know how to mangle their types anyway :).
-  const FunctionProtoType *FT = FD->getType()->castAs<FunctionProtoType>();
+  FunctionProtoType const *FT = FD->getType()->castAs<FunctionProtoType>();
 
   // extern "C" functions can hold entities that must be mangled.
   // As it stands, these functions still need to get expressed in the full
@@ -590,7 +585,7 @@
   }
 }
 
-void MicrosoftCXXNameMangler::mangleVariableEncoding(const VarDecl *VD) {
+void MicrosoftCXXNameMangler::mangleVariableEncoding(VarDecl const *VD) {
   // <type-encoding> ::= <storage-class> <variable-type>
   // <storage-class> ::= 0  # private static member
   //                 ::= 1  # protected static member
@@ -602,13 +597,18 @@
   if (VD->isStaticDataMember()) {
     // If it's a static member, it also encodes the access level.
     switch (VD->getAccess()) {
-      default:
-      case AS_private: Out << '0'; break;
-      case AS_protected: Out << '1'; break;
-      case AS_public: Out << '2'; break;
+    default:
+    case AS_private:
+      Out << '0';
+      break;
+    case AS_protected:
+      Out << '1';
+      break;
+    case AS_public:
+      Out << '2';
+      break;
     }
-  }
-  else if (!VD->isStaticLocal())
+  } else if (!VD->isStaticLocal())
     Out << '3';
   else
     Out << '4';
@@ -624,14 +624,14 @@
     mangleType(Ty, SR, QMM_Drop);
     manglePointerExtQualifiers(
         Ty.getDesugaredType(getASTContext()).getLocalQualifiers(), QualType());
-    if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) {
+    if (MemberPointerType const *MPT = Ty->getAs<MemberPointerType>()) {
       mangleQualifiers(MPT->getPointeeType().getQualifiers(), true);
       // Member pointers are suffixed with a back reference to the member
       // pointer's class name.
       mangleName(MPT->getClass()->getAsCXXRecordDecl());
     } else
       mangleQualifiers(Ty->getPointeeType().getQualifiers(), false);
-  } else if (const ArrayType *AT = getASTContext().getAsArrayType(Ty)) {
+  } else if (ArrayType const *AT = getASTContext().getAsArrayType(Ty)) {
     // Global arrays are funny, too.
     mangleDecayedArrayType(AT);
     if (AT->getElementType()->isArrayType())
@@ -644,8 +644,8 @@
   }
 }
 
-void MicrosoftCXXNameMangler::mangleMemberDataPointer(const CXXRecordDecl *RD,
-                                                      const ValueDecl *VD,
+void MicrosoftCXXNameMangler::mangleMemberDataPointer(CXXRecordDecl const *RD,
+                                                      ValueDecl const *VD,
                                                       StringRef Prefix) {
   // <member-data-pointer> ::= <integer-literal>
   //                       ::= $F <number> <number>
@@ -672,10 +672,18 @@
 
   char Code = '\0';
   switch (IM) {
-  case MSInheritanceModel::Single:      Code = '0'; break;
-  case MSInheritanceModel::Multiple:    Code = '0'; break;
-  case MSInheritanceModel::Virtual:     Code = 'F'; break;
-  case MSInheritanceModel::Unspecified: Code = 'G'; break;
+  case MSInheritanceModel::Single:
+    Code = '0';
+    break;
+  case MSInheritanceModel::Multiple:
+    Code = '0';
+    break;
+  case MSInheritanceModel::Virtual:
+    Code = 'F';
+    break;
+  case MSInheritanceModel::Unspecified:
+    Code = 'G';
+    break;
   }
 
   Out << Prefix << Code;
@@ -691,10 +699,8 @@
     mangleNumber(VBTableOffset);
 }
 
-void
-MicrosoftCXXNameMangler::mangleMemberFunctionPointer(const CXXRecordDecl *RD,
-                                                     const CXXMethodDecl *MD,
-                                                     StringRef Prefix) {
+void MicrosoftCXXNameMangler::mangleMemberFunctionPointer(
+    CXXRecordDecl const *RD, CXXMethodDecl const *MD, StringRef Prefix) {
   // <member-function-pointer> ::= $1? <name>
   //                           ::= $H? <name> <number>
   //                           ::= $I? <name> <number> <number>
@@ -704,10 +710,18 @@
 
   char Code = '\0';
   switch (IM) {
-  case MSInheritanceModel::Single:      Code = '1'; break;
-  case MSInheritanceModel::Multiple:    Code = 'H'; break;
-  case MSInheritanceModel::Virtual:     Code = 'I'; break;
-  case MSInheritanceModel::Unspecified: Code = 'J'; break;
+  case MSInheritanceModel::Single:
+    Code = '1';
+    break;
+  case MSInheritanceModel::Multiple:
+    Code = 'H';
+    break;
+  case MSInheritanceModel::Virtual:
+    Code = 'I';
+    break;
+  case MSInheritanceModel::Unspecified:
+    Code = 'J';
+    break;
   }
 
   // If non-virtual, mangle the name.  If virtual, mangle as a virtual memptr
@@ -726,7 +740,7 @@
       NVOffset = ML.VFPtrOffset.getQuantity();
       VBTableOffset = ML.VBTableIndex * 4;
       if (ML.VBase) {
-        const ASTRecordLayout &Layout = getASTContext().getASTRecordLayout(RD);
+        ASTRecordLayout const &Layout = getASTContext().getASTRecordLayout(RD);
         VBPtrOffset = Layout.getVBPtrOffset().getQuantity();
       }
     } else {
@@ -756,7 +770,7 @@
 }
 
 void MicrosoftCXXNameMangler::mangleVirtualMemPtrThunk(
-    const CXXMethodDecl *MD, const MethodVFTableLocation &ML) {
+    CXXMethodDecl const *MD, MethodVFTableLocation const &ML) {
   // Get the vftable offset.
   CharUnits PointerWidth = getASTContext().toCharUnitsFromBits(
       getASTContext().getTargetInfo().getPointerWidth(0));
@@ -770,7 +784,7 @@
   mangleCallingConvention(MD->getType()->castAs<FunctionProtoType>());
 }
 
-void MicrosoftCXXNameMangler::mangleName(const NamedDecl *ND) {
+void MicrosoftCXXNameMangler::mangleName(NamedDecl const *ND) {
   // <name> ::= <unscoped-name> {[<named-scope>]+ | [<nested-name>]}? @
 
   // Always start with the unqualified name.
@@ -783,7 +797,7 @@
 }
 
 void MicrosoftCXXNameMangler::mangleNumber(int64_t Number) {
-  mangleNumber(llvm::APSInt(llvm::APInt(64, Number), /*IsUnsigned*/false));
+  mangleNumber(llvm::APSInt(llvm::APInt(64, Number), /*IsUnsigned*/ false));
 }
 
 void MicrosoftCXXNameMangler::mangleNumber(llvm::APSInt Number) {
@@ -811,16 +825,30 @@
   using llvm::APFloat;
 
   switch (APFloat::SemanticsToEnum(Number.getSemantics())) {
-  case APFloat::S_IEEEsingle: Out << 'A'; break;
-  case APFloat::S_IEEEdouble: Out << 'B'; break;
+  case APFloat::S_IEEEsingle:
+    Out << 'A';
+    break;
+  case APFloat::S_IEEEdouble:
+    Out << 'B';
+    break;
 
   // The following are all Clang extensions. We try to pick manglings that are
   // unlikely to conflict with MSVC's scheme.
-  case APFloat::S_IEEEhalf: Out << 'V'; break;
-  case APFloat::S_BFloat: Out << 'W'; break;
-  case APFloat::S_x87DoubleExtended: Out << 'X'; break;
-  case APFloat::S_IEEEquad: Out << 'Y'; break;
-  case APFloat::S_PPCDoubleDouble: Out << 'Z'; break;
+  case APFloat::S_IEEEhalf:
+    Out << 'V';
+    break;
+  case APFloat::S_BFloat:
+    Out << 'W';
+    break;
+  case APFloat::S_x87DoubleExtended:
+    Out << 'X';
+    break;
+  case APFloat::S_IEEEquad:
+    Out << 'Y';
+    break;
+  case APFloat::S_PPCDoubleDouble:
+    Out << 'Z';
+    break;
   }
 
   mangleBits(Number.bitcastToAPInt());
@@ -844,25 +872,25 @@
   }
 }
 
-static const TemplateDecl *
-isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) {
+static TemplateDecl const *
+isTemplate(NamedDecl const *ND, TemplateArgumentList const *&TemplateArgs) {
   // Check if we have a function template.
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
-    if (const TemplateDecl *TD = FD->getPrimaryTemplate()) {
+  if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(ND)) {
+    if (TemplateDecl const *TD = FD->getPrimaryTemplate()) {
       TemplateArgs = FD->getTemplateSpecializationArgs();
       return TD;
     }
   }
 
   // Check if we have a class template.
-  if (const ClassTemplateSpecializationDecl *Spec =
+  if (ClassTemplateSpecializationDecl const *Spec =
           dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
     TemplateArgs = &Spec->getTemplateArgs();
     return Spec->getSpecializedTemplate();
   }
 
   // Check if we have a variable template.
-  if (const VarTemplateSpecializationDecl *Spec =
+  if (VarTemplateSpecializationDecl const *Spec =
           dyn_cast<VarTemplateSpecializationDecl>(ND)) {
     TemplateArgs = &Spec->getTemplateArgs();
     return Spec->getSpecializedTemplate();
@@ -871,7 +899,7 @@
   return nullptr;
 }
 
-void MicrosoftCXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND,
+void MicrosoftCXXNameMangler::mangleUnqualifiedName(NamedDecl const *ND,
                                                     DeclarationName Name) {
   //  <unqualified-name> ::= <operator-name>
   //                     ::= <ctor-dtor-name>
@@ -879,8 +907,8 @@
   //                     ::= <template-name>
 
   // Check if we have a template.
-  const TemplateArgumentList *TemplateArgs = nullptr;
-  if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
+  TemplateArgumentList const *TemplateArgs = nullptr;
+  if (TemplateDecl const *TD = isTemplate(ND, TemplateArgs)) {
     // Function templates aren't considered for name back referencing.  This
     // makes sense since function templates aren't likely to occur multiple
     // times in a symbol.
@@ -943,211 +971,210 @@
   }
 
   switch (Name.getNameKind()) {
-    case DeclarationName::Identifier: {
-      if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) {
-        mangleSourceName(II->getName());
-        break;
-      }
-
-      // Otherwise, an anonymous entity.  We must have a declaration.
-      assert(ND && "mangling empty name without declaration");
+  case DeclarationName::Identifier: {
+    if (IdentifierInfo const *II = Name.getAsIdentifierInfo()) {
+      mangleSourceName(II->getName());
+      break;
+    }
 
-      if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(ND)) {
-        if (NS->isAnonymousNamespace()) {
-          Out << "?A0x" << Context.getAnonymousNamespaceHash() << '@';
-          break;
-        }
-      }
+    // Otherwise, an anonymous entity.  We must have a declaration.
+    assert(ND && "mangling empty name without declaration");
 
-      if (const DecompositionDecl *DD = dyn_cast<DecompositionDecl>(ND)) {
-        // Decomposition declarations are considered anonymous, and get
-        // numbered with a $S prefix.
-        llvm::SmallString<64> Name("$S");
-        // Get a unique id for the anonymous struct.
-        Name += llvm::utostr(Context.getAnonymousStructId(DD) + 1);
-        mangleSourceName(Name);
+    if (NamespaceDecl const *NS = dyn_cast<NamespaceDecl>(ND)) {
+      if (NS->isAnonymousNamespace()) {
+        Out << "?A0x" << Context.getAnonymousNamespaceHash() << '@';
         break;
       }
+    }
 
-      if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
-        // We must have an anonymous union or struct declaration.
-        const CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl();
-        assert(RD && "expected variable decl to have a record type");
-        // Anonymous types with no tag or typedef get the name of their
-        // declarator mangled in.  If they have no declarator, number them with
-        // a $S prefix.
-        llvm::SmallString<64> Name("$S");
-        // Get a unique id for the anonymous struct.
-        Name += llvm::utostr(Context.getAnonymousStructId(RD) + 1);
-        mangleSourceName(Name.str());
-        break;
-      }
+    if (DecompositionDecl const *DD = dyn_cast<DecompositionDecl>(ND)) {
+      // Decomposition declarations are considered anonymous, and get
+      // numbered with a $S prefix.
+      llvm::SmallString<64> Name("$S");
+      // Get a unique id for the anonymous struct.
+      Name += llvm::utostr(Context.getAnonymousStructId(DD) + 1);
+      mangleSourceName(Name);
+      break;
+    }
 
-      if (const MSGuidDecl *GD = dyn_cast<MSGuidDecl>(ND)) {
-        // Mangle a GUID object as if it were a variable with the corresponding
-        // mangled name.
-        SmallString<sizeof("_GUID_12345678_1234_1234_1234_1234567890ab")> GUID;
-        llvm::raw_svector_ostream GUIDOS(GUID);
-        Context.mangleMSGuidDecl(GD, GUIDOS);
-        mangleSourceName(GUID);
-        break;
-      }
+    if (VarDecl const *VD = dyn_cast<VarDecl>(ND)) {
+      // We must have an anonymous union or struct declaration.
+      CXXRecordDecl const *RD = VD->getType()->getAsCXXRecordDecl();
+      assert(RD && "expected variable decl to have a record type");
+      // Anonymous types with no tag or typedef get the name of their
+      // declarator mangled in.  If they have no declarator, number them with
+      // a $S prefix.
+      llvm::SmallString<64> Name("$S");
+      // Get a unique id for the anonymous struct.
+      Name += llvm::utostr(Context.getAnonymousStructId(RD) + 1);
+      mangleSourceName(Name.str());
+      break;
+    }
 
-      if (const auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
-        Out << "?__N";
-        mangleTemplateArgValue(TPO->getType().getUnqualifiedType(),
-                               TPO->getValue());
-        break;
-      }
+    if (MSGuidDecl const *GD = dyn_cast<MSGuidDecl>(ND)) {
+      // Mangle a GUID object as if it were a variable with the corresponding
+      // mangled name.
+      SmallString<sizeof("_GUID_12345678_1234_1234_1234_1234567890ab")> GUID;
+      llvm::raw_svector_ostream GUIDOS(GUID);
+      Context.mangleMSGuidDecl(GD, GUIDOS);
+      mangleSourceName(GUID);
+      break;
+    }
 
-      // We must have an anonymous struct.
-      const TagDecl *TD = cast<TagDecl>(ND);
-      if (const TypedefNameDecl *D = TD->getTypedefNameForAnonDecl()) {
-        assert(TD->getDeclContext() == D->getDeclContext() &&
-               "Typedef should not be in another decl context!");
-        assert(D->getDeclName().getAsIdentifierInfo() &&
-               "Typedef was not named!");
-        mangleSourceName(D->getDeclName().getAsIdentifierInfo()->getName());
-        break;
-      }
+    if (auto const *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
+      Out << "?__N";
+      mangleTemplateArgValue(TPO->getType().getUnqualifiedType(),
+                             TPO->getValue());
+      break;
+    }
 
-      if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(TD)) {
-        if (Record->isLambda()) {
-          llvm::SmallString<10> Name("<lambda_");
-
-          Decl *LambdaContextDecl = Record->getLambdaContextDecl();
-          unsigned LambdaManglingNumber = Record->getLambdaManglingNumber();
-          unsigned LambdaId;
-          const ParmVarDecl *Parm =
-              dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
-          const FunctionDecl *Func =
-              Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr;
-
-          if (Func) {
-            unsigned DefaultArgNo =
-                Func->getNumParams() - Parm->getFunctionScopeIndex();
-            Name += llvm::utostr(DefaultArgNo);
-            Name += "_";
-          }
+    // We must have an anonymous struct.
+    TagDecl const *TD = cast<TagDecl>(ND);
+    if (TypedefNameDecl const *D = TD->getTypedefNameForAnonDecl()) {
+      assert(TD->getDeclContext() == D->getDeclContext() &&
+             "Typedef should not be in another decl context!");
+      assert(D->getDeclName().getAsIdentifierInfo() &&
+             "Typedef was not named!");
+      mangleSourceName(D->getDeclName().getAsIdentifierInfo()->getName());
+      break;
+    }
 
-          if (LambdaManglingNumber)
-            LambdaId = LambdaManglingNumber;
-          else
-            LambdaId = Context.getLambdaId(Record);
+    if (CXXRecordDecl const *Record = dyn_cast<CXXRecordDecl>(TD)) {
+      if (Record->isLambda()) {
+        llvm::SmallString<10> Name("<lambda_");
+
+        Decl *LambdaContextDecl = Record->getLambdaContextDecl();
+        unsigned LambdaManglingNumber = Record->getLambdaManglingNumber();
+        unsigned LambdaId;
+        ParmVarDecl const *Parm =
+            dyn_cast_or_null<ParmVarDecl>(LambdaContextDecl);
+        FunctionDecl const *Func =
+            Parm ? dyn_cast<FunctionDecl>(Parm->getDeclContext()) : nullptr;
+
+        if (Func) {
+          unsigned DefaultArgNo =
+              Func->getNumParams() - Parm->getFunctionScopeIndex();
+          Name += llvm::utostr(DefaultArgNo);
+          Name += "_";
+        }
 
-          Name += llvm::utostr(LambdaId);
-          Name += ">";
+        if (LambdaManglingNumber)
+          LambdaId = LambdaManglingNumber;
+        else
+          LambdaId = Context.getLambdaId(Record);
+
+        Name += llvm::utostr(LambdaId);
+        Name += ">";
 
-          mangleSourceName(Name);
+        mangleSourceName(Name);
 
-          // If the context is a variable or a class member and not a parameter,
-          // it is encoded in a qualified name.
-          if (LambdaManglingNumber && LambdaContextDecl) {
-            if ((isa<VarDecl>(LambdaContextDecl) ||
-                 isa<FieldDecl>(LambdaContextDecl)) &&
-                !isa<ParmVarDecl>(LambdaContextDecl)) {
-              mangleUnqualifiedName(cast<NamedDecl>(LambdaContextDecl));
-            }
+        // If the context is a variable or a class member and not a parameter,
+        // it is encoded in a qualified name.
+        if (LambdaManglingNumber && LambdaContextDecl) {
+          if ((isa<VarDecl>(LambdaContextDecl) ||
+               isa<FieldDecl>(LambdaContextDecl)) &&
+              !isa<ParmVarDecl>(LambdaContextDecl)) {
+            mangleUnqualifiedName(cast<NamedDecl>(LambdaContextDecl));
           }
-          break;
         }
+        break;
       }
-
-      llvm::SmallString<64> Name;
-      if (DeclaratorDecl *DD =
-              Context.getASTContext().getDeclaratorForUnnamedTagDecl(TD)) {
-        // Anonymous types without a name for linkage purposes have their
-        // declarator mangled in if they have one.
-        Name += "<unnamed-type-";
-        Name += DD->getName();
-      } else if (TypedefNameDecl *TND =
-                     Context.getASTContext().getTypedefNameForUnnamedTagDecl(
-                         TD)) {
-        // Anonymous types without a name for linkage purposes have their
-        // associate typedef mangled in if they have one.
-        Name += "<unnamed-type-";
-        Name += TND->getName();
-      } else if (isa<EnumDecl>(TD) &&
-                 cast<EnumDecl>(TD)->enumerator_begin() !=
-                     cast<EnumDecl>(TD)->enumerator_end()) {
-        // Anonymous non-empty enums mangle in the first enumerator.
-        auto *ED = cast<EnumDecl>(TD);
-        Name += "<unnamed-enum-";
-        Name += ED->enumerator_begin()->getName();
-      } else {
-        // Otherwise, number the types using a $S prefix.
-        Name += "<unnamed-type-$S";
-        Name += llvm::utostr(Context.getAnonymousStructId(TD) + 1);
-      }
-      Name += ">";
-      mangleSourceName(Name.str());
-      break;
     }
 
-    case DeclarationName::ObjCZeroArgSelector:
-    case DeclarationName::ObjCOneArgSelector:
-    case DeclarationName::ObjCMultiArgSelector: {
-      // This is reachable only when constructing an outlined SEH finally
-      // block.  Nothing depends on this mangling and it's used only with
-      // functinos with internal linkage.
-      llvm::SmallString<64> Name;
-      mangleSourceName(Name.str());
-      break;
+    llvm::SmallString<64> Name;
+    if (DeclaratorDecl *DD =
+            Context.getASTContext().getDeclaratorForUnnamedTagDecl(TD)) {
+      // Anonymous types without a name for linkage purposes have their
+      // declarator mangled in if they have one.
+      Name += "<unnamed-type-";
+      Name += DD->getName();
+    } else if (TypedefNameDecl *TND =
+                   Context.getASTContext().getTypedefNameForUnnamedTagDecl(
+                       TD)) {
+      // Anonymous types without a name for linkage purposes have their
+      // associate typedef mangled in if they have one.
+      Name += "<unnamed-type-";
+      Name += TND->getName();
+    } else if (isa<EnumDecl>(TD) && cast<EnumDecl>(TD)->enumerator_begin() !=
+                                        cast<EnumDecl>(TD)->enumerator_end()) {
+      // Anonymous non-empty enums mangle in the first enumerator.
+      auto *ED = cast<EnumDecl>(TD);
+      Name += "<unnamed-enum-";
+      Name += ED->enumerator_begin()->getName();
+    } else {
+      // Otherwise, number the types using a $S prefix.
+      Name += "<unnamed-type-$S";
+      Name += llvm::utostr(Context.getAnonymousStructId(TD) + 1);
     }
+    Name += ">";
+    mangleSourceName(Name.str());
+    break;
+  }
 
-    case DeclarationName::CXXConstructorName:
-      if (isStructorDecl(ND)) {
-        if (StructorType == Ctor_CopyingClosure) {
-          Out << "?_O";
-          return;
-        }
-        if (StructorType == Ctor_DefaultClosure) {
-          Out << "?_F";
-          return;
-        }
+  case DeclarationName::ObjCZeroArgSelector:
+  case DeclarationName::ObjCOneArgSelector:
+  case DeclarationName::ObjCMultiArgSelector: {
+    // This is reachable only when constructing an outlined SEH finally
+    // block.  Nothing depends on this mangling and it's used only with
+    // functinos with internal linkage.
+    llvm::SmallString<64> Name;
+    mangleSourceName(Name.str());
+    break;
+  }
+
+  case DeclarationName::CXXConstructorName:
+    if (isStructorDecl(ND)) {
+      if (StructorType == Ctor_CopyingClosure) {
+        Out << "?_O";
+        return;
       }
-      Out << "?0";
-      return;
+      if (StructorType == Ctor_DefaultClosure) {
+        Out << "?_F";
+        return;
+      }
+    }
+    Out << "?0";
+    return;
 
-    case DeclarationName::CXXDestructorName:
-      if (isStructorDecl(ND))
-        // If the named decl is the C++ destructor we're mangling,
-        // use the type we were given.
-        mangleCXXDtorType(static_cast<CXXDtorType>(StructorType));
-      else
-        // Otherwise, use the base destructor name. This is relevant if a
-        // class with a destructor is declared within a destructor.
-        mangleCXXDtorType(Dtor_Base);
-      break;
+  case DeclarationName::CXXDestructorName:
+    if (isStructorDecl(ND))
+      // If the named decl is the C++ destructor we're mangling,
+      // use the type we were given.
+      mangleCXXDtorType(static_cast<CXXDtorType>(StructorType));
+    else
+      // Otherwise, use the base destructor name. This is relevant if a
+      // class with a destructor is declared within a destructor.
+      mangleCXXDtorType(Dtor_Base);
+    break;
 
-    case DeclarationName::CXXConversionFunctionName:
-      // <operator-name> ::= ?B # (cast)
-      // The target type is encoded as the return type.
-      Out << "?B";
-      break;
+  case DeclarationName::CXXConversionFunctionName:
+    // <operator-name> ::= ?B # (cast)
+    // The target type is encoded as the return type.
+    Out << "?B";
+    break;
 
-    case DeclarationName::CXXOperatorName:
-      mangleOperatorName(Name.getCXXOverloadedOperator(), ND->getLocation());
-      break;
+  case DeclarationName::CXXOperatorName:
+    mangleOperatorName(Name.getCXXOverloadedOperator(), ND->getLocation());
+    break;
 
-    case DeclarationName::CXXLiteralOperatorName: {
-      Out << "?__K";
-      mangleSourceName(Name.getCXXLiteralIdentifier()->getName());
-      break;
-    }
+  case DeclarationName::CXXLiteralOperatorName: {
+    Out << "?__K";
+    mangleSourceName(Name.getCXXLiteralIdentifier()->getName());
+    break;
+  }
 
-    case DeclarationName::CXXDeductionGuideName:
-      llvm_unreachable("Can't mangle a deduction guide name!");
+  case DeclarationName::CXXDeductionGuideName:
+    llvm_unreachable("Can't mangle a deduction guide name!");
 
-    case DeclarationName::CXXUsingDirective:
-      llvm_unreachable("Can't mangle a using directive name!");
+  case DeclarationName::CXXUsingDirective:
+    llvm_unreachable("Can't mangle a using directive name!");
   }
 }
 
 // <postfix> ::= <unqualified-name> [<postfix>]
 //           ::= <substitution> [<postfix>]
-void MicrosoftCXXNameMangler::mangleNestedName(const NamedDecl *ND) {
-  const DeclContext *DC = getEffectiveDeclContext(ND);
+void MicrosoftCXXNameMangler::mangleNestedName(NamedDecl const *ND) {
+  DeclContext const *DC = getEffectiveDeclContext(ND);
   while (!DC->isTranslationUnit()) {
     if (isa<TagDecl>(ND) || isa<VarDecl>(ND)) {
       unsigned Disc;
@@ -1158,10 +1185,10 @@
       }
     }
 
-    if (const BlockDecl *BD = dyn_cast<BlockDecl>(DC)) {
+    if (BlockDecl const *BD = dyn_cast<BlockDecl>(DC)) {
       auto Discriminate =
-          [](StringRef Name, const unsigned Discriminator,
-             const unsigned ParameterDiscriminator) -> std::string {
+          [](StringRef Name, unsigned const Discriminator,
+             unsigned const ParameterDiscriminator) -> std::string {
         std::string Buffer;
         llvm::raw_string_ostream Stream(Buffer);
         Stream << Name;
@@ -1180,29 +1207,29 @@
       // parameters.  Rather than mangling the unqualified parameter name,
       // always use the position to give a uniform mangling.
       unsigned ParameterDiscriminator = 0;
-      if (const auto *MC = BD->getBlockManglingContextDecl())
-        if (const auto *P = dyn_cast<ParmVarDecl>(MC))
-          if (const auto *F = dyn_cast<FunctionDecl>(P->getDeclContext()))
+      if (auto const *MC = BD->getBlockManglingContextDecl())
+        if (auto const *P = dyn_cast<ParmVarDecl>(MC))
+          if (auto const *F = dyn_cast<FunctionDecl>(P->getDeclContext()))
             ParameterDiscriminator =
                 F->getNumParams() - P->getFunctionScopeIndex();
 
       DC = getEffectiveDeclContext(BD);
 
       Out << '?';
-      mangleSourceName(Discriminate("_block_invoke", Discriminator,
-                                    ParameterDiscriminator));
+      mangleSourceName(
+          Discriminate("_block_invoke", Discriminator, ParameterDiscriminator));
       // If we have a block mangling context, encode that now.  This allows us
       // to discriminate between named static data initializers in the same
       // scope.  This is handled differently from parameters, which use
       // positions to discriminate between multiple instances.
-      if (const auto *MC = BD->getBlockManglingContextDecl())
+      if (auto const *MC = BD->getBlockManglingContextDecl())
         if (!isa<ParmVarDecl>(MC))
-          if (const auto *ND = dyn_cast<NamedDecl>(MC))
+          if (auto const *ND = dyn_cast<NamedDecl>(MC))
             mangleUnqualifiedName(ND);
       // MS ABI and Itanium manglings are in inverted scopes.  In the case of a
       // RecordDecl, mangle the entire scope hierarchy at this point rather than
       // just the unqualified name to get the ordering correct.
-      if (const auto *RD = dyn_cast<RecordDecl>(DC))
+      if (auto const *RD = dyn_cast<RecordDecl>(DC))
         mangleName(RD);
       else
         Out << '@';
@@ -1215,8 +1242,8 @@
         Out << 'E';
       Out << 'A';
       mangleArtificialTagType(TTK_Struct,
-                             Discriminate("__block_literal", Discriminator,
-                                          ParameterDiscriminator));
+                              Discriminate("__block_literal", Discriminator,
+                                           ParameterDiscriminator));
       Out << "@Z";
 
       // If the effective context was a Record, we have fully mangled the
@@ -1224,18 +1251,18 @@
       if (isa<RecordDecl>(DC))
         break;
       continue;
-    } else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(DC)) {
+    } else if (ObjCMethodDecl const *Method = dyn_cast<ObjCMethodDecl>(DC)) {
       mangleObjCMethodName(Method);
     } else if (isa<NamedDecl>(DC)) {
       ND = cast<NamedDecl>(DC);
-      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
+      if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(ND)) {
         mangle(FD, "?");
         break;
       } else {
         mangleUnqualifiedName(ND);
         // Lambdas in default arguments conceptually belong to the function the
         // parameter corresponds to.
-        if (const auto *LDADC = getLambdaDefaultArgumentDeclContext(ND)) {
+        if (auto const *LDADC = getLambdaDefaultArgumentDeclContext(ND)) {
           DC = LDADC;
           continue;
         }
@@ -1251,11 +1278,17 @@
   // towards the base dtor.
   switch (T) {
   // <operator-name> ::= ?1  # destructor
-  case Dtor_Base: Out << "?1"; return;
+  case Dtor_Base:
+    Out << "?1";
+    return;
   // <operator-name> ::= ?_D # vbase destructor
-  case Dtor_Complete: Out << "?_D"; return;
+  case Dtor_Complete:
+    Out << "?_D";
+    return;
   // <operator-name> ::= ?_G # scalar deleting destructor
-  case Dtor_Deleting: Out << "?_G"; return;
+  case Dtor_Deleting:
+    Out << "?_G";
+    return;
   // <operator-name> ::= ?_E # vector deleting destructor
   // FIXME: Add a vector deleting dtor type.  It goes in the vtable, so we need
   // it.
@@ -1271,86 +1304,166 @@
   //                     ?0 # constructor
   //                     ?1 # destructor
   // <operator-name> ::= ?2 # new
-  case OO_New: Out << "?2"; break;
+  case OO_New:
+    Out << "?2";
+    break;
   // <operator-name> ::= ?3 # delete
-  case OO_Delete: Out << "?3"; break;
+  case OO_Delete:
+    Out << "?3";
+    break;
   // <operator-name> ::= ?4 # =
-  case OO_Equal: Out << "?4"; break;
+  case OO_Equal:
+    Out << "?4";
+    break;
   // <operator-name> ::= ?5 # >>
-  case OO_GreaterGreater: Out << "?5"; break;
+  case OO_GreaterGreater:
+    Out << "?5";
+    break;
   // <operator-name> ::= ?6 # <<
-  case OO_LessLess: Out << "?6"; break;
+  case OO_LessLess:
+    Out << "?6";
+    break;
   // <operator-name> ::= ?7 # !
-  case OO_Exclaim: Out << "?7"; break;
+  case OO_Exclaim:
+    Out << "?7";
+    break;
   // <operator-name> ::= ?8 # ==
-  case OO_EqualEqual: Out << "?8"; break;
+  case OO_EqualEqual:
+    Out << "?8";
+    break;
   // <operator-name> ::= ?9 # !=
-  case OO_ExclaimEqual: Out << "?9"; break;
+  case OO_ExclaimEqual:
+    Out << "?9";
+    break;
   // <operator-name> ::= ?A # []
-  case OO_Subscript: Out << "?A"; break;
+  case OO_Subscript:
+    Out << "?A";
+    break;
   //                     ?B # conversion
   // <operator-name> ::= ?C # ->
-  case OO_Arrow: Out << "?C"; break;
+  case OO_Arrow:
+    Out << "?C";
+    break;
   // <operator-name> ::= ?D # *
-  case OO_Star: Out << "?D"; break;
+  case OO_Star:
+    Out << "?D";
+    break;
   // <operator-name> ::= ?E # ++
-  case OO_PlusPlus: Out << "?E"; break;
+  case OO_PlusPlus:
+    Out << "?E";
+    break;
   // <operator-name> ::= ?F # --
-  case OO_MinusMinus: Out << "?F"; break;
+  case OO_MinusMinus:
+    Out << "?F";
+    break;
   // <operator-name> ::= ?G # -
-  case OO_Minus: Out << "?G"; break;
+  case OO_Minus:
+    Out << "?G";
+    break;
   // <operator-name> ::= ?H # +
-  case OO_Plus: Out << "?H"; break;
+  case OO_Plus:
+    Out << "?H";
+    break;
   // <operator-name> ::= ?I # &
-  case OO_Amp: Out << "?I"; break;
+  case OO_Amp:
+    Out << "?I";
+    break;
   // <operator-name> ::= ?J # ->*
-  case OO_ArrowStar: Out << "?J"; break;
+  case OO_ArrowStar:
+    Out << "?J";
+    break;
   // <operator-name> ::= ?K # /
-  case OO_Slash: Out << "?K"; break;
+  case OO_Slash:
+    Out << "?K";
+    break;
   // <operator-name> ::= ?L # %
-  case OO_Percent: Out << "?L"; break;
+  case OO_Percent:
+    Out << "?L";
+    break;
   // <operator-name> ::= ?M # <
-  case OO_Less: Out << "?M"; break;
+  case OO_Less:
+    Out << "?M";
+    break;
   // <operator-name> ::= ?N # <=
-  case OO_LessEqual: Out << "?N"; break;
+  case OO_LessEqual:
+    Out << "?N";
+    break;
   // <operator-name> ::= ?O # >
-  case OO_Greater: Out << "?O"; break;
+  case OO_Greater:
+    Out << "?O";
+    break;
   // <operator-name> ::= ?P # >=
-  case OO_GreaterEqual: Out << "?P"; break;
+  case OO_GreaterEqual:
+    Out << "?P";
+    break;
   // <operator-name> ::= ?Q # ,
-  case OO_Comma: Out << "?Q"; break;
+  case OO_Comma:
+    Out << "?Q";
+    break;
   // <operator-name> ::= ?R # ()
-  case OO_Call: Out << "?R"; break;
+  case OO_Call:
+    Out << "?R";
+    break;
   // <operator-name> ::= ?S # ~
-  case OO_Tilde: Out << "?S"; break;
+  case OO_Tilde:
+    Out << "?S";
+    break;
   // <operator-name> ::= ?T # ^
-  case OO_Caret: Out << "?T"; break;
+  case OO_Caret:
+    Out << "?T";
+    break;
   // <operator-name> ::= ?U # |
-  case OO_Pipe: Out << "?U"; break;
+  case OO_Pipe:
+    Out << "?U";
+    break;
   // <operator-name> ::= ?V # &&
-  case OO_AmpAmp: Out << "?V"; break;
+  case OO_AmpAmp:
+    Out << "?V";
+    break;
   // <operator-name> ::= ?W # ||
-  case OO_PipePipe: Out << "?W"; break;
+  case OO_PipePipe:
+    Out << "?W";
+    break;
   // <operator-name> ::= ?X # *=
-  case OO_StarEqual: Out << "?X"; break;
+  case OO_StarEqual:
+    Out << "?X";
+    break;
   // <operator-name> ::= ?Y # +=
-  case OO_PlusEqual: Out << "?Y"; break;
+  case OO_PlusEqual:
+    Out << "?Y";
+    break;
   // <operator-name> ::= ?Z # -=
-  case OO_MinusEqual: Out << "?Z"; break;
+  case OO_MinusEqual:
+    Out << "?Z";
+    break;
   // <operator-name> ::= ?_0 # /=
-  case OO_SlashEqual: Out << "?_0"; break;
+  case OO_SlashEqual:
+    Out << "?_0";
+    break;
   // <operator-name> ::= ?_1 # %=
-  case OO_PercentEqual: Out << "?_1"; break;
+  case OO_PercentEqual:
+    Out << "?_1";
+    break;
   // <operator-name> ::= ?_2 # >>=
-  case OO_GreaterGreaterEqual: Out << "?_2"; break;
+  case OO_GreaterGreaterEqual:
+    Out << "?_2";
+    break;
   // <operator-name> ::= ?_3 # <<=
-  case OO_LessLessEqual: Out << "?_3"; break;
+  case OO_LessLessEqual:
+    Out << "?_3";
+    break;
   // <operator-name> ::= ?_4 # &=
-  case OO_AmpEqual: Out << "?_4"; break;
+  case OO_AmpEqual:
+    Out << "?_4";
+    break;
   // <operator-name> ::= ?_5 # |=
-  case OO_PipeEqual: Out << "?_5"; break;
+  case OO_PipeEqual:
+    Out << "?_5";
+    break;
   // <operator-name> ::= ?_6 # ^=
-  case OO_CaretEqual: Out << "?_6"; break;
+  case OO_CaretEqual:
+    Out << "?_6";
+    break;
   //                     ?_7 # vftable
   //                     ?_8 # vbtable
   //                     ?_9 # vcall
@@ -1379,18 +1492,27 @@
   //                     ?_S # local vftable
   //                     ?_T # local vftable constructor closure
   // <operator-name> ::= ?_U # new[]
-  case OO_Array_New: Out << "?_U"; break;
+  case OO_Array_New:
+    Out << "?_U";
+    break;
   // <operator-name> ::= ?_V # delete[]
-  case OO_Array_Delete: Out << "?_V"; break;
+  case OO_Array_Delete:
+    Out << "?_V";
+    break;
   // <operator-name> ::= ?__L # co_await
-  case OO_Coawait: Out << "?__L"; break;
+  case OO_Coawait:
+    Out << "?__L";
+    break;
   // <operator-name> ::= ?__M # <=>
-  case OO_Spaceship: Out << "?__M"; break;
+  case OO_Spaceship:
+    Out << "?__M";
+    break;
 
   case OO_Conditional: {
     DiagnosticsEngine &Diags = Context.getDiags();
-    unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-      "cannot mangle this conditional operator yet");
+    unsigned DiagID =
+        Diags.getCustomDiagID(DiagnosticsEngine::Error,
+                              "cannot mangle this conditional operator yet");
     Diags.Report(Loc, DiagID);
     break;
   }
@@ -1413,12 +1535,12 @@
   }
 }
 
-void MicrosoftCXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) {
+void MicrosoftCXXNameMangler::mangleObjCMethodName(ObjCMethodDecl const *MD) {
   Context.mangleObjCMethodNameAsSourceName(MD, Out);
 }
 
 void MicrosoftCXXNameMangler::mangleTemplateInstantiationName(
-    const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) {
+    TemplateDecl const *TD, TemplateArgumentList const &TemplateArgs) {
   // <template-name> ::= <unscoped-template-name> <template-args>
   //                 ::= <substitution>
   // Always start with the unqualified name.
@@ -1443,15 +1565,15 @@
   PassObjectSizeArgs.swap(OuterPassObjectSizeArgs);
 }
 
-void
-MicrosoftCXXNameMangler::mangleUnscopedTemplateName(const TemplateDecl *TD) {
+void MicrosoftCXXNameMangler::mangleUnscopedTemplateName(
+    TemplateDecl const *TD) {
   // <unscoped-template-name> ::= ?$ <unqualified-name>
   Out << "?$";
   mangleUnqualifiedName(TD);
 }
 
 void MicrosoftCXXNameMangler::mangleIntegerLiteral(
-    const llvm::APSInt &Value, const NonTypeTemplateParmDecl *PD,
+    llvm::APSInt const &Value, NonTypeTemplateParmDecl const *PD,
     QualType TemplateArgType) {
   // <integer-literal> ::= $0 <number>
   Out << "$";
@@ -1472,7 +1594,7 @@
 }
 
 void MicrosoftCXXNameMangler::mangleExpression(
-    const Expr *E, const NonTypeTemplateParmDecl *PD) {
+    Expr const *E, NonTypeTemplateParmDecl const *PD) {
   // See if this is a constant expression.
   if (Optional<llvm::APSInt> Value =
           E->getIntegerConstantExpr(Context.getASTContext())) {
@@ -1484,19 +1606,19 @@
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
       DiagnosticsEngine::Error, "cannot yet mangle expression type %0");
-  Diags.Report(E->getExprLoc(), DiagID) << E->getStmtClassName()
-                                        << E->getSourceRange();
+  Diags.Report(E->getExprLoc(), DiagID)
+      << E->getStmtClassName() << E->getSourceRange();
 }
 
 void MicrosoftCXXNameMangler::mangleTemplateArgs(
-    const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) {
+    TemplateDecl const *TD, TemplateArgumentList const &TemplateArgs) {
   // <template-args> ::= <template-arg>+
-  const TemplateParameterList *TPL = TD->getTemplateParameters();
+  TemplateParameterList const *TPL = TD->getTemplateParameters();
   assert(TPL->size() == TemplateArgs.size() &&
          "size mismatch between args and parms!");
 
   for (size_t i = 0; i < TemplateArgs.size(); ++i) {
-    const TemplateArgument &TA = TemplateArgs[i];
+    TemplateArgument const &TA = TemplateArgs[i];
 
     // Separate consecutive packs by $$Z.
     if (i > 0 && TA.getKind() == TemplateArgument::Pack &&
@@ -1507,9 +1629,9 @@
   }
 }
 
-void MicrosoftCXXNameMangler::mangleTemplateArg(const TemplateDecl *TD,
-                                                const TemplateArgument &TA,
-                                                const NamedDecl *Parm) {
+void MicrosoftCXXNameMangler::mangleTemplateArg(TemplateDecl const *TD,
+                                                TemplateArgument const &TA,
+                                                NamedDecl const *Parm) {
   // <template-arg> ::= <type>
   //                ::= <integer-literal>
   //                ::= <member-data-pointer>
@@ -1554,13 +1676,13 @@
     break;
   }
   case TemplateArgument::Declaration: {
-    const NamedDecl *ND = TA.getAsDecl();
+    NamedDecl const *ND = TA.getAsDecl();
     if (isa<FieldDecl>(ND) || isa<IndirectFieldDecl>(ND)) {
       mangleMemberDataPointer(cast<CXXRecordDecl>(ND->getDeclContext())
                                   ->getMostRecentNonInjectedDecl(),
                               cast<ValueDecl>(ND));
-    } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
-      const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
+    } else if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(ND)) {
+      CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(FD);
       if (MD && MD->isInstance()) {
         mangleMemberFunctionPointer(
             MD->getParent()->getMostRecentNonInjectedDecl(), MD);
@@ -1587,8 +1709,8 @@
   }
   case TemplateArgument::NullPtr: {
     QualType T = TA.getNullPtrType();
-    if (const MemberPointerType *MPT = T->getAs<MemberPointerType>()) {
-      const CXXRecordDecl *RD = MPT->getMostRecentCXXRecordDecl();
+    if (MemberPointerType const *MPT = T->getAs<MemberPointerType>()) {
+      CXXRecordDecl const *RD = MPT->getMostRecentCXXRecordDecl();
       if (MPT->isMemberFunctionPointerType() &&
           !isa<FunctionTemplateDecl>(TD)) {
         mangleMemberFunctionPointer(RD, nullptr);
@@ -1635,15 +1757,15 @@
       else
         llvm_unreachable("unexpected template parameter decl!");
     } else {
-      for (const TemplateArgument &PA : TemplateArgs)
+      for (TemplateArgument const &PA : TemplateArgs)
         mangleTemplateArg(TD, PA, Parm);
     }
     break;
   }
   case TemplateArgument::Template: {
-    const NamedDecl *ND =
+    NamedDecl const *ND =
         TA.getAsTemplate().getAsTemplateDecl()->getTemplatedDecl();
-    if (const auto *TD = dyn_cast<TagDecl>(ND)) {
+    if (auto const *TD = dyn_cast<TagDecl>(ND)) {
       mangleType(TD);
     } else if (isa<TypeAliasDecl>(ND)) {
       Out << "$$Y";
@@ -1657,7 +1779,7 @@
 }
 
 void MicrosoftCXXNameMangler::mangleTemplateArgValue(QualType T,
-                                                     const APValue &V,
+                                                     APValue const &V,
                                                      bool WithScalarType) {
   switch (V.getKind()) {
   case APValue::None:
@@ -1703,7 +1825,7 @@
       } else if (!V.hasLValuePath()) {
         // FIXME: This can only happen as an extension. Invent a mangling.
         break;
-      } else if (auto *VD = Base.dyn_cast<const ValueDecl*>()) {
+      } else if (auto *VD = Base.dyn_cast<ValueDecl const *>()) {
         Out << (T->isReferenceType() ? "E" : "1");
         mangle(VD);
       } else {
@@ -1722,7 +1844,7 @@
         if (T->isArrayType())
           goto mangling_unknown;
 
-        const Decl *D = E.getAsBaseOrMember().getPointer();
+        Decl const *D = E.getAsBaseOrMember().getPointer();
         auto *FD = dyn_cast<FieldDecl>(D);
         // We don't know how to mangle derived-to-base conversions yet.
         if (!FD)
@@ -1733,14 +1855,14 @@
         T = FD->getType();
       }
 
-      auto *VD = Base.dyn_cast<const ValueDecl*>();
+      auto *VD = Base.dyn_cast<ValueDecl const *>();
       if (!VD)
         break;
       Out << "E";
       mangle(VD);
 
       for (APValue::LValuePathEntry E : V.getLValuePath()) {
-        const Decl *D = E.getAsBaseOrMember().getPointer();
+        Decl const *D = E.getAsBaseOrMember().getPointer();
         mangleUnqualifiedName(cast<FieldDecl>(D));
       }
       for (unsigned I = 0; I != NumAts; ++I)
@@ -1761,9 +1883,9 @@
     if (!V.getMemberPointerPath().empty())
       break;
 
-    const CXXRecordDecl *RD =
+    CXXRecordDecl const *RD =
         T->castAs<MemberPointerType>()->getMostRecentCXXRecordDecl();
-    const ValueDecl *D = V.getMemberPointerDecl();
+    ValueDecl const *D = V.getMemberPointerDecl();
     if (T->isMemberDataPointerType())
       mangleMemberDataPointer(RD, D, "");
     else
@@ -1774,13 +1896,13 @@
   case APValue::Struct: {
     Out << '2';
     mangleType(T, SourceRange(), QMM_Escape);
-    const CXXRecordDecl *RD = T->getAsCXXRecordDecl();
+    CXXRecordDecl const *RD = T->getAsCXXRecordDecl();
     assert(RD && "unexpected type for record value");
 
     unsigned BaseIndex = 0;
-    for (const CXXBaseSpecifier &B : RD->bases())
+    for (CXXBaseSpecifier const &B : RD->bases())
       mangleTemplateArgValue(B.getType(), V.getStructBase(BaseIndex++));
-    for (const FieldDecl *FD : RD->fields())
+    for (FieldDecl const *FD : RD->fields())
       if (!FD->isUnnamedBitfield())
         mangleTemplateArgValue(FD->getType(),
                                V.getStructField(FD->getFieldIndex()),
@@ -1792,7 +1914,7 @@
   case APValue::Union:
     Out << '7';
     mangleType(T, SourceRange(), QMM_Escape);
-    if (const FieldDecl *FD = V.getUnionField()) {
+    if (FieldDecl const *FD = V.getUnionField()) {
       mangleUnqualifiedName(FD);
       mangleTemplateArgValue(FD->getType(), V.getUnionValue());
     }
@@ -1823,7 +1945,7 @@
     QualType ElemT = getASTContext().getAsArrayType(T)->getElementType();
     mangleType(ElemT, SourceRange(), QMM_Escape);
     for (unsigned I = 0, N = V.getArraySize(); I != N; ++I) {
-      const APValue &ElemV = I < V.getArrayInitializedElts()
+      APValue const &ElemV = I < V.getArrayInitializedElts()
                                  ? V.getArrayInitializedElt(I)
                                  : V.getArrayFiller();
       mangleTemplateArgValue(ElemT, ElemV);
@@ -1842,7 +1964,7 @@
     QualType ElemT = T->castAs<VectorType>()->getElementType();
     mangleType(ElemT, SourceRange(), QMM_Escape);
     for (unsigned I = 0, N = V.getVectorLength(); I != N; ++I) {
-      const APValue &ElemV = V.getVectorElt(I);
+      APValue const &ElemV = V.getVectorElt(I);
       mangleTemplateArgValue(ElemT, ElemV);
       Out << '@';
     }
@@ -1862,7 +1984,7 @@
   Diags.Report(DiagID);
 }
 
-void MicrosoftCXXNameMangler::mangleObjCProtocol(const ObjCProtocolDecl *PD) {
+void MicrosoftCXXNameMangler::mangleObjCProtocol(ObjCProtocolDecl const *PD) {
   llvm::SmallString<64> TemplateMangling;
   llvm::raw_svector_ostream Stream(TemplateMangling);
   MicrosoftCXXNameMangler Extra(Context, Stream);
@@ -1903,7 +2025,7 @@
   mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__ObjC"});
 }
 
-void MicrosoftCXXNameMangler::mangleObjCKindOfType(const ObjCObjectType *T,
+void MicrosoftCXXNameMangler::mangleObjCKindOfType(ObjCObjectType const *T,
                                                    Qualifiers Quals,
                                                    SourceRange Range) {
   llvm::SmallString<64> TemplateMangling;
@@ -1964,7 +2086,8 @@
   //                       ::= 8  # near method (pointers only)
   //                       ::= 9  # far method (pointers only)
   //                       ::= _A <basis> # based function (pointers only)
-  //                       ::= _B <basis> # based function (far?) (pointers only)
+  //                       ::= _B <basis> # based function (far?) (pointers
+  //                       only)
   //                       ::= _C <basis> # based method (pointers only)
   //                       ::= _D <basis> # based method (far?) (pointers only)
   //                       ::= _E # block (Clang)
@@ -1974,8 +2097,7 @@
   //         ::= 3 # ?
   //         ::= 4 # ?
   //         ::= 5 # not really based
-  bool HasConst = Quals.hasConst(),
-       HasVolatile = Quals.hasVolatile();
+  bool HasConst = Quals.hasConst(), HasVolatile = Quals.hasVolatile();
 
   if (!IsMember) {
     if (HasConst && HasVolatile) {
@@ -2002,8 +2124,8 @@
   // FIXME: For now, just drop all extension qualifiers on the floor.
 }
 
-void
-MicrosoftCXXNameMangler::mangleRefQualifier(RefQualifierKind RefQualifier) {
+void MicrosoftCXXNameMangler::mangleRefQualifier(
+    RefQualifierKind RefQualifier) {
   // <ref-qualifier> ::= G                # lvalue reference
   //                 ::= H                # rvalue-reference
   switch (RefQualifier) {
@@ -2023,16 +2145,17 @@
 void MicrosoftCXXNameMangler::manglePointerExtQualifiers(Qualifiers Quals,
                                                          QualType PointeeType) {
   // Check if this is a default 64-bit pointer or has __ptr64 qualifier.
-  bool is64Bit = PointeeType.isNull() ? PointersAre64Bit :
-      is64BitPointer(PointeeType.getQualifiers());
+  bool is64Bit = PointeeType.isNull()
+                     ? PointersAre64Bit
+                     : is64BitPointer(PointeeType.getQualifiers());
   if (is64Bit && (PointeeType.isNull() || !PointeeType->isFunctionType()))
     Out << 'E';
 
   if (Quals.hasRestrict())
     Out << 'I';
 
-  if (Quals.hasUnaligned() ||
-      (!PointeeType.isNull() && PointeeType.getLocalQualifiers().hasUnaligned()))
+  if (Quals.hasUnaligned() || (!PointeeType.isNull() &&
+                               PointeeType.getLocalQualifiers().hasUnaligned()))
     Out << 'F';
 }
 
@@ -2041,8 +2164,7 @@
   //                         ::= Q  # const
   //                         ::= R  # volatile
   //                         ::= S  # const volatile
-  bool HasConst = Quals.hasConst(),
-       HasVolatile = Quals.hasVolatile();
+  bool HasConst = Quals.hasConst(), HasVolatile = Quals.hasVolatile();
 
   if (HasConst && HasVolatile) {
     Out << 'S';
@@ -2065,11 +2187,11 @@
   // e.g.
   // void (*x)(void) will not form a backreference with void x(void)
   void *TypePtr;
-  if (const auto *DT = T->getAs<DecayedType>()) {
+  if (auto const *DT = T->getAs<DecayedType>()) {
     QualType OriginalType = DT->getOriginalType();
     // All decayed ArrayTypes should be treated identically; as-if they were
     // a decayed IncompleteArrayType.
-    if (const auto *AT = getASTContext().getAsArrayType(OriginalType))
+    if (auto const *AT = getASTContext().getAsArrayType(OriginalType))
       OriginalType = getASTContext().getIncompleteArrayType(
           AT->getElementType(), AT->getSizeModifier(),
           AT->getIndexTypeCVRQualifiers());
@@ -2107,12 +2229,12 @@
 }
 
 void MicrosoftCXXNameMangler::manglePassObjectSizeArg(
-    const PassObjectSizeAttr *POSA) {
+    PassObjectSizeAttr const *POSA) {
   int Type = POSA->getType();
   bool Dynamic = POSA->isDynamic();
 
   auto Iter = PassObjectSizeArgs.insert({Type, Dynamic}).first;
-  auto *TypePtr = (const void *)&*Iter;
+  auto *TypePtr = (void const *)&*Iter;
   ArgBackRefMap::iterator Found = FunArgBackReferences.find(TypePtr);
 
   if (Found == FunArgBackReferences.end()) {
@@ -2209,7 +2331,7 @@
   T = T.getDesugaredType(getASTContext());
   Qualifiers Quals = T.getLocalQualifiers();
 
-  if (const ArrayType *AT = getASTContext().getAsArrayType(T)) {
+  if (ArrayType const *AT = getASTContext().getAsArrayType(T)) {
     // If there were any Quals, getAsArrayType() pushed them onto the array
     // element type.
     if (QMM == QMM_Mangle)
@@ -2229,7 +2351,7 @@
       Quals = Quals.withoutObjCLifetime();
     break;
   case QMM_Mangle:
-    if (const FunctionType *FT = dyn_cast<FunctionType>(T)) {
+    if (FunctionType const *FT = dyn_cast<FunctionType>(T)) {
       Out << '6';
       mangleFunctionType(FT);
       return;
@@ -2254,17 +2376,17 @@
     break;
   }
 
-  const Type *ty = T.getTypePtr();
+  Type const *ty = T.getTypePtr();
 
   switch (ty->getTypeClass()) {
 #define ABSTRACT_TYPE(CLASS, PARENT)
-#define NON_CANONICAL_TYPE(CLASS, PARENT) \
-  case Type::CLASS: \
-    llvm_unreachable("can't mangle non-canonical type " #CLASS "Type"); \
+#define NON_CANONICAL_TYPE(CLASS, PARENT)                                      \
+  case Type::CLASS:                                                            \
+    llvm_unreachable("can't mangle non-canonical type " #CLASS "Type");        \
     return;
-#define TYPE(CLASS, PARENT) \
-  case Type::CLASS: \
-    mangleType(cast<CLASS##Type>(ty), Quals, Range); \
+#define TYPE(CLASS, PARENT)                                                    \
+  case Type::CLASS:                                                            \
+    mangleType(cast<CLASS##Type>(ty), Quals, Range);                           \
     break;
 #include "clang/AST/TypeNodes.inc"
 #undef ABSTRACT_TYPE
@@ -2273,7 +2395,7 @@
   }
 }
 
-void MicrosoftCXXNameMangler::mangleType(const BuiltinType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(BuiltinType const *T, Qualifiers,
                                          SourceRange Range) {
   //  <type>         ::= <builtin-type>
   //  <builtin-type> ::= X  # void
@@ -2374,8 +2496,7 @@
     break;
 
 #define BUILTIN_TYPE(Id, SingletonId)
-#define PLACEHOLDER_TYPE(Id, SingletonId) \
-  case BuiltinType::Id:
+#define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
   case BuiltinType::Dependent:
     llvm_unreachable("placeholder types shouldn't get to name mangling");
@@ -2390,9 +2511,9 @@
     mangleArtificialTagType(TTK_Struct, "objc_selector");
     break;
 
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-  case BuiltinType::Id: \
-    Out << "PAUocl_" #ImgType "_" #Suffix "@@"; \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
+  case BuiltinType::Id:                                                        \
+    Out << "PAUocl_" #ImgType "_" #Suffix "@@";                                \
     break;
 #include "clang/Basic/OpenCLImageTypes.def"
   case BuiltinType::OCLSampler:
@@ -2415,9 +2536,9 @@
     Out << "PA";
     mangleArtificialTagType(TTK_Struct, "ocl_reserveid");
     break;
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-  case BuiltinType::Id: \
-    mangleArtificialTagType(TTK_Struct, "ocl_" #ExtType); \
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext)                                      \
+  case BuiltinType::Id:                                                        \
+    mangleArtificialTagType(TTK_Struct, "ocl_" #ExtType);                      \
     break;
 #include "clang/Basic/OpenCLExtensionTypes.def"
 
@@ -2433,11 +2554,9 @@
     mangleArtificialTagType(TTK_Struct, "_Half", {"__clang"});
     break;
 
-#define SVE_TYPE(Name, Id, SingletonId) \
-  case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-  case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
@@ -2479,7 +2598,7 @@
 }
 
 // <type>          ::= <function-type>
-void MicrosoftCXXNameMangler::mangleType(const FunctionProtoType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(FunctionProtoType const *T, Qualifiers,
                                          SourceRange) {
   // Structors only appear in decls, so at this point we know it's not a
   // structor type.
@@ -2492,27 +2611,28 @@
     mangleFunctionType(T);
   }
 }
-void MicrosoftCXXNameMangler::mangleType(const FunctionNoProtoType *T,
+void MicrosoftCXXNameMangler::mangleType(FunctionNoProtoType const *T,
                                          Qualifiers, SourceRange) {
   Out << "$$A6";
   mangleFunctionType(T);
 }
 
-void MicrosoftCXXNameMangler::mangleFunctionType(const FunctionType *T,
-                                                 const FunctionDecl *D,
+void MicrosoftCXXNameMangler::mangleFunctionType(FunctionType const *T,
+                                                 FunctionDecl const *D,
                                                  bool ForceThisQuals,
                                                  bool MangleExceptionSpec) {
   // <function-type> ::= <this-cvr-qualifiers> <calling-convention>
   //                     <return-type> <argument-list> <throw-spec>
-  const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(T);
+  FunctionProtoType const *Proto = dyn_cast<FunctionProtoType>(T);
 
   SourceRange Range;
-  if (D) Range = D->getSourceRange();
+  if (D)
+    Range = D->getSourceRange();
 
   bool IsInLambda = false;
   bool IsStructor = false, HasThisQuals = ForceThisQuals, IsCtorClosure = false;
   CallingConv CC = T->getCallConv();
-  if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(D)) {
+  if (CXXMethodDecl const *MD = dyn_cast_or_null<CXXMethodDecl>(D)) {
     if (MD->getParent()->isLambda())
       IsInLambda = true;
     if (MD->isInstance())
@@ -2593,7 +2713,7 @@
       // can differ by their calling convention and are typically deduced.  So
       // we make sure that this type gets mangled properly.
       mangleType(ResultType, Range, QMM_Result);
-    } else if (const auto *AT = dyn_cast_or_null<AutoType>(
+    } else if (auto const *AT = dyn_cast_or_null<AutoType>(
                    ResultType->getContainedAutoType())) {
       Out << '?';
       mangleQualifiers(ResultType.getLocalQualifiers(), /*IsMember=*/false);
@@ -2634,7 +2754,7 @@
       // necessary to just cross our fingers and hope this type+namespace
       // combination doesn't conflict with anything?
       if (D)
-        if (const auto *P = D->getParamDecl(I)->getAttr<PassObjectSizeAttr>())
+        if (auto const *P = D->getParamDecl(I)->getAttr<PassObjectSizeAttr>())
           manglePassObjectSizeArg(P);
     }
     // <builtin-type>      ::= Z  # ellipsis
@@ -2652,7 +2772,7 @@
     Out << 'Z';
 }
 
-void MicrosoftCXXNameMangler::mangleFunctionClass(const FunctionDecl *FD) {
+void MicrosoftCXXNameMangler::mangleFunctionClass(FunctionDecl const *FD) {
   // <function-class>  ::= <member-function> E? # E designates a 64-bit 'this'
   //                                            # pointer. in 64-bit mode *all*
   //                                            # 'this' pointers are 64-bit.
@@ -2677,7 +2797,7 @@
   //                   ::= V # public: virtual far
   // <global-function> ::= Y # global near
   //                   ::= Z # global far
-  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
+  if (CXXMethodDecl const *MD = dyn_cast<CXXMethodDecl>(FD)) {
     bool IsVirtual = MD->isVirtual();
     // When mangling vbase destructor variants, ignore whether or not the
     // underlying destructor was defined to be virtual.
@@ -2686,31 +2806,31 @@
       IsVirtual = false;
     }
     switch (MD->getAccess()) {
-      case AS_none:
-        llvm_unreachable("Unsupported access specifier");
-      case AS_private:
-        if (MD->isStatic())
-          Out << 'C';
-        else if (IsVirtual)
-          Out << 'E';
-        else
-          Out << 'A';
-        break;
-      case AS_protected:
-        if (MD->isStatic())
-          Out << 'K';
-        else if (IsVirtual)
-          Out << 'M';
-        else
-          Out << 'I';
-        break;
-      case AS_public:
-        if (MD->isStatic())
-          Out << 'S';
-        else if (IsVirtual)
-          Out << 'U';
-        else
-          Out << 'Q';
+    case AS_none:
+      llvm_unreachable("Unsupported access specifier");
+    case AS_private:
+      if (MD->isStatic())
+        Out << 'C';
+      else if (IsVirtual)
+        Out << 'E';
+      else
+        Out << 'A';
+      break;
+    case AS_protected:
+      if (MD->isStatic())
+        Out << 'K';
+      else if (IsVirtual)
+        Out << 'M';
+      else
+        Out << 'I';
+      break;
+    case AS_public:
+      if (MD->isStatic())
+        Out << 'S';
+      else if (IsVirtual)
+        Out << 'U';
+      else
+        Out << 'Q';
     }
   } else {
     Out << 'Y';
@@ -2739,28 +2859,48 @@
   // them.)
 
   switch (CC) {
-    default:
-      llvm_unreachable("Unsupported CC for mangling");
-    case CC_Win64:
-    case CC_X86_64SysV:
-    case CC_C: Out << 'A'; break;
-    case CC_X86Pascal: Out << 'C'; break;
-    case CC_X86ThisCall: Out << 'E'; break;
-    case CC_X86StdCall: Out << 'G'; break;
-    case CC_X86FastCall: Out << 'I'; break;
-    case CC_X86VectorCall: Out << 'Q'; break;
-    case CC_Swift: Out << 'S'; break;
-    case CC_SwiftAsync: Out << 'W'; break;
-    case CC_PreserveMost: Out << 'U'; break;
-    case CC_X86RegCall: Out << 'w'; break;
-  }
-}
-void MicrosoftCXXNameMangler::mangleCallingConvention(const FunctionType *T) {
+  default:
+    llvm_unreachable("Unsupported CC for mangling");
+  case CC_Win64:
+  case CC_X86_64SysV:
+  case CC_C:
+    Out << 'A';
+    break;
+  case CC_X86Pascal:
+    Out << 'C';
+    break;
+  case CC_X86ThisCall:
+    Out << 'E';
+    break;
+  case CC_X86StdCall:
+    Out << 'G';
+    break;
+  case CC_X86FastCall:
+    Out << 'I';
+    break;
+  case CC_X86VectorCall:
+    Out << 'Q';
+    break;
+  case CC_Swift:
+    Out << 'S';
+    break;
+  case CC_SwiftAsync:
+    Out << 'W';
+    break;
+  case CC_PreserveMost:
+    Out << 'U';
+    break;
+  case CC_X86RegCall:
+    Out << 'w';
+    break;
+  }
+}
+void MicrosoftCXXNameMangler::mangleCallingConvention(FunctionType const *T) {
   mangleCallingConvention(T->getCallConv());
 }
 
 void MicrosoftCXXNameMangler::mangleThrowSpecification(
-                                                const FunctionProtoType *FT) {
+    FunctionProtoType const *FT) {
   // <throw-spec> ::= Z # (default)
   //              ::= _E # noexcept
   if (FT->canThrow())
@@ -2769,15 +2909,15 @@
     Out << "_E";
 }
 
-void MicrosoftCXXNameMangler::mangleType(const UnresolvedUsingType *T,
+void MicrosoftCXXNameMangler::mangleType(UnresolvedUsingType const *T,
                                          Qualifiers, SourceRange Range) {
   // Probably should be mangled as a template instantiation; need to see what
   // VC does first.
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this unresolved dependent type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID =
+      Diags.getCustomDiagID(DiagnosticsEngine::Error,
+                            "cannot mangle this unresolved dependent type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
 // <type>        ::= <union-type> | <struct-type> | <class-type> | <enum-type>
@@ -2787,30 +2927,30 @@
 // <enum-type>   ::= W4 <name>
 void MicrosoftCXXNameMangler::mangleTagTypeKind(TagTypeKind TTK) {
   switch (TTK) {
-    case TTK_Union:
-      Out << 'T';
-      break;
-    case TTK_Struct:
-    case TTK_Interface:
-      Out << 'U';
-      break;
-    case TTK_Class:
-      Out << 'V';
-      break;
-    case TTK_Enum:
-      Out << "W4";
-      break;
+  case TTK_Union:
+    Out << 'T';
+    break;
+  case TTK_Struct:
+  case TTK_Interface:
+    Out << 'U';
+    break;
+  case TTK_Class:
+    Out << 'V';
+    break;
+  case TTK_Enum:
+    Out << "W4";
+    break;
   }
 }
-void MicrosoftCXXNameMangler::mangleType(const EnumType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(EnumType const *T, Qualifiers,
                                          SourceRange) {
   mangleType(cast<TagType>(T)->getDecl());
 }
-void MicrosoftCXXNameMangler::mangleType(const RecordType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(RecordType const *T, Qualifiers,
                                          SourceRange) {
   mangleType(cast<TagType>(T)->getDecl());
 }
-void MicrosoftCXXNameMangler::mangleType(const TagDecl *TD) {
+void MicrosoftCXXNameMangler::mangleType(TagDecl const *TD) {
   mangleTagTypeKind(TD->getTagKind());
   mangleName(TD);
 }
@@ -2839,56 +2979,57 @@
 // It's supposed to be the other way around, but for some strange reason, it
 // isn't. Today this behavior is retained for the sole purpose of backwards
 // compatibility.
-void MicrosoftCXXNameMangler::mangleDecayedArrayType(const ArrayType *T) {
+void MicrosoftCXXNameMangler::mangleDecayedArrayType(ArrayType const *T) {
   // This isn't a recursive mangling, so now we have to do it all in this
   // one call.
   manglePointerCVQualifiers(T->getElementType().getQualifiers());
   mangleType(T->getElementType(), SourceRange());
 }
-void MicrosoftCXXNameMangler::mangleType(const ConstantArrayType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(ConstantArrayType const *T, Qualifiers,
                                          SourceRange) {
   llvm_unreachable("Should have been special cased");
 }
-void MicrosoftCXXNameMangler::mangleType(const VariableArrayType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(VariableArrayType const *T, Qualifiers,
                                          SourceRange) {
   llvm_unreachable("Should have been special cased");
 }
-void MicrosoftCXXNameMangler::mangleType(const DependentSizedArrayType *T,
+void MicrosoftCXXNameMangler::mangleType(DependentSizedArrayType const *T,
                                          Qualifiers, SourceRange) {
   llvm_unreachable("Should have been special cased");
 }
-void MicrosoftCXXNameMangler::mangleType(const IncompleteArrayType *T,
+void MicrosoftCXXNameMangler::mangleType(IncompleteArrayType const *T,
                                          Qualifiers, SourceRange) {
   llvm_unreachable("Should have been special cased");
 }
-void MicrosoftCXXNameMangler::mangleArrayType(const ArrayType *T) {
+void MicrosoftCXXNameMangler::mangleArrayType(ArrayType const *T) {
   QualType ElementTy(T, 0);
   SmallVector<llvm::APInt, 3> Dimensions;
   for (;;) {
     if (ElementTy->isConstantArrayType()) {
-      const ConstantArrayType *CAT =
+      ConstantArrayType const *CAT =
           getASTContext().getAsConstantArrayType(ElementTy);
       Dimensions.push_back(CAT->getSize());
       ElementTy = CAT->getElementType();
     } else if (ElementTy->isIncompleteArrayType()) {
-      const IncompleteArrayType *IAT =
+      IncompleteArrayType const *IAT =
           getASTContext().getAsIncompleteArrayType(ElementTy);
       Dimensions.push_back(llvm::APInt(32, 0));
       ElementTy = IAT->getElementType();
     } else if (ElementTy->isVariableArrayType()) {
-      const VariableArrayType *VAT =
-        getASTContext().getAsVariableArrayType(ElementTy);
+      VariableArrayType const *VAT =
+          getASTContext().getAsVariableArrayType(ElementTy);
       Dimensions.push_back(llvm::APInt(32, 0));
       ElementTy = VAT->getElementType();
     } else if (ElementTy->isDependentSizedArrayType()) {
       // The dependent expression has to be folded into a constant (TODO).
-      const DependentSizedArrayType *DSAT =
-        getASTContext().getAsDependentSizedArrayType(ElementTy);
+      DependentSizedArrayType const *DSAT =
+          getASTContext().getAsDependentSizedArrayType(ElementTy);
       DiagnosticsEngine &Diags = Context.getDiags();
-      unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-        "cannot mangle this dependent-length array yet");
+      unsigned DiagID = Diags.getCustomDiagID(
+          DiagnosticsEngine::Error,
+          "cannot mangle this dependent-length array yet");
       Diags.Report(DSAT->getSizeExpr()->getExprLoc(), DiagID)
-        << DSAT->getBracketsRange();
+          << DSAT->getBracketsRange();
       return;
     } else {
       break;
@@ -2897,7 +3038,7 @@
   Out << 'Y';
   // <dimension-count> ::= <number> # number of extra dimensions
   mangleNumber(Dimensions.size());
-  for (const llvm::APInt &Dimension : Dimensions)
+  for (llvm::APInt const &Dimension : Dimensions)
     mangleNumber(Dimension.getLimitedValue());
   mangleType(ElementTy, SourceRange(), QMM_Escape);
 }
@@ -2905,12 +3046,12 @@
 // <type>                   ::= <pointer-to-member-type>
 // <pointer-to-member-type> ::= <pointer-cvr-qualifiers> <cvr-qualifiers>
 //                                                          <class name> <type>
-void MicrosoftCXXNameMangler::mangleType(const MemberPointerType *T,
+void MicrosoftCXXNameMangler::mangleType(MemberPointerType const *T,
                                          Qualifiers Quals, SourceRange Range) {
   QualType PointeeType = T->getPointeeType();
   manglePointerCVQualifiers(Quals);
   manglePointerExtQualifiers(Quals, PointeeType);
-  if (const FunctionProtoType *FPT = PointeeType->getAs<FunctionProtoType>()) {
+  if (FunctionProtoType const *FPT = PointeeType->getAs<FunctionProtoType>()) {
     Out << '8';
     mangleName(T->getClass()->castAs<RecordType>()->getDecl());
     mangleFunctionType(FPT, nullptr, true);
@@ -2921,28 +3062,28 @@
   }
 }
 
-void MicrosoftCXXNameMangler::mangleType(const TemplateTypeParmType *T,
+void MicrosoftCXXNameMangler::mangleType(TemplateTypeParmType const *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this template type parameter type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error,
+      "cannot mangle this template type parameter type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const SubstTemplateTypeParmPackType *T,
+void MicrosoftCXXNameMangler::mangleType(SubstTemplateTypeParmPackType const *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this substituted parameter pack yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error,
+      "cannot mangle this substituted parameter pack yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
 // <type> ::= <pointer-type>
 // <pointer-type> ::= E? <pointer-cvr-qualifiers> <cvr-qualifiers> <type>
 //                       # the E is required for 64-bit non-static pointers
-void MicrosoftCXXNameMangler::mangleType(const PointerType *T, Qualifiers Quals,
+void MicrosoftCXXNameMangler::mangleType(PointerType const *T, Qualifiers Quals,
                                          SourceRange Range) {
   QualType PointeeType = T->getPointeeType();
   manglePointerCVQualifiers(Quals);
@@ -2957,7 +3098,7 @@
     mangleAddressSpaceType(PointeeType, PointeeType.getQualifiers(), Range);
 }
 
-void MicrosoftCXXNameMangler::mangleType(const ObjCObjectPointerType *T,
+void MicrosoftCXXNameMangler::mangleType(ObjCObjectPointerType const *T,
                                          Qualifiers Quals, SourceRange Range) {
   QualType PointeeType = T->getPointeeType();
   switch (Quals.getObjCLifetime()) {
@@ -2977,7 +3118,7 @@
 // <type> ::= <reference-type>
 // <reference-type> ::= A E? <cvr-qualifiers> <type>
 //                 # the E is required for 64-bit non-static lvalue references
-void MicrosoftCXXNameMangler::mangleType(const LValueReferenceType *T,
+void MicrosoftCXXNameMangler::mangleType(LValueReferenceType const *T,
                                          Qualifiers Quals, SourceRange Range) {
   QualType PointeeType = T->getPointeeType();
   assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!");
@@ -2989,7 +3130,7 @@
 // <type> ::= <r-value-reference-type>
 // <r-value-reference-type> ::= $$Q E? <cvr-qualifiers> <type>
 //                 # the E is required for 64-bit non-static rvalue references
-void MicrosoftCXXNameMangler::mangleType(const RValueReferenceType *T,
+void MicrosoftCXXNameMangler::mangleType(RValueReferenceType const *T,
                                          Qualifiers Quals, SourceRange Range) {
   QualType PointeeType = T->getPointeeType();
   assert(!Quals.hasConst() && !Quals.hasVolatile() && "unexpected qualifier!");
@@ -2998,7 +3139,7 @@
   mangleType(PointeeType, Range);
 }
 
-void MicrosoftCXXNameMangler::mangleType(const ComplexType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(ComplexType const *T, Qualifiers,
                                          SourceRange Range) {
   QualType ElementType = T->getElementType();
 
@@ -3018,7 +3159,7 @@
 // (It doesn't matter for Objective-C types and the like that cl.exe doesn't
 // support.)
 bool MicrosoftCXXNameMangler::isArtificialTagType(QualType T) const {
-  const Type *ty = T.getTypePtr();
+  Type const *ty = T.getTypePtr();
   switch (ty->getTypeClass()) {
   default:
     return false;
@@ -3032,9 +3173,9 @@
   }
 }
 
-void MicrosoftCXXNameMangler::mangleType(const VectorType *T, Qualifiers Quals,
+void MicrosoftCXXNameMangler::mangleType(VectorType const *T, Qualifiers Quals,
                                          SourceRange Range) {
-  const BuiltinType *ET = T->getElementType()->getAs<BuiltinType>();
+  BuiltinType const *ET = T->getElementType()->getAs<BuiltinType>();
   assert(ET && "vectors with non-builtin elements are unsupported");
   uint64_t Width = getASTContext().getTypeSize(T);
   // Pattern match exactly the typedefs in our intrinsic headers.  Anything that
@@ -3050,7 +3191,8 @@
         else if (ET->getKind() == BuiltinType::LongLong)
           mangleArtificialTagType(TTK_Union, "__m" + llvm::utostr(Width) + 'i');
         else if (ET->getKind() == BuiltinType::Double)
-          mangleArtificialTagType(TTK_Struct, "__m" + llvm::utostr(Width) + 'd');
+          mangleArtificialTagType(TTK_Struct,
+                                  "__m" + llvm::utostr(Width) + 'd');
       }
     }
   }
@@ -3073,12 +3215,12 @@
   }
 }
 
-void MicrosoftCXXNameMangler::mangleType(const ExtVectorType *T,
+void MicrosoftCXXNameMangler::mangleType(ExtVectorType const *T,
                                          Qualifiers Quals, SourceRange Range) {
-  mangleType(static_cast<const VectorType *>(T), Quals, Range);
+  mangleType(static_cast<VectorType const *>(T), Quals, Range);
 }
 
-void MicrosoftCXXNameMangler::mangleType(const DependentVectorType *T,
+void MicrosoftCXXNameMangler::mangleType(DependentVectorType const *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
@@ -3087,16 +3229,16 @@
   Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const DependentSizedExtVectorType *T,
+void MicrosoftCXXNameMangler::mangleType(DependentSizedExtVectorType const *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this dependent-sized extended vector type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error,
+      "cannot mangle this dependent-sized extended vector type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const ConstantMatrixType *T,
+void MicrosoftCXXNameMangler::mangleType(ConstantMatrixType const *T,
                                          Qualifiers quals, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
@@ -3104,7 +3246,7 @@
   Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const DependentSizedMatrixType *T,
+void MicrosoftCXXNameMangler::mangleType(DependentSizedMatrixType const *T,
                                          Qualifiers quals, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
@@ -3113,7 +3255,7 @@
   Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const DependentAddressSpaceType *T,
+void MicrosoftCXXNameMangler::mangleType(DependentAddressSpaceType const *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
@@ -3122,14 +3264,14 @@
   Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const ObjCInterfaceType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(ObjCInterfaceType const *T, Qualifiers,
                                          SourceRange) {
   // ObjC interfaces have structs underlying them.
   mangleTagTypeKind(TTK_Struct);
   mangleName(T->getDecl());
 }
 
-void MicrosoftCXXNameMangler::mangleType(const ObjCObjectType *T,
+void MicrosoftCXXNameMangler::mangleType(ObjCObjectType const *T,
                                          Qualifiers Quals, SourceRange Range) {
   if (T->isKindOfType())
     return mangleObjCKindOfType(T, Quals, Range);
@@ -3155,11 +3297,11 @@
   else
     mangleSourceName(T->getInterface()->getName());
 
-  for (const auto &Q : T->quals())
+  for (auto const &Q : T->quals())
     mangleObjCProtocol(Q);
 
   if (T->isSpecialized())
-    for (const auto &TA : T->getTypeArgs())
+    for (auto const &TA : T->getTypeArgs())
       mangleType(TA, Range, QMM_Drop);
 
   Out << '@';
@@ -3171,7 +3313,7 @@
   NameBackReferences.swap(OuterTemplateContext);
 }
 
-void MicrosoftCXXNameMangler::mangleType(const BlockPointerType *T,
+void MicrosoftCXXNameMangler::mangleType(BlockPointerType const *T,
                                          Qualifiers Quals, SourceRange Range) {
   QualType PointeeType = T->getPointeeType();
   manglePointerCVQualifiers(Quals);
@@ -3182,107 +3324,100 @@
   mangleFunctionType(PointeeType->castAs<FunctionProtoType>());
 }
 
-void MicrosoftCXXNameMangler::mangleType(const InjectedClassNameType *,
+void MicrosoftCXXNameMangler::mangleType(InjectedClassNameType const *,
                                          Qualifiers, SourceRange) {
   llvm_unreachable("Cannot mangle injected class name type.");
 }
 
-void MicrosoftCXXNameMangler::mangleType(const TemplateSpecializationType *T,
+void MicrosoftCXXNameMangler::mangleType(TemplateSpecializationType const *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this template specialization type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error,
+      "cannot mangle this template specialization type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const DependentNameType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(DependentNameType const *T, Qualifiers,
                                          SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this dependent name type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error, "cannot mangle this dependent name type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
 void MicrosoftCXXNameMangler::mangleType(
-    const DependentTemplateSpecializationType *T, Qualifiers,
+    DependentTemplateSpecializationType const *T, Qualifiers,
     SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this dependent template specialization type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error,
+      "cannot mangle this dependent template specialization type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const PackExpansionType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(PackExpansionType const *T, Qualifiers,
                                          SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this pack expansion yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error, "cannot mangle this pack expansion yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const TypeOfType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(TypeOfType const *T, Qualifiers,
                                          SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this typeof(type) yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error, "cannot mangle this typeof(type) yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const TypeOfExprType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(TypeOfExprType const *T, Qualifiers,
                                          SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this typeof(expression) yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error, "cannot mangle this typeof(expression) yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const DecltypeType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(DecltypeType const *T, Qualifiers,
                                          SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this decltype() yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+                                          "cannot mangle this decltype() yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const UnaryTransformType *T,
+void MicrosoftCXXNameMangler::mangleType(UnaryTransformType const *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this unary transform type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error, "cannot mangle this unary transform type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const AutoType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(AutoType const *T, Qualifiers,
                                          SourceRange Range) {
   assert(T->getDeducedType().isNull() && "expecting a dependent type!");
 
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this 'auto' type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+                                          "cannot mangle this 'auto' type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
 void MicrosoftCXXNameMangler::mangleType(
-    const DeducedTemplateSpecializationType *T, Qualifiers, SourceRange Range) {
+    DeducedTemplateSpecializationType const *T, Qualifiers, SourceRange Range) {
   assert(T->getDeducedType().isNull() && "expecting a dependent type!");
 
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this deduced class template specialization type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error,
+      "cannot mangle this deduced class template specialization type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const AtomicType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(AtomicType const *T, Qualifiers,
                                          SourceRange Range) {
   QualType ValueType = T->getValueType();
 
@@ -3296,7 +3431,7 @@
   mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
 }
 
-void MicrosoftCXXNameMangler::mangleType(const PipeType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(PipeType const *T, Qualifiers,
                                          SourceRange Range) {
   QualType ElementType = T->getElementType();
 
@@ -3313,7 +3448,7 @@
 
 void MicrosoftMangleContextImpl::mangleCXXName(GlobalDecl GD,
                                                raw_ostream &Out) {
-  const NamedDecl *D = cast<NamedDecl>(GD.getDecl());
+  NamedDecl const *D = cast<NamedDecl>(GD.getDecl());
   PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
                                  getASTContext().getSourceManager(),
                                  "Mangling declaration");
@@ -3336,7 +3471,7 @@
   return Mangler.mangle(D);
 }
 
-void MicrosoftCXXNameMangler::mangleType(const ExtIntType *T, Qualifiers,
+void MicrosoftCXXNameMangler::mangleType(ExtIntType const *T, Qualifiers,
                                          SourceRange Range) {
   llvm::SmallString<64> TemplateMangling;
   llvm::raw_svector_ostream Stream(TemplateMangling);
@@ -3351,7 +3486,7 @@
   mangleArtificialTagType(TTK_Struct, TemplateMangling, {"__clang"});
 }
 
-void MicrosoftCXXNameMangler::mangleType(const DependentExtIntType *T,
+void MicrosoftCXXNameMangler::mangleType(DependentExtIntType const *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(
@@ -3384,7 +3519,7 @@
 // <vtordispex-shift>   ::= <offset-to-vbptr> <vbase-offset-offset>
 //                          <offset-to-vtordisp>
 static void mangleThunkThisAdjustment(AccessSpecifier AS,
-                                      const ThisAdjustment &Adjustment,
+                                      ThisAdjustment const &Adjustment,
                                       MicrosoftCXXNameMangler &Mangler,
                                       raw_ostream &Out) {
   if (!Adjustment.Virtual.isEmpty()) {
@@ -3448,7 +3583,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleVirtualMemPtrThunk(
-    const CXXMethodDecl *MD, const MethodVFTableLocation &ML,
+    CXXMethodDecl const *MD, MethodVFTableLocation const &ML,
     raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
@@ -3456,8 +3591,8 @@
   Mangler.mangleVirtualMemPtrThunk(MD, ML);
 }
 
-void MicrosoftMangleContextImpl::mangleThunk(const CXXMethodDecl *MD,
-                                             const ThunkInfo &Thunk,
+void MicrosoftMangleContextImpl::mangleThunk(CXXMethodDecl const *MD,
+                                             ThunkInfo const &Thunk,
                                              raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
@@ -3474,14 +3609,14 @@
     assert(Thunk.Method != nullptr &&
            "Thunk info should hold the overridee decl");
 
-  const CXXMethodDecl *DeclForFPT = Thunk.Method ? Thunk.Method : MD;
-  Mangler.mangleFunctionType(
-      DeclForFPT->getType()->castAs<FunctionProtoType>(), MD);
+  CXXMethodDecl const *DeclForFPT = Thunk.Method ? Thunk.Method : MD;
+  Mangler.mangleFunctionType(DeclForFPT->getType()->castAs<FunctionProtoType>(),
+                             MD);
 }
 
 void MicrosoftMangleContextImpl::mangleCXXDtorThunk(
-    const CXXDestructorDecl *DD, CXXDtorType Type,
-    const ThisAdjustment &Adjustment, raw_ostream &Out) {
+    CXXDestructorDecl const *DD, CXXDtorType Type,
+    ThisAdjustment const &Adjustment, raw_ostream &Out) {
   // FIXME: Actually, the dtor thunk should be emitted for vector deleting
   // dtors rather than scalar deleting dtors. Just use the vector deleting dtor
   // mangling manually until we support both deleting dtor types.
@@ -3495,7 +3630,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleCXXVFTable(
-    const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
+    CXXRecordDecl const *Derived, ArrayRef<CXXRecordDecl const *> BasePath,
     raw_ostream &Out) {
   // <mangled-name> ::= ?_7 <class-name> <storage-class>
   //                    <cvr-qualifiers> [<name>] @
@@ -3509,13 +3644,13 @@
     Mangler.getStream() << "??_7";
   Mangler.mangleName(Derived);
   Mangler.getStream() << "6B"; // '6' for vftable, 'B' for const.
-  for (const CXXRecordDecl *RD : BasePath)
+  for (CXXRecordDecl const *RD : BasePath)
     Mangler.mangleName(RD);
   Mangler.getStream() << '@';
 }
 
 void MicrosoftMangleContextImpl::mangleCXXVBTable(
-    const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
+    CXXRecordDecl const *Derived, ArrayRef<CXXRecordDecl const *> BasePath,
     raw_ostream &Out) {
   // <mangled-name> ::= ?_8 <class-name> <storage-class>
   //                    <cvr-qualifiers> [<name>] @
@@ -3525,8 +3660,8 @@
   MicrosoftCXXNameMangler Mangler(*this, MHO);
   Mangler.getStream() << "??_8";
   Mangler.mangleName(Derived);
-  Mangler.getStream() << "7B";  // '7' for vbtable, 'B' for const.
-  for (const CXXRecordDecl *RD : BasePath)
+  Mangler.getStream() << "7B"; // '7' for vbtable, 'B' for const.
+  for (CXXRecordDecl const *RD : BasePath)
     Mangler.mangleName(RD);
   Mangler.getStream() << '@';
 }
@@ -3547,7 +3682,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleCXXVirtualDisplacementMap(
-    const CXXRecordDecl *SrcRD, const CXXRecordDecl *DstRD, raw_ostream &Out) {
+    CXXRecordDecl const *SrcRD, CXXRecordDecl const *DstRD, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
   Mangler.getStream() << "??_K";
@@ -3584,7 +3719,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleCXXCatchableType(
-    QualType T, const CXXConstructorDecl *CD, CXXCtorType CT, uint32_t Size,
+    QualType T, CXXConstructorDecl const *CD, CXXCtorType CT, uint32_t Size,
     uint32_t NVOffset, int32_t VBPtrOffset, uint32_t VBIndex,
     raw_ostream &Out) {
   MicrosoftCXXNameMangler Mangler(*this, Out);
@@ -3629,7 +3764,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassDescriptor(
-    const CXXRecordDecl *Derived, uint32_t NVOffset, int32_t VBPtrOffset,
+    CXXRecordDecl const *Derived, uint32_t NVOffset, int32_t VBPtrOffset,
     uint32_t VBTableOffset, uint32_t Flags, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
@@ -3643,7 +3778,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleCXXRTTIBaseClassArray(
-    const CXXRecordDecl *Derived, raw_ostream &Out) {
+    CXXRecordDecl const *Derived, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
   Mangler.getStream() << "??_R2";
@@ -3652,7 +3787,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleCXXRTTIClassHierarchyDescriptor(
-    const CXXRecordDecl *Derived, raw_ostream &Out) {
+    CXXRecordDecl const *Derived, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
   Mangler.getStream() << "??_R3";
@@ -3661,7 +3796,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleCXXRTTICompleteObjectLocator(
-    const CXXRecordDecl *Derived, ArrayRef<const CXXRecordDecl *> BasePath,
+    CXXRecordDecl const *Derived, ArrayRef<CXXRecordDecl const *> BasePath,
     raw_ostream &Out) {
   // <mangled-name> ::= ?_R4 <class-name> <storage-class>
   //                    <cvr-qualifiers> [<name>] @
@@ -3684,7 +3819,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleSEHFilterExpression(
-    const NamedDecl *EnclosingDecl, raw_ostream &Out) {
+    NamedDecl const *EnclosingDecl, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
   // The function body is in the same comdat as the function with the handler,
@@ -3696,7 +3831,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleSEHFinallyBlock(
-    const NamedDecl *EnclosingDecl, raw_ostream &Out) {
+    NamedDecl const *EnclosingDecl, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
   // The function body is in the same comdat as the function with the handler,
@@ -3716,7 +3851,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleReferenceTemporary(
-    const VarDecl *VD, unsigned ManglingNumber, raw_ostream &Out) {
+    VarDecl const *VD, unsigned ManglingNumber, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
 
@@ -3725,7 +3860,7 @@
 }
 
 void MicrosoftMangleContextImpl::mangleThreadSafeStaticGuardVariable(
-    const VarDecl *VD, unsigned GuardNum, raw_ostream &Out) {
+    VarDecl const *VD, unsigned GuardNum, raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
   MicrosoftCXXNameMangler Mangler(*this, MHO);
 
@@ -3734,7 +3869,7 @@
   Mangler.getStream() << "@4HA";
 }
 
-void MicrosoftMangleContextImpl::mangleStaticGuardVariable(const VarDecl *VD,
+void MicrosoftMangleContextImpl::mangleStaticGuardVariable(VarDecl const *VD,
                                                            raw_ostream &Out) {
   // <guard-name> ::= ?_B <postfix> @5 <scope-depth>
   //              ::= ?__J <postfix> @5 <scope-depth>
@@ -3768,7 +3903,7 @@
     Mangler.mangleNumber(ScopeDepth);
 }
 
-void MicrosoftMangleContextImpl::mangleInitFiniStub(const VarDecl *D,
+void MicrosoftMangleContextImpl::mangleInitFiniStub(VarDecl const *D,
                                                     char CharCode,
                                                     raw_ostream &Out) {
   msvc_hashing_ostream MHO(Out);
@@ -3787,20 +3922,19 @@
   Mangler.getStream() << "YAXXZ";
 }
 
-void MicrosoftMangleContextImpl::mangleDynamicInitializer(const VarDecl *D,
+void MicrosoftMangleContextImpl::mangleDynamicInitializer(VarDecl const *D,
                                                           raw_ostream &Out) {
   // <initializer-name> ::= ?__E <name> YAXXZ
   mangleInitFiniStub(D, 'E', Out);
 }
 
-void
-MicrosoftMangleContextImpl::mangleDynamicAtExitDestructor(const VarDecl *D,
-                                                          raw_ostream &Out) {
+void MicrosoftMangleContextImpl::mangleDynamicAtExitDestructor(
+    VarDecl const *D, raw_ostream &Out) {
   // <destructor-name> ::= ?__F <name> YAXXZ
   mangleInitFiniStub(D, 'F', Out);
 }
 
-void MicrosoftMangleContextImpl::mangleStringLiteral(const StringLiteral *SL,
+void MicrosoftMangleContextImpl::mangleStringLiteral(StringLiteral const *SL,
                                                      raw_ostream &Out) {
   // <char-type> ::= 0   # char, char16_t, char32_t
   //                     # (little endian char data in mangling)
Index: clang/lib/AST/NSAPI.cpp
===================================================================
--- clang/lib/AST/NSAPI.cpp
+++ clang/lib/AST/NSAPI.cpp
@@ -15,23 +15,16 @@
 using namespace clang;
 
 NSAPI::NSAPI(ASTContext &ctx)
-  : Ctx(ctx), ClassIds(), BOOLId(nullptr), NSIntegerId(nullptr),
-    NSUIntegerId(nullptr), NSASCIIStringEncodingId(nullptr),
-    NSUTF8StringEncodingId(nullptr) {}
+    : Ctx(ctx), ClassIds(), BOOLId(nullptr), NSIntegerId(nullptr),
+      NSUIntegerId(nullptr), NSASCIIStringEncodingId(nullptr),
+      NSUTF8StringEncodingId(nullptr) {}
 
 IdentifierInfo *NSAPI::getNSClassId(NSClassIdKindKind K) const {
-  static const char *ClassName[NumClassIds] = {
-    "NSObject",
-    "NSString",
-    "NSArray",
-    "NSMutableArray",
-    "NSDictionary",
-    "NSMutableDictionary",
-    "NSNumber",
-    "NSMutableSet",
-    "NSMutableOrderedSet",
-    "NSValue"
-  };
+  static char const *ClassName[NumClassIds] = {
+      "NSObject",       "NSString",     "NSArray",
+      "NSMutableArray", "NSDictionary", "NSMutableDictionary",
+      "NSNumber",       "NSMutableSet", "NSMutableOrderedSet",
+      "NSValue"};
 
   if (!ClassIds[K])
     return (ClassIds[K] = &Ctx.Idents.get(ClassName[K]));
@@ -48,22 +41,21 @@
       break;
     case NSStr_stringWithUTF8String:
       Sel = Ctx.Selectors.getUnarySelector(
-                                       &Ctx.Idents.get("stringWithUTF8String"));
+          &Ctx.Idents.get("stringWithUTF8String"));
       break;
     case NSStr_initWithUTF8String:
-      Sel = Ctx.Selectors.getUnarySelector(
-                                       &Ctx.Idents.get("initWithUTF8String"));
+      Sel =
+          Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("initWithUTF8String"));
       break;
     case NSStr_stringWithCStringEncoding: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("stringWithCString"),
-        &Ctx.Idents.get("encoding")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("stringWithCString"),
+                                     &Ctx.Idents.get("encoding")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
     case NSStr_stringWithCString:
-      Sel= Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("stringWithCString"));
+      Sel =
+          Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("stringWithCString"));
       break;
     case NSStr_initWithString:
       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("initWithString"));
@@ -92,10 +84,8 @@
       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("arrayWithObjects"));
       break;
     case NSArr_arrayWithObjectsCount: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("arrayWithObjects"),
-        &Ctx.Idents.get("count")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("arrayWithObjects"),
+                                     &Ctx.Idents.get("count")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
@@ -109,10 +99,8 @@
       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("objectAtIndex"));
       break;
     case NSMutableArr_replaceObjectAtIndex: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("replaceObjectAtIndex"),
-        &Ctx.Idents.get("withObject")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("replaceObjectAtIndex"),
+                                     &Ctx.Idents.get("withObject")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
@@ -120,18 +108,14 @@
       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("addObject"));
       break;
     case NSMutableArr_insertObjectAtIndex: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("insertObject"),
-        &Ctx.Idents.get("atIndex")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("insertObject"),
+                                     &Ctx.Idents.get("atIndex")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
     case NSMutableArr_setObjectAtIndexedSubscript: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("setObject"),
-        &Ctx.Idents.get("atIndexedSubscript")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("setObject"),
+                                     &Ctx.Idents.get("atIndexedSubscript")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
@@ -152,8 +136,7 @@
   return None;
 }
 
-Selector NSAPI::getNSDictionarySelector(
-                                       NSDictionaryMethodKind MK) const {
+Selector NSAPI::getNSDictionarySelector(NSDictionaryMethodKind MK) const {
   if (NSDictionarySelectors[MK].isNull()) {
     Selector Sel;
     switch (MK) {
@@ -162,50 +145,42 @@
       break;
     case NSDict_dictionaryWithDictionary:
       Sel = Ctx.Selectors.getUnarySelector(
-                                   &Ctx.Idents.get("dictionaryWithDictionary"));
+          &Ctx.Idents.get("dictionaryWithDictionary"));
       break;
     case NSDict_dictionaryWithObjectForKey: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("dictionaryWithObject"),
-        &Ctx.Idents.get("forKey")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("dictionaryWithObject"),
+                                     &Ctx.Idents.get("forKey")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
     case NSDict_dictionaryWithObjectsForKeys: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("dictionaryWithObjects"),
-        &Ctx.Idents.get("forKeys")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("dictionaryWithObjects"),
+                                     &Ctx.Idents.get("forKeys")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
     case NSDict_dictionaryWithObjectsForKeysCount: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("dictionaryWithObjects"),
-        &Ctx.Idents.get("forKeys"),
-        &Ctx.Idents.get("count")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("dictionaryWithObjects"),
+                                     &Ctx.Idents.get("forKeys"),
+                                     &Ctx.Idents.get("count")};
       Sel = Ctx.Selectors.getSelector(3, KeyIdents);
       break;
     }
     case NSDict_dictionaryWithObjectsAndKeys:
       Sel = Ctx.Selectors.getUnarySelector(
-                               &Ctx.Idents.get("dictionaryWithObjectsAndKeys"));
+          &Ctx.Idents.get("dictionaryWithObjectsAndKeys"));
       break;
     case NSDict_initWithDictionary:
-      Sel = Ctx.Selectors.getUnarySelector(
-                                         &Ctx.Idents.get("initWithDictionary"));
+      Sel =
+          Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("initWithDictionary"));
       break;
     case NSDict_initWithObjectsAndKeys:
       Sel = Ctx.Selectors.getUnarySelector(
-                                     &Ctx.Idents.get("initWithObjectsAndKeys"));
+          &Ctx.Idents.get("initWithObjectsAndKeys"));
       break;
     case NSDict_initWithObjectsForKeys: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("initWithObjects"),
-        &Ctx.Idents.get("forKeys")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("initWithObjects"),
+                                     &Ctx.Idents.get("forKeys")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
@@ -213,26 +188,20 @@
       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("objectForKey"));
       break;
     case NSMutableDict_setObjectForKey: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("setObject"),
-        &Ctx.Idents.get("forKey")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("setObject"),
+                                     &Ctx.Idents.get("forKey")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
     case NSMutableDict_setObjectForKeyedSubscript: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("setObject"),
-        &Ctx.Idents.get("forKeyedSubscript")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("setObject"),
+                                     &Ctx.Idents.get("forKeyedSubscript")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
     case NSMutableDict_setValueForKey: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("setValue"),
-        &Ctx.Idents.get("forKey")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("setValue"),
+                                     &Ctx.Idents.get("forKey")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
@@ -262,34 +231,26 @@
       Sel = Ctx.Selectors.getUnarySelector(&Ctx.Idents.get("addObject"));
       break;
     case NSOrderedSet_insertObjectAtIndex: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("insertObject"),
-        &Ctx.Idents.get("atIndex")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("insertObject"),
+                                     &Ctx.Idents.get("atIndex")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
     case NSOrderedSet_setObjectAtIndex: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("setObject"),
-        &Ctx.Idents.get("atIndex")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("setObject"),
+                                     &Ctx.Idents.get("atIndex")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
     case NSOrderedSet_setObjectAtIndexedSubscript: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("setObject"),
-        &Ctx.Idents.get("atIndexedSubscript")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("setObject"),
+                                     &Ctx.Idents.get("atIndexedSubscript")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
     case NSOrderedSet_replaceObjectAtIndexWithObject: {
-      IdentifierInfo *KeyIdents[] = {
-        &Ctx.Idents.get("replaceObjectAtIndex"),
-        &Ctx.Idents.get("withObject")
-      };
+      IdentifierInfo *KeyIdents[] = {&Ctx.Idents.get("replaceObjectAtIndex"),
+                                     &Ctx.Idents.get("withObject")};
       Sel = Ctx.Selectors.getSelector(2, KeyIdents);
       break;
     }
@@ -300,8 +261,7 @@
   return NSSetSelectors[MK];
 }
 
-Optional<NSAPI::NSSetMethodKind>
-NSAPI::getNSSetMethodKind(Selector Sel) {
+Optional<NSAPI::NSSetMethodKind> NSAPI::getNSSetMethodKind(Selector Sel) {
   for (unsigned i = 0; i != NumNSSetMethods; ++i) {
     NSSetMethodKind MK = NSSetMethodKind(i);
     if (Sel == getNSSetSelector(MK))
@@ -313,43 +273,41 @@
 
 Selector NSAPI::getNSNumberLiteralSelector(NSNumberLiteralMethodKind MK,
                                            bool Instance) const {
-  static const char *ClassSelectorName[NumNSNumberLiteralMethods] = {
-    "numberWithChar",
-    "numberWithUnsignedChar",
-    "numberWithShort",
-    "numberWithUnsignedShort",
-    "numberWithInt",
-    "numberWithUnsignedInt",
-    "numberWithLong",
-    "numberWithUnsignedLong",
-    "numberWithLongLong",
-    "numberWithUnsignedLongLong",
-    "numberWithFloat",
-    "numberWithDouble",
-    "numberWithBool",
-    "numberWithInteger",
-    "numberWithUnsignedInteger"
-  };
-  static const char *InstanceSelectorName[NumNSNumberLiteralMethods] = {
-    "initWithChar",
-    "initWithUnsignedChar",
-    "initWithShort",
-    "initWithUnsignedShort",
-    "initWithInt",
-    "initWithUnsignedInt",
-    "initWithLong",
-    "initWithUnsignedLong",
-    "initWithLongLong",
-    "initWithUnsignedLongLong",
-    "initWithFloat",
-    "initWithDouble",
-    "initWithBool",
-    "initWithInteger",
-    "initWithUnsignedInteger"
-  };
+  static char const *ClassSelectorName[NumNSNumberLiteralMethods] = {
+      "numberWithChar",
+      "numberWithUnsignedChar",
+      "numberWithShort",
+      "numberWithUnsignedShort",
+      "numberWithInt",
+      "numberWithUnsignedInt",
+      "numberWithLong",
+      "numberWithUnsignedLong",
+      "numberWithLongLong",
+      "numberWithUnsignedLongLong",
+      "numberWithFloat",
+      "numberWithDouble",
+      "numberWithBool",
+      "numberWithInteger",
+      "numberWithUnsignedInteger"};
+  static char const *InstanceSelectorName[NumNSNumberLiteralMethods] = {
+      "initWithChar",
+      "initWithUnsignedChar",
+      "initWithShort",
+      "initWithUnsignedShort",
+      "initWithInt",
+      "initWithUnsignedInt",
+      "initWithLong",
+      "initWithUnsignedLong",
+      "initWithLongLong",
+      "initWithUnsignedLongLong",
+      "initWithFloat",
+      "initWithDouble",
+      "initWithBool",
+      "initWithInteger",
+      "initWithUnsignedInteger"};
 
   Selector *Sels;
-  const char **Names;
+  char const **Names;
   if (Instance) {
     Sels = NSNumberInstanceSelectors;
     Names = InstanceSelectorName;
@@ -376,11 +334,11 @@
 
 Optional<NSAPI::NSNumberLiteralMethodKind>
 NSAPI::getNSNumberFactoryMethodKind(QualType T) const {
-  const BuiltinType *BT = T->getAs<BuiltinType>();
+  BuiltinType const *BT = T->getAs<BuiltinType>();
   if (!BT)
     return None;
 
-  const TypedefType *TDT = T->getAs<TypedefType>();
+  TypedefType const *TDT = T->getAs<TypedefType>();
   if (TDT) {
     QualType TDTTy = QualType(TDT, 0);
     if (isObjCBOOLType(TDTTy))
@@ -461,22 +419,19 @@
   case BuiltinType::ObjCClass:
   case BuiltinType::ObjCId:
   case BuiltinType::ObjCSel:
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
   case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-  case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
 #include "clang/Basic/OpenCLExtensionTypes.def"
   case BuiltinType::OCLSampler:
   case BuiltinType::OCLEvent:
   case BuiltinType::OCLClkEvent:
   case BuiltinType::OCLQueue:
   case BuiltinType::OCLReserveID:
-#define SVE_TYPE(Name, Id, SingletonId) \
-  case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-  case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
@@ -516,21 +471,21 @@
   if (!Ctx.getLangOpts().ObjC || T.isNull())
     return StringRef();
 
-  while (const TypedefType *TDT = T->getAs<TypedefType>()) {
+  while (TypedefType const *TDT = T->getAs<TypedefType>()) {
     StringRef NSIntegralResust =
-      llvm::StringSwitch<StringRef>(
-        TDT->getDecl()->getDeclName().getAsIdentifierInfo()->getName())
-    .Case("int8_t", "int8_t")
-    .Case("int16_t", "int16_t")
-    .Case("int32_t", "int32_t")
-    .Case("NSInteger", "NSInteger")
-    .Case("int64_t", "int64_t")
-    .Case("uint8_t", "uint8_t")
-    .Case("uint16_t", "uint16_t")
-    .Case("uint32_t", "uint32_t")
-    .Case("NSUInteger", "NSUInteger")
-    .Case("uint64_t", "uint64_t")
-    .Default(StringRef());
+        llvm::StringSwitch<StringRef>(
+            TDT->getDecl()->getDeclName().getAsIdentifierInfo()->getName())
+            .Case("int8_t", "int8_t")
+            .Case("int16_t", "int16_t")
+            .Case("int32_t", "int32_t")
+            .Case("NSInteger", "NSInteger")
+            .Case("int64_t", "int64_t")
+            .Case("uint8_t", "uint8_t")
+            .Case("uint16_t", "uint16_t")
+            .Case("uint32_t", "uint32_t")
+            .Case("NSUInteger", "NSUInteger")
+            .Case("uint64_t", "uint64_t")
+            .Default(StringRef());
     if (!NSIntegralResust.empty())
       return NSIntegralResust;
     T = TDT->desugar();
@@ -563,8 +518,8 @@
   return IsSubclass;
 }
 
-bool NSAPI::isObjCTypedef(QualType T,
-                          StringRef name, IdentifierInfo *&II) const {
+bool NSAPI::isObjCTypedef(QualType T, StringRef name,
+                          IdentifierInfo *&II) const {
   if (!Ctx.getLangOpts().ObjC)
     return false;
   if (T.isNull())
@@ -573,7 +528,7 @@
   if (!II)
     II = &Ctx.Idents.get(name);
 
-  while (const TypedefType *TDT = T->getAs<TypedefType>()) {
+  while (TypedefType const *TDT = T->getAs<TypedefType>()) {
     if (TDT->getDecl()->getDeclName().getAsIdentifierInfo() == II)
       return true;
     T = TDT->desugar();
@@ -582,8 +537,8 @@
   return false;
 }
 
-bool NSAPI::isObjCEnumerator(const Expr *E,
-                             StringRef name, IdentifierInfo *&II) const {
+bool NSAPI::isObjCEnumerator(Expr const *E, StringRef name,
+                             IdentifierInfo *&II) const {
   if (!Ctx.getLangOpts().ObjC)
     return false;
   if (!E)
@@ -592,9 +547,9 @@
   if (!II)
     II = &Ctx.Idents.get(name);
 
-  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
-    if (const EnumConstantDecl *
-          EnumD = dyn_cast_or_null<EnumConstantDecl>(DRE->getDecl()))
+  if (DeclRefExpr const *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts()))
+    if (EnumConstantDecl const *EnumD =
+            dyn_cast_or_null<EnumConstantDecl>(DRE->getDecl()))
       return EnumD->getIdentifier() == II;
 
   return false;
@@ -604,8 +559,8 @@
                                   Selector &Sel) const {
   if (Sel.isNull()) {
     SmallVector<IdentifierInfo *, 4> Idents;
-    for (ArrayRef<StringRef>::const_iterator
-           I = Ids.begin(), E = Ids.end(); I != E; ++I)
+    for (ArrayRef<StringRef>::const_iterator I = Ids.begin(), E = Ids.end();
+         I != E; ++I)
       Idents.push_back(&Ctx.Idents.get(*I));
     Sel = Ctx.Selectors.getSelector(Idents.size(), Idents.data());
   }
Index: clang/lib/AST/NestedNameSpecifier.cpp
===================================================================
--- clang/lib/AST/NestedNameSpecifier.cpp
+++ clang/lib/AST/NestedNameSpecifier.cpp
@@ -38,14 +38,14 @@
 using namespace clang;
 
 NestedNameSpecifier *
-NestedNameSpecifier::FindOrInsert(const ASTContext &Context,
-                                  const NestedNameSpecifier &Mockup) {
+NestedNameSpecifier::FindOrInsert(ASTContext const &Context,
+                                  NestedNameSpecifier const &Mockup) {
   llvm::FoldingSetNodeID ID;
   Mockup.Profile(ID);
 
   void *InsertPos = nullptr;
-  NestedNameSpecifier *NNS
-    = Context.NestedNameSpecifiers.FindNodeOrInsertPos(ID, InsertPos);
+  NestedNameSpecifier *NNS =
+      Context.NestedNameSpecifiers.FindNodeOrInsertPos(ID, InsertPos);
   if (!NNS) {
     NNS =
         new (Context, alignof(NestedNameSpecifier)) NestedNameSpecifier(Mockup);
@@ -55,9 +55,9 @@
   return NNS;
 }
 
-NestedNameSpecifier *
-NestedNameSpecifier::Create(const ASTContext &Context,
-                            NestedNameSpecifier *Prefix, IdentifierInfo *II) {
+NestedNameSpecifier *NestedNameSpecifier::Create(ASTContext const &Context,
+                                                 NestedNameSpecifier *Prefix,
+                                                 IdentifierInfo *II) {
   assert(II && "Identifier cannot be NULL");
   assert((!Prefix || Prefix->isDependent()) && "Prefix must be dependent");
 
@@ -68,14 +68,12 @@
   return FindOrInsert(Context, Mockup);
 }
 
-NestedNameSpecifier *
-NestedNameSpecifier::Create(const ASTContext &Context,
-                            NestedNameSpecifier *Prefix,
-                            const NamespaceDecl *NS) {
+NestedNameSpecifier *NestedNameSpecifier::Create(ASTContext const &Context,
+                                                 NestedNameSpecifier *Prefix,
+                                                 NamespaceDecl const *NS) {
   assert(NS && "Namespace cannot be NULL");
-  assert((!Prefix ||
-          (Prefix->getAsType() == nullptr &&
-           Prefix->getAsIdentifier() == nullptr)) &&
+  assert((!Prefix || (Prefix->getAsType() == nullptr &&
+                      Prefix->getAsIdentifier() == nullptr)) &&
          "Broken nested name specifier");
   NestedNameSpecifier Mockup;
   Mockup.Prefix.setPointer(Prefix);
@@ -84,14 +82,12 @@
   return FindOrInsert(Context, Mockup);
 }
 
-NestedNameSpecifier *
-NestedNameSpecifier::Create(const ASTContext &Context,
-                            NestedNameSpecifier *Prefix,
-                            NamespaceAliasDecl *Alias) {
+NestedNameSpecifier *NestedNameSpecifier::Create(ASTContext const &Context,
+                                                 NestedNameSpecifier *Prefix,
+                                                 NamespaceAliasDecl *Alias) {
   assert(Alias && "Namespace alias cannot be NULL");
-  assert((!Prefix ||
-          (Prefix->getAsType() == nullptr &&
-           Prefix->getAsIdentifier() == nullptr)) &&
+  assert((!Prefix || (Prefix->getAsType() == nullptr &&
+                      Prefix->getAsIdentifier() == nullptr)) &&
          "Broken nested name specifier");
   NestedNameSpecifier Mockup;
   Mockup.Prefix.setPointer(Prefix);
@@ -100,20 +96,19 @@
   return FindOrInsert(Context, Mockup);
 }
 
-NestedNameSpecifier *
-NestedNameSpecifier::Create(const ASTContext &Context,
-                            NestedNameSpecifier *Prefix,
-                            bool Template, const Type *T) {
+NestedNameSpecifier *NestedNameSpecifier::Create(ASTContext const &Context,
+                                                 NestedNameSpecifier *Prefix,
+                                                 bool Template, Type const *T) {
   assert(T && "Type cannot be NULL");
   NestedNameSpecifier Mockup;
   Mockup.Prefix.setPointer(Prefix);
-  Mockup.Prefix.setInt(Template? StoredTypeSpecWithTemplate : StoredTypeSpec);
-  Mockup.Specifier = const_cast<Type*>(T);
+  Mockup.Prefix.setInt(Template ? StoredTypeSpecWithTemplate : StoredTypeSpec);
+  Mockup.Specifier = const_cast<Type *>(T);
   return FindOrInsert(Context, Mockup);
 }
 
-NestedNameSpecifier *
-NestedNameSpecifier::Create(const ASTContext &Context, IdentifierInfo *II) {
+NestedNameSpecifier *NestedNameSpecifier::Create(ASTContext const &Context,
+                                                 IdentifierInfo *II) {
   assert(II && "Identifier cannot be NULL");
   NestedNameSpecifier Mockup;
   Mockup.Prefix.setPointer(nullptr);
@@ -123,7 +118,7 @@
 }
 
 NestedNameSpecifier *
-NestedNameSpecifier::GlobalSpecifier(const ASTContext &Context) {
+NestedNameSpecifier::GlobalSpecifier(ASTContext const &Context) {
   if (!Context.GlobalNestedNameSpecifier)
     Context.GlobalNestedNameSpecifier =
         new (Context, alignof(NestedNameSpecifier)) NestedNameSpecifier();
@@ -131,7 +126,7 @@
 }
 
 NestedNameSpecifier *
-NestedNameSpecifier::SuperSpecifier(const ASTContext &Context,
+NestedNameSpecifier::SuperSpecifier(ASTContext const &Context,
                                     CXXRecordDecl *RD) {
   NestedNameSpecifier Mockup;
   Mockup.Prefix.setPointer(nullptr);
@@ -217,7 +212,7 @@
 
   case Super: {
     CXXRecordDecl *RD = static_cast<CXXRecordDecl *>(Specifier);
-    for (const auto &Base : RD->bases())
+    for (auto const &Base : RD->bases())
       if (Base.getType()->isDependentType())
         // FIXME: must also be instantiation-dependent.
         return NestedNameSpecifierDependence::Dependent;
@@ -249,7 +244,7 @@
 
 /// Print this nested name specifier to the given output
 /// stream.
-void NestedNameSpecifier::print(raw_ostream &OS, const PrintingPolicy &Policy,
+void NestedNameSpecifier::print(raw_ostream &OS, PrintingPolicy const &Policy,
                                 bool ResolveTemplateArguments) const {
   if (getPrefix())
     getPrefix()->print(OS, Policy);
@@ -283,17 +278,17 @@
     LLVM_FALLTHROUGH;
 
   case TypeSpec: {
-    const auto *Record =
-            dyn_cast_or_null<ClassTemplateSpecializationDecl>(getAsRecordDecl());
+    auto const *Record =
+        dyn_cast_or_null<ClassTemplateSpecializationDecl>(getAsRecordDecl());
     if (ResolveTemplateArguments && Record) {
-        // Print the type trait with resolved template parameters.
-        Record->printName(OS);
-        printTemplateArgumentList(
-            OS, Record->getTemplateArgs().asArray(), Policy,
-            Record->getSpecializedTemplate()->getTemplateParameters());
-        break;
+      // Print the type trait with resolved template parameters.
+      Record->printName(OS);
+      printTemplateArgumentList(
+          OS, Record->getTemplateArgs().asArray(), Policy,
+          Record->getSpecializedTemplate()->getTemplateParameters());
+      break;
     }
-    const Type *T = getAsType();
+    Type const *T = getAsType();
 
     PrintingPolicy InnerPolicy(Policy);
     InnerPolicy.SuppressScope = true;
@@ -307,8 +302,8 @@
     // suppress that nested-name-specifier during printing.
     assert(!isa<ElaboratedType>(T) &&
            "Elaborated type in nested-name-specifier");
-    if (const TemplateSpecializationType *SpecType
-          = dyn_cast<TemplateSpecializationType>(T)) {
+    if (TemplateSpecializationType const *SpecType =
+            dyn_cast<TemplateSpecializationType>(T)) {
       // Print the template name without its corresponding
       // nested-name-specifier.
       SpecType->getTemplateName().print(OS, InnerPolicy,
@@ -317,7 +312,7 @@
       // Print the template argument list.
       printTemplateArgumentList(OS, SpecType->template_arguments(),
                                 InnerPolicy);
-    } else if (const auto *DepSpecType =
+    } else if (auto const *DepSpecType =
                    dyn_cast<DependentTemplateSpecializationType>(T)) {
       // Print the template name without its corresponding
       // nested-name-specifier.
@@ -336,7 +331,7 @@
   OS << "::";
 }
 
-LLVM_DUMP_METHOD void NestedNameSpecifier::dump(const LangOptions &LO) const {
+LLVM_DUMP_METHOD void NestedNameSpecifier::dump(LangOptions const &LO) const {
   dump(llvm::errs(), LO);
 }
 
@@ -348,7 +343,7 @@
 }
 
 LLVM_DUMP_METHOD void NestedNameSpecifier::dump(llvm::raw_ostream &OS,
-                                                const LangOptions &LO) const {
+                                                LangOptions const &LO) const {
   print(OS, PrintingPolicy(LO));
 }
 
@@ -383,8 +378,7 @@
   return Length;
 }
 
-unsigned
-NestedNameSpecifierLoc::getDataLength(NestedNameSpecifier *Qualifier) {
+unsigned NestedNameSpecifierLoc::getDataLength(NestedNameSpecifier *Qualifier) {
   unsigned Length = 0;
   for (; Qualifier; Qualifier = Qualifier->getPrefix())
     Length += getLocalDataLength(Qualifier);
@@ -403,7 +397,7 @@
 /// offset.
 static void *LoadPointer(void *Data, unsigned Offset) {
   void *Result;
-  memcpy(&Result, static_cast<char *>(Data) + Offset, sizeof(void*));
+  memcpy(&Result, static_cast<char *>(Data) + Offset, sizeof(void *));
   return Result;
 }
 
@@ -443,7 +437,7 @@
     void *TypeData = LoadPointer(Data, Offset);
     TypeLoc TL(Qualifier->getAsType(), TypeData);
     return SourceRange(TL.getBeginLoc(),
-                       LoadSourceLocation(Data, Offset + sizeof(void*)));
+                       LoadSourceLocation(Data, Offset + sizeof(void *)));
   }
   }
 
@@ -499,12 +493,12 @@
 static void SavePointer(void *Ptr, char *&Buffer, unsigned &BufferSize,
                         unsigned &BufferCapacity) {
   Append(reinterpret_cast<char *>(&Ptr),
-         reinterpret_cast<char *>(&Ptr) + sizeof(void *),
-         Buffer, BufferSize, BufferCapacity);
+         reinterpret_cast<char *>(&Ptr) + sizeof(void *), Buffer, BufferSize,
+         BufferCapacity);
 }
 
-NestedNameSpecifierLocBuilder::
-NestedNameSpecifierLocBuilder(const NestedNameSpecifierLocBuilder &Other)
+NestedNameSpecifierLocBuilder::NestedNameSpecifierLocBuilder(
+    NestedNameSpecifierLocBuilder const &Other)
     : Representation(Other.Representation) {
   if (!Other.Buffer)
     return;
@@ -521,9 +515,8 @@
          BufferCapacity);
 }
 
-NestedNameSpecifierLocBuilder &
-NestedNameSpecifierLocBuilder::
-operator=(const NestedNameSpecifierLocBuilder &Other) {
+NestedNameSpecifierLocBuilder &NestedNameSpecifierLocBuilder::operator=(
+    NestedNameSpecifierLocBuilder const &Other) {
   Representation = Other.Representation;
 
   if (Buffer && Other.Buffer && BufferCapacity >= Other.BufferSize) {
@@ -564,9 +557,8 @@
                                            SourceLocation TemplateKWLoc,
                                            TypeLoc TL,
                                            SourceLocation ColonColonLoc) {
-  Representation = NestedNameSpecifier::Create(Context, Representation,
-                                               TemplateKWLoc.isValid(),
-                                               TL.getTypePtr());
+  Representation = NestedNameSpecifier::Create(
+      Context, Representation, TemplateKWLoc.isValid(), TL.getTypePtr());
 
   // Push source-location info into the buffer.
   SavePointer(TL.getOpaqueData(), Buffer, BufferSize, BufferCapacity);
@@ -577,8 +569,8 @@
                                            IdentifierInfo *Identifier,
                                            SourceLocation IdentifierLoc,
                                            SourceLocation ColonColonLoc) {
-  Representation = NestedNameSpecifier::Create(Context, Representation,
-                                               Identifier);
+  Representation =
+      NestedNameSpecifier::Create(Context, Representation, Identifier);
 
   // Push source-location info into the buffer.
   SaveSourceLocation(IdentifierLoc, Buffer, BufferSize, BufferCapacity);
@@ -589,8 +581,8 @@
                                            NamespaceDecl *Namespace,
                                            SourceLocation NamespaceLoc,
                                            SourceLocation ColonColonLoc) {
-  Representation = NestedNameSpecifier::Create(Context, Representation,
-                                               Namespace);
+  Representation =
+      NestedNameSpecifier::Create(Context, Representation, Namespace);
 
   // Push source-location info into the buffer.
   SaveSourceLocation(NamespaceLoc, Buffer, BufferSize, BufferCapacity);
@@ -642,30 +634,29 @@
   while (!Stack.empty()) {
     NestedNameSpecifier *NNS = Stack.pop_back_val();
     switch (NNS->getKind()) {
-      case NestedNameSpecifier::Identifier:
-      case NestedNameSpecifier::Namespace:
-      case NestedNameSpecifier::NamespaceAlias:
-        SaveSourceLocation(R.getBegin(), Buffer, BufferSize, BufferCapacity);
-        break;
-
-      case NestedNameSpecifier::TypeSpec:
-      case NestedNameSpecifier::TypeSpecWithTemplate: {
-        TypeSourceInfo *TSInfo
-        = Context.getTrivialTypeSourceInfo(QualType(NNS->getAsType(), 0),
-                                           R.getBegin());
-        SavePointer(TSInfo->getTypeLoc().getOpaqueData(), Buffer, BufferSize,
-                    BufferCapacity);
-        break;
-      }
-
-      case NestedNameSpecifier::Global:
-      case NestedNameSpecifier::Super:
-        break;
+    case NestedNameSpecifier::Identifier:
+    case NestedNameSpecifier::Namespace:
+    case NestedNameSpecifier::NamespaceAlias:
+      SaveSourceLocation(R.getBegin(), Buffer, BufferSize, BufferCapacity);
+      break;
+
+    case NestedNameSpecifier::TypeSpec:
+    case NestedNameSpecifier::TypeSpecWithTemplate: {
+      TypeSourceInfo *TSInfo = Context.getTrivialTypeSourceInfo(
+          QualType(NNS->getAsType(), 0), R.getBegin());
+      SavePointer(TSInfo->getTypeLoc().getOpaqueData(), Buffer, BufferSize,
+                  BufferCapacity);
+      break;
+    }
+
+    case NestedNameSpecifier::Global:
+    case NestedNameSpecifier::Super:
+      break;
     }
 
     // Save the location of the '::'.
-    SaveSourceLocation(Stack.empty()? R.getEnd() : R.getBegin(),
-                       Buffer, BufferSize, BufferCapacity);
+    SaveSourceLocation(Stack.empty() ? R.getEnd() : R.getBegin(), Buffer,
+                       BufferSize, BufferCapacity);
   }
 }
 
Index: clang/lib/AST/ODRHash.cpp
===================================================================
--- clang/lib/AST/ODRHash.cpp
+++ clang/lib/AST/ODRHash.cpp
@@ -21,12 +21,12 @@
 
 using namespace clang;
 
-void ODRHash::AddStmt(const Stmt *S) {
+void ODRHash::AddStmt(Stmt const *S) {
   assert(S && "Expecting non-null pointer.");
   S->ProcessODRHash(ID, *this);
 }
 
-void ODRHash::AddIdentifierInfo(const IdentifierInfo *II) {
+void ODRHash::AddIdentifierInfo(IdentifierInfo const *II) {
   assert(II && "Expecting non-null pointer.");
   ID.AddString(II->getName());
 }
@@ -73,7 +73,7 @@
     unsigned NumArgs = S.getNumArgs();
     ID.AddInteger(NumArgs);
     for (unsigned i = 0; i < NumArgs; ++i) {
-      const IdentifierInfo *II = S.getIdentifierInfoForSlot(i);
+      IdentifierInfo const *II = S.getIdentifierInfoForSlot(i);
       AddBoolean(II);
       if (II) {
         AddIdentifierInfo(II);
@@ -106,9 +106,9 @@
   }
 }
 
-void ODRHash::AddNestedNameSpecifier(const NestedNameSpecifier *NNS) {
+void ODRHash::AddNestedNameSpecifier(NestedNameSpecifier const *NNS) {
   assert(NNS && "Expecting non-null pointer.");
-  const auto *Prefix = NNS->getPrefix();
+  auto const *Prefix = NNS->getPrefix();
   AddBoolean(Prefix);
   if (Prefix) {
     AddNestedNameSpecifier(Prefix);
@@ -155,38 +155,38 @@
 }
 
 void ODRHash::AddTemplateArgument(TemplateArgument TA) {
-  const auto Kind = TA.getKind();
+  auto const Kind = TA.getKind();
   ID.AddInteger(Kind);
 
   switch (Kind) {
-    case TemplateArgument::Null:
-      llvm_unreachable("Expected valid TemplateArgument");
-    case TemplateArgument::Type:
-      AddQualType(TA.getAsType());
-      break;
-    case TemplateArgument::Declaration:
-      AddDecl(TA.getAsDecl());
-      break;
-    case TemplateArgument::NullPtr:
-    case TemplateArgument::Integral:
-      break;
-    case TemplateArgument::Template:
-    case TemplateArgument::TemplateExpansion:
-      AddTemplateName(TA.getAsTemplateOrTemplatePattern());
-      break;
-    case TemplateArgument::Expression:
-      AddStmt(TA.getAsExpr());
-      break;
-    case TemplateArgument::Pack:
-      ID.AddInteger(TA.pack_size());
-      for (auto SubTA : TA.pack_elements()) {
-        AddTemplateArgument(SubTA);
-      }
-      break;
+  case TemplateArgument::Null:
+    llvm_unreachable("Expected valid TemplateArgument");
+  case TemplateArgument::Type:
+    AddQualType(TA.getAsType());
+    break;
+  case TemplateArgument::Declaration:
+    AddDecl(TA.getAsDecl());
+    break;
+  case TemplateArgument::NullPtr:
+  case TemplateArgument::Integral:
+    break;
+  case TemplateArgument::Template:
+  case TemplateArgument::TemplateExpansion:
+    AddTemplateName(TA.getAsTemplateOrTemplatePattern());
+    break;
+  case TemplateArgument::Expression:
+    AddStmt(TA.getAsExpr());
+    break;
+  case TemplateArgument::Pack:
+    ID.AddInteger(TA.pack_size());
+    for (auto SubTA : TA.pack_elements()) {
+      AddTemplateArgument(SubTA);
+    }
+    break;
   }
 }
 
-void ODRHash::AddTemplateParameterList(const TemplateParameterList *TPL) {
+void ODRHash::AddTemplateParameterList(TemplateParameterList const *TPL) {
   assert(TPL && "Expecting non-null pointer.");
 
   ID.AddInteger(TPL->size());
@@ -205,10 +205,10 @@
   // Append the bools to the end of the data segment backwards.  This allows
   // for the bools data to be compressed 32 times smaller compared to using
   // ID.AddBoolean
-  const unsigned unsigned_bits = sizeof(unsigned) * CHAR_BIT;
-  const unsigned size = Bools.size();
-  const unsigned remainder = size % unsigned_bits;
-  const unsigned loops = size / unsigned_bits;
+  unsigned const unsigned_bits = sizeof(unsigned) * CHAR_BIT;
+  unsigned const size = Bools.size();
+  unsigned const remainder = size % unsigned_bits;
+  unsigned const loops = size / unsigned_bits;
   auto I = Bools.rbegin();
   unsigned value = 0;
   for (unsigned i = 0; i < remainder; ++i) {
@@ -245,25 +245,23 @@
   ODRDeclVisitor(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
       : ID(ID), Hash(Hash) {}
 
-  void AddStmt(const Stmt *S) {
+  void AddStmt(Stmt const *S) {
     Hash.AddBoolean(S);
     if (S) {
       Hash.AddStmt(S);
     }
   }
 
-  void AddIdentifierInfo(const IdentifierInfo *II) {
+  void AddIdentifierInfo(IdentifierInfo const *II) {
     Hash.AddBoolean(II);
     if (II) {
       Hash.AddIdentifierInfo(II);
     }
   }
 
-  void AddQualType(QualType T) {
-    Hash.AddQualType(T);
-  }
+  void AddQualType(QualType T) { Hash.AddQualType(T); }
 
-  void AddDecl(const Decl *D) {
+  void AddDecl(Decl const *D) {
     Hash.AddBoolean(D);
     if (D) {
       Hash.AddDecl(D);
@@ -274,27 +272,27 @@
     Hash.AddTemplateArgument(TA);
   }
 
-  void Visit(const Decl *D) {
+  void Visit(Decl const *D) {
     ID.AddInteger(D->getKind());
     Inherited::Visit(D);
   }
 
-  void VisitNamedDecl(const NamedDecl *D) {
+  void VisitNamedDecl(NamedDecl const *D) {
     Hash.AddDeclarationName(D->getDeclName());
     Inherited::VisitNamedDecl(D);
   }
 
-  void VisitValueDecl(const ValueDecl *D) {
+  void VisitValueDecl(ValueDecl const *D) {
     if (!isa<FunctionDecl>(D)) {
       AddQualType(D->getType());
     }
     Inherited::VisitValueDecl(D);
   }
 
-  void VisitVarDecl(const VarDecl *D) {
+  void VisitVarDecl(VarDecl const *D) {
     Hash.AddBoolean(D->isStaticLocal());
     Hash.AddBoolean(D->isConstexpr());
-    const bool HasInit = D->hasInit();
+    bool const HasInit = D->hasInit();
     Hash.AddBoolean(HasInit);
     if (HasInit) {
       AddStmt(D->getInit());
@@ -302,25 +300,25 @@
     Inherited::VisitVarDecl(D);
   }
 
-  void VisitParmVarDecl(const ParmVarDecl *D) {
+  void VisitParmVarDecl(ParmVarDecl const *D) {
     // TODO: Handle default arguments.
     Inherited::VisitParmVarDecl(D);
   }
 
-  void VisitAccessSpecDecl(const AccessSpecDecl *D) {
+  void VisitAccessSpecDecl(AccessSpecDecl const *D) {
     ID.AddInteger(D->getAccess());
     Inherited::VisitAccessSpecDecl(D);
   }
 
-  void VisitStaticAssertDecl(const StaticAssertDecl *D) {
+  void VisitStaticAssertDecl(StaticAssertDecl const *D) {
     AddStmt(D->getAssertExpr());
     AddStmt(D->getMessage());
 
     Inherited::VisitStaticAssertDecl(D);
   }
 
-  void VisitFieldDecl(const FieldDecl *D) {
-    const bool IsBitfield = D->isBitField();
+  void VisitFieldDecl(FieldDecl const *D) {
+    bool const IsBitfield = D->isBitField();
     Hash.AddBoolean(IsBitfield);
 
     if (IsBitfield) {
@@ -333,34 +331,34 @@
     Inherited::VisitFieldDecl(D);
   }
 
-  void VisitFunctionDecl(const FunctionDecl *D) {
+  void VisitFunctionDecl(FunctionDecl const *D) {
     // Handled by the ODRHash for FunctionDecl
     ID.AddInteger(D->getODRHash());
 
     Inherited::VisitFunctionDecl(D);
   }
 
-  void VisitCXXMethodDecl(const CXXMethodDecl *D) {
+  void VisitCXXMethodDecl(CXXMethodDecl const *D) {
     // Handled by the ODRHash for FunctionDecl
 
     Inherited::VisitCXXMethodDecl(D);
   }
 
-  void VisitTypedefNameDecl(const TypedefNameDecl *D) {
+  void VisitTypedefNameDecl(TypedefNameDecl const *D) {
     AddQualType(D->getUnderlyingType());
 
     Inherited::VisitTypedefNameDecl(D);
   }
 
-  void VisitTypedefDecl(const TypedefDecl *D) {
+  void VisitTypedefDecl(TypedefDecl const *D) {
     Inherited::VisitTypedefDecl(D);
   }
 
-  void VisitTypeAliasDecl(const TypeAliasDecl *D) {
+  void VisitTypeAliasDecl(TypeAliasDecl const *D) {
     Inherited::VisitTypeAliasDecl(D);
   }
 
-  void VisitFriendDecl(const FriendDecl *D) {
+  void VisitFriendDecl(FriendDecl const *D) {
     TypeSourceInfo *TSI = D->getFriendType();
     Hash.AddBoolean(TSI);
     if (TSI) {
@@ -370,9 +368,9 @@
     }
   }
 
-  void VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
+  void VisitTemplateTypeParmDecl(TemplateTypeParmDecl const *D) {
     // Only care about default arguments as part of the definition.
-    const bool hasDefaultArgument =
+    bool const hasDefaultArgument =
         D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
     Hash.AddBoolean(hasDefaultArgument);
     if (hasDefaultArgument) {
@@ -380,7 +378,7 @@
     }
     Hash.AddBoolean(D->isParameterPack());
 
-    const TypeConstraint *TC = D->getTypeConstraint();
+    TypeConstraint const *TC = D->getTypeConstraint();
     Hash.AddBoolean(TC != nullptr);
     if (TC)
       AddStmt(TC->getImmediatelyDeclaredConstraint());
@@ -388,9 +386,9 @@
     Inherited::VisitTemplateTypeParmDecl(D);
   }
 
-  void VisitNonTypeTemplateParmDecl(const NonTypeTemplateParmDecl *D) {
+  void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl const *D) {
     // Only care about default arguments as part of the definition.
-    const bool hasDefaultArgument =
+    bool const hasDefaultArgument =
         D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
     Hash.AddBoolean(hasDefaultArgument);
     if (hasDefaultArgument) {
@@ -401,9 +399,9 @@
     Inherited::VisitNonTypeTemplateParmDecl(D);
   }
 
-  void VisitTemplateTemplateParmDecl(const TemplateTemplateParmDecl *D) {
+  void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl const *D) {
     // Only care about default arguments as part of the definition.
-    const bool hasDefaultArgument =
+    bool const hasDefaultArgument =
         D->hasDefaultArgument() && !D->defaultArgumentWasInherited();
     Hash.AddBoolean(hasDefaultArgument);
     if (hasDefaultArgument) {
@@ -414,24 +412,24 @@
     Inherited::VisitTemplateTemplateParmDecl(D);
   }
 
-  void VisitTemplateDecl(const TemplateDecl *D) {
+  void VisitTemplateDecl(TemplateDecl const *D) {
     Hash.AddTemplateParameterList(D->getTemplateParameters());
 
     Inherited::VisitTemplateDecl(D);
   }
 
-  void VisitRedeclarableTemplateDecl(const RedeclarableTemplateDecl *D) {
+  void VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl const *D) {
     Hash.AddBoolean(D->isMemberSpecialization());
     Inherited::VisitRedeclarableTemplateDecl(D);
   }
 
-  void VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
+  void VisitFunctionTemplateDecl(FunctionTemplateDecl const *D) {
     AddDecl(D->getTemplatedDecl());
     ID.AddInteger(D->getTemplatedDecl()->getODRHash());
     Inherited::VisitFunctionTemplateDecl(D);
   }
 
-  void VisitEnumConstantDecl(const EnumConstantDecl *D) {
+  void VisitEnumConstantDecl(EnumConstantDecl const *D) {
     AddStmt(D->getInitExpr());
     Inherited::VisitEnumConstantDecl(D);
   }
@@ -440,40 +438,42 @@
 
 // Only allow a small portion of Decl's to be processed.  Remove this once
 // all Decl's can be handled.
-bool ODRHash::isDeclToBeProcessed(const Decl *D, const DeclContext *Parent) {
-  if (D->isImplicit()) return false;
-  if (D->getDeclContext() != Parent) return false;
+bool ODRHash::isDeclToBeProcessed(Decl const *D, DeclContext const *Parent) {
+  if (D->isImplicit())
+    return false;
+  if (D->getDeclContext() != Parent)
+    return false;
 
   switch (D->getKind()) {
-    default:
-      return false;
-    case Decl::AccessSpec:
-    case Decl::CXXConstructor:
-    case Decl::CXXDestructor:
-    case Decl::CXXMethod:
-    case Decl::EnumConstant: // Only found in EnumDecl's.
-    case Decl::Field:
-    case Decl::Friend:
-    case Decl::FunctionTemplate:
-    case Decl::StaticAssert:
-    case Decl::TypeAlias:
-    case Decl::Typedef:
-    case Decl::Var:
-      return true;
+  default:
+    return false;
+  case Decl::AccessSpec:
+  case Decl::CXXConstructor:
+  case Decl::CXXDestructor:
+  case Decl::CXXMethod:
+  case Decl::EnumConstant: // Only found in EnumDecl's.
+  case Decl::Field:
+  case Decl::Friend:
+  case Decl::FunctionTemplate:
+  case Decl::StaticAssert:
+  case Decl::TypeAlias:
+  case Decl::Typedef:
+  case Decl::Var:
+    return true;
   }
 }
 
-void ODRHash::AddSubDecl(const Decl *D) {
+void ODRHash::AddSubDecl(Decl const *D) {
   assert(D && "Expecting non-null pointer.");
 
   ODRDeclVisitor(ID, *this).Visit(D);
 }
 
-void ODRHash::AddCXXRecordDecl(const CXXRecordDecl *Record) {
+void ODRHash::AddCXXRecordDecl(CXXRecordDecl const *Record) {
   assert(Record && Record->hasDefinition() &&
          "Expected non-null record to be a definition.");
 
-  const DeclContext *DC = Record;
+  DeclContext const *DC = Record;
   while (DC) {
     if (isa<ClassTemplateSpecializationDecl>(DC)) {
       return;
@@ -485,7 +485,7 @@
 
   // Filter out sub-Decls which will not be processed in order to get an
   // accurate count of Decl's.
-  llvm::SmallVector<const Decl *, 16> Decls;
+  llvm::SmallVector<Decl const *, 16> Decls;
   for (Decl *SubDecl : Record->decls()) {
     if (isDeclToBeProcessed(SubDecl, Record)) {
       Decls.push_back(SubDecl);
@@ -501,7 +501,7 @@
     AddSubDecl(SubDecl);
   }
 
-  const ClassTemplateDecl *TD = Record->getDescribedClassTemplate();
+  ClassTemplateDecl const *TD = Record->getDescribedClassTemplate();
   AddBoolean(TD);
   if (TD) {
     AddTemplateParameterList(TD->getTemplateParameters());
@@ -516,18 +516,20 @@
   }
 }
 
-void ODRHash::AddFunctionDecl(const FunctionDecl *Function,
-                              bool SkipBody) {
+void ODRHash::AddFunctionDecl(FunctionDecl const *Function, bool SkipBody) {
   assert(Function && "Expecting non-null pointer.");
 
   // Skip functions that are specializations or in specialization context.
-  const DeclContext *DC = Function;
+  DeclContext const *DC = Function;
   while (DC) {
-    if (isa<ClassTemplateSpecializationDecl>(DC)) return;
+    if (isa<ClassTemplateSpecializationDecl>(DC))
+      return;
     if (auto *F = dyn_cast<FunctionDecl>(DC)) {
       if (F->isFunctionTemplateSpecialization()) {
-        if (!isa<CXXMethodDecl>(DC)) return;
-        if (DC->getLexicalParent()->isFileContext()) return;
+        if (!isa<CXXMethodDecl>(DC))
+          return;
+        if (DC->getLexicalParent()->isFileContext())
+          return;
         // Inline method specializations are the only supported
         // specialization for now.
       }
@@ -537,16 +539,16 @@
 
   ID.AddInteger(Function->getDeclKind());
 
-  const auto *SpecializationArgs = Function->getTemplateSpecializationArgs();
+  auto const *SpecializationArgs = Function->getTemplateSpecializationArgs();
   AddBoolean(SpecializationArgs);
   if (SpecializationArgs) {
     ID.AddInteger(SpecializationArgs->size());
-    for (const TemplateArgument &TA : SpecializationArgs->asArray()) {
+    for (TemplateArgument const &TA : SpecializationArgs->asArray()) {
       AddTemplateArgument(TA);
     }
   }
 
-  if (const auto *Method = dyn_cast<CXXMethodDecl>(Function)) {
+  if (auto const *Method = dyn_cast<CXXMethodDecl>(Function)) {
     AddBoolean(Method->isConst());
     AddBoolean(Method->isVolatile());
   }
@@ -571,7 +573,7 @@
     return;
   }
 
-  const bool HasBody = Function->isThisDeclarationADefinition() &&
+  bool const HasBody = Function->isThisDeclarationADefinition() &&
                        !Function->isDefaulted() && !Function->isDeleted() &&
                        !Function->isLateTemplateParsed();
   AddBoolean(HasBody);
@@ -586,7 +588,7 @@
 
   // Filter out sub-Decls which will not be processed in order to get an
   // accurate count of Decl's.
-  llvm::SmallVector<const Decl *, 16> Decls;
+  llvm::SmallVector<Decl const *, 16> Decls;
   for (Decl *SubDecl : Function->decls()) {
     if (isDeclToBeProcessed(SubDecl, Function)) {
       Decls.push_back(SubDecl);
@@ -599,7 +601,7 @@
   }
 }
 
-void ODRHash::AddEnumDecl(const EnumDecl *Enum) {
+void ODRHash::AddEnumDecl(EnumDecl const *Enum) {
   assert(Enum);
   AddDeclarationName(Enum->getDeclName());
 
@@ -612,7 +614,7 @@
 
   // Filter out sub-Decls which will not be processed in order to get an
   // accurate count of Decl's.
-  llvm::SmallVector<const Decl *, 16> Decls;
+  llvm::SmallVector<Decl const *, 16> Decls;
   for (Decl *SubDecl : Enum->decls()) {
     if (isDeclToBeProcessed(SubDecl, Enum)) {
       assert(isa<EnumConstantDecl>(SubDecl) && "Unexpected Decl");
@@ -624,14 +626,13 @@
   for (auto SubDecl : Decls) {
     AddSubDecl(SubDecl);
   }
-
 }
 
-void ODRHash::AddDecl(const Decl *D) {
+void ODRHash::AddDecl(Decl const *D) {
   assert(D && "Expecting non-null pointer.");
   D = D->getCanonicalDecl();
 
-  const NamedDecl *ND = dyn_cast<NamedDecl>(D);
+  NamedDecl const *ND = dyn_cast<NamedDecl>(D);
   AddBoolean(ND);
   if (!ND) {
     ID.AddInteger(D->getKind());
@@ -640,13 +641,12 @@
 
   AddDeclarationName(ND->getDeclName());
 
-  const auto *Specialization =
-            dyn_cast<ClassTemplateSpecializationDecl>(D);
+  auto const *Specialization = dyn_cast<ClassTemplateSpecializationDecl>(D);
   AddBoolean(Specialization);
   if (Specialization) {
-    const TemplateArgumentList &List = Specialization->getTemplateArgs();
+    TemplateArgumentList const &List = Specialization->getTemplateArgs();
     ID.AddInteger(List.size());
-    for (const TemplateArgument &TA : List.asArray())
+    for (TemplateArgument const &TA : List.asArray())
       AddTemplateArgument(TA);
   }
 }
@@ -677,25 +677,23 @@
     }
   }
 
-  void AddQualType(QualType T) {
-    Hash.AddQualType(T);
-  }
+  void AddQualType(QualType T) { Hash.AddQualType(T); }
 
-  void AddType(const Type *T) {
+  void AddType(Type const *T) {
     Hash.AddBoolean(T);
     if (T) {
       Hash.AddType(T);
     }
   }
 
-  void AddNestedNameSpecifier(const NestedNameSpecifier *NNS) {
+  void AddNestedNameSpecifier(NestedNameSpecifier const *NNS) {
     Hash.AddBoolean(NNS);
     if (NNS) {
       Hash.AddNestedNameSpecifier(NNS);
     }
   }
 
-  void AddIdentifierInfo(const IdentifierInfo *II) {
+  void AddIdentifierInfo(IdentifierInfo const *II) {
     Hash.AddBoolean(II);
     if (II) {
       Hash.AddIdentifierInfo(II);
@@ -708,20 +706,20 @@
 
   // Return the RecordType if the typedef only strips away a keyword.
   // Otherwise, return the original type.
-  static const Type *RemoveTypedef(const Type *T) {
-    const auto *TypedefT = dyn_cast<TypedefType>(T);
+  static Type const *RemoveTypedef(Type const *T) {
+    auto const *TypedefT = dyn_cast<TypedefType>(T);
     if (!TypedefT) {
       return T;
     }
 
-    const TypedefNameDecl *D = TypedefT->getDecl();
+    TypedefNameDecl const *D = TypedefT->getDecl();
     QualType UnderlyingType = D->getUnderlyingType();
 
     if (UnderlyingType.hasLocalQualifiers()) {
       return T;
     }
 
-    const auto *ElaboratedT = dyn_cast<ElaboratedType>(UnderlyingType);
+    auto const *ElaboratedT = dyn_cast<ElaboratedType>(UnderlyingType);
     if (!ElaboratedT) {
       return T;
     }
@@ -735,13 +733,13 @@
       return T;
     }
 
-    const auto *RecordT = dyn_cast<RecordType>(NamedType);
+    auto const *RecordT = dyn_cast<RecordType>(NamedType);
     if (!RecordT) {
       return T;
     }
 
-    const IdentifierInfo *TypedefII = TypedefT->getDecl()->getIdentifier();
-    const IdentifierInfo *RecordII = RecordT->getDecl()->getIdentifier();
+    IdentifierInfo const *TypedefII = TypedefT->getDecl()->getIdentifier();
+    IdentifierInfo const *RecordII = RecordT->getDecl()->getIdentifier();
     if (!TypedefII || !RecordII ||
         TypedefII->getName() != RecordII->getName()) {
       return T;
@@ -750,15 +748,15 @@
     return RecordT;
   }
 
-  void Visit(const Type *T) {
+  void Visit(Type const *T) {
     T = RemoveTypedef(T);
     ID.AddInteger(T->getTypeClass());
     Inherited::Visit(T);
   }
 
-  void VisitType(const Type *T) {}
+  void VisitType(Type const *T) {}
 
-  void VisitAdjustedType(const AdjustedType *T) {
+  void VisitAdjustedType(AdjustedType const *T) {
     QualType Original = T->getOriginalType();
     QualType Adjusted = T->getAdjustedType();
 
@@ -786,38 +784,38 @@
     VisitType(T);
   }
 
-  void VisitDecayedType(const DecayedType *T) {
+  void VisitDecayedType(DecayedType const *T) {
     // getDecayedType and getPointeeType are derived from getAdjustedType
     // and don't need to be separately processed.
     VisitAdjustedType(T);
   }
 
-  void VisitArrayType(const ArrayType *T) {
+  void VisitArrayType(ArrayType const *T) {
     AddQualType(T->getElementType());
     ID.AddInteger(T->getSizeModifier());
     VisitQualifiers(T->getIndexTypeQualifiers());
     VisitType(T);
   }
-  void VisitConstantArrayType(const ConstantArrayType *T) {
+  void VisitConstantArrayType(ConstantArrayType const *T) {
     T->getSize().Profile(ID);
     VisitArrayType(T);
   }
 
-  void VisitDependentSizedArrayType(const DependentSizedArrayType *T) {
+  void VisitDependentSizedArrayType(DependentSizedArrayType const *T) {
     AddStmt(T->getSizeExpr());
     VisitArrayType(T);
   }
 
-  void VisitIncompleteArrayType(const IncompleteArrayType *T) {
+  void VisitIncompleteArrayType(IncompleteArrayType const *T) {
     VisitArrayType(T);
   }
 
-  void VisitVariableArrayType(const VariableArrayType *T) {
+  void VisitVariableArrayType(VariableArrayType const *T) {
     AddStmt(T->getSizeExpr());
     VisitArrayType(T);
   }
 
-  void VisitAttributedType(const AttributedType *T) {
+  void VisitAttributedType(AttributedType const *T) {
     ID.AddInteger(T->getAttrKind());
     AddQualType(T->getModifiedType());
     AddQualType(T->getEquivalentType());
@@ -825,67 +823,67 @@
     VisitType(T);
   }
 
-  void VisitBlockPointerType(const BlockPointerType *T) {
+  void VisitBlockPointerType(BlockPointerType const *T) {
     AddQualType(T->getPointeeType());
     VisitType(T);
   }
 
-  void VisitBuiltinType(const BuiltinType *T) {
+  void VisitBuiltinType(BuiltinType const *T) {
     ID.AddInteger(T->getKind());
     VisitType(T);
   }
 
-  void VisitComplexType(const ComplexType *T) {
+  void VisitComplexType(ComplexType const *T) {
     AddQualType(T->getElementType());
     VisitType(T);
   }
 
-  void VisitDecltypeType(const DecltypeType *T) {
+  void VisitDecltypeType(DecltypeType const *T) {
     AddStmt(T->getUnderlyingExpr());
     AddQualType(T->getUnderlyingType());
     VisitType(T);
   }
 
-  void VisitDependentDecltypeType(const DependentDecltypeType *T) {
+  void VisitDependentDecltypeType(DependentDecltypeType const *T) {
     VisitDecltypeType(T);
   }
 
-  void VisitDeducedType(const DeducedType *T) {
+  void VisitDeducedType(DeducedType const *T) {
     AddQualType(T->getDeducedType());
     VisitType(T);
   }
 
-  void VisitAutoType(const AutoType *T) {
+  void VisitAutoType(AutoType const *T) {
     ID.AddInteger((unsigned)T->getKeyword());
     ID.AddInteger(T->isConstrained());
     if (T->isConstrained()) {
       AddDecl(T->getTypeConstraintConcept());
       ID.AddInteger(T->getNumArgs());
-      for (const auto &TA : T->getTypeConstraintArguments())
+      for (auto const &TA : T->getTypeConstraintArguments())
         Hash.AddTemplateArgument(TA);
     }
     VisitDeducedType(T);
   }
 
   void VisitDeducedTemplateSpecializationType(
-      const DeducedTemplateSpecializationType *T) {
+      DeducedTemplateSpecializationType const *T) {
     Hash.AddTemplateName(T->getTemplateName());
     VisitDeducedType(T);
   }
 
-  void VisitDependentAddressSpaceType(const DependentAddressSpaceType *T) {
+  void VisitDependentAddressSpaceType(DependentAddressSpaceType const *T) {
     AddQualType(T->getPointeeType());
     AddStmt(T->getAddrSpaceExpr());
     VisitType(T);
   }
 
-  void VisitDependentSizedExtVectorType(const DependentSizedExtVectorType *T) {
+  void VisitDependentSizedExtVectorType(DependentSizedExtVectorType const *T) {
     AddQualType(T->getElementType());
     AddStmt(T->getSizeExpr());
     VisitType(T);
   }
 
-  void VisitFunctionType(const FunctionType *T) {
+  void VisitFunctionType(FunctionType const *T) {
     AddQualType(T->getReturnType());
     T->getExtInfo().Profile(ID);
     Hash.AddBoolean(T->isConst());
@@ -894,11 +892,11 @@
     VisitType(T);
   }
 
-  void VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
+  void VisitFunctionNoProtoType(FunctionNoProtoType const *T) {
     VisitFunctionType(T);
   }
 
-  void VisitFunctionProtoType(const FunctionProtoType *T) {
+  void VisitFunctionProtoType(FunctionProtoType const *T) {
     ID.AddInteger(T->getNumParams());
     for (auto ParamType : T->getParamTypes())
       AddQualType(ParamType);
@@ -906,23 +904,23 @@
     VisitFunctionType(T);
   }
 
-  void VisitInjectedClassNameType(const InjectedClassNameType *T) {
+  void VisitInjectedClassNameType(InjectedClassNameType const *T) {
     AddDecl(T->getDecl());
     VisitType(T);
   }
 
-  void VisitMemberPointerType(const MemberPointerType *T) {
+  void VisitMemberPointerType(MemberPointerType const *T) {
     AddQualType(T->getPointeeType());
     AddType(T->getClass());
     VisitType(T);
   }
 
-  void VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
+  void VisitObjCObjectPointerType(ObjCObjectPointerType const *T) {
     AddQualType(T->getPointeeType());
     VisitType(T);
   }
 
-  void VisitObjCObjectType(const ObjCObjectType *T) {
+  void VisitObjCObjectType(ObjCObjectType const *T) {
     AddDecl(T->getInterface());
 
     auto TypeArgs = T->getTypeArgsAsWritten();
@@ -942,12 +940,12 @@
     VisitType(T);
   }
 
-  void VisitObjCInterfaceType(const ObjCInterfaceType *T) {
+  void VisitObjCInterfaceType(ObjCInterfaceType const *T) {
     // This type is handled by the parent type ObjCObjectType.
     VisitObjCObjectType(T);
   }
 
-  void VisitObjCTypeParamType(const ObjCTypeParamType *T) {
+  void VisitObjCTypeParamType(ObjCTypeParamType const *T) {
     AddDecl(T->getDecl());
     auto Protocols = T->getProtocols();
     ID.AddInteger(Protocols.size());
@@ -958,88 +956,88 @@
     VisitType(T);
   }
 
-  void VisitPackExpansionType(const PackExpansionType *T) {
+  void VisitPackExpansionType(PackExpansionType const *T) {
     AddQualType(T->getPattern());
     VisitType(T);
   }
 
-  void VisitParenType(const ParenType *T) {
+  void VisitParenType(ParenType const *T) {
     AddQualType(T->getInnerType());
     VisitType(T);
   }
 
-  void VisitPipeType(const PipeType *T) {
+  void VisitPipeType(PipeType const *T) {
     AddQualType(T->getElementType());
     Hash.AddBoolean(T->isReadOnly());
     VisitType(T);
   }
 
-  void VisitPointerType(const PointerType *T) {
+  void VisitPointerType(PointerType const *T) {
     AddQualType(T->getPointeeType());
     VisitType(T);
   }
 
-  void VisitReferenceType(const ReferenceType *T) {
+  void VisitReferenceType(ReferenceType const *T) {
     AddQualType(T->getPointeeTypeAsWritten());
     VisitType(T);
   }
 
-  void VisitLValueReferenceType(const LValueReferenceType *T) {
+  void VisitLValueReferenceType(LValueReferenceType const *T) {
     VisitReferenceType(T);
   }
 
-  void VisitRValueReferenceType(const RValueReferenceType *T) {
+  void VisitRValueReferenceType(RValueReferenceType const *T) {
     VisitReferenceType(T);
   }
 
   void
-  VisitSubstTemplateTypeParmPackType(const SubstTemplateTypeParmPackType *T) {
+  VisitSubstTemplateTypeParmPackType(SubstTemplateTypeParmPackType const *T) {
     AddType(T->getReplacedParameter());
     Hash.AddTemplateArgument(T->getArgumentPack());
     VisitType(T);
   }
 
-  void VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
+  void VisitSubstTemplateTypeParmType(SubstTemplateTypeParmType const *T) {
     AddType(T->getReplacedParameter());
     AddQualType(T->getReplacementType());
     VisitType(T);
   }
 
-  void VisitTagType(const TagType *T) {
+  void VisitTagType(TagType const *T) {
     AddDecl(T->getDecl());
     VisitType(T);
   }
 
-  void VisitRecordType(const RecordType *T) { VisitTagType(T); }
-  void VisitEnumType(const EnumType *T) { VisitTagType(T); }
+  void VisitRecordType(RecordType const *T) { VisitTagType(T); }
+  void VisitEnumType(EnumType const *T) { VisitTagType(T); }
 
-  void VisitTemplateSpecializationType(const TemplateSpecializationType *T) {
+  void VisitTemplateSpecializationType(TemplateSpecializationType const *T) {
     ID.AddInteger(T->getNumArgs());
-    for (const auto &TA : T->template_arguments()) {
+    for (auto const &TA : T->template_arguments()) {
       Hash.AddTemplateArgument(TA);
     }
     Hash.AddTemplateName(T->getTemplateName());
     VisitType(T);
   }
 
-  void VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
+  void VisitTemplateTypeParmType(TemplateTypeParmType const *T) {
     ID.AddInteger(T->getDepth());
     ID.AddInteger(T->getIndex());
     Hash.AddBoolean(T->isParameterPack());
     AddDecl(T->getDecl());
   }
 
-  void VisitTypedefType(const TypedefType *T) {
+  void VisitTypedefType(TypedefType const *T) {
     AddDecl(T->getDecl());
     QualType UnderlyingType = T->getDecl()->getUnderlyingType();
     VisitQualifiers(UnderlyingType.getQualifiers());
     while (true) {
-      if (const TypedefType *Underlying =
+      if (TypedefType const *Underlying =
               dyn_cast<TypedefType>(UnderlyingType.getTypePtr())) {
         UnderlyingType = Underlying->getDecl()->getUnderlyingType();
         continue;
       }
-      if (const ElaboratedType *Underlying =
+      if (ElaboratedType const *Underlying =
               dyn_cast<ElaboratedType>(UnderlyingType.getTypePtr())) {
         UnderlyingType = Underlying->getNamedType();
         continue;
@@ -1051,7 +1049,7 @@
     VisitType(T);
   }
 
-  void VisitTypeOfExprType(const TypeOfExprType *T) {
+  void VisitTypeOfExprType(TypeOfExprType const *T) {
     AddStmt(T->getUnderlyingExpr());
     Hash.AddBoolean(T->isSugared());
     if (T->isSugared())
@@ -1059,64 +1057,62 @@
 
     VisitType(T);
   }
-  void VisitTypeOfType(const TypeOfType *T) {
+  void VisitTypeOfType(TypeOfType const *T) {
     AddQualType(T->getUnderlyingType());
     VisitType(T);
   }
 
-  void VisitTypeWithKeyword(const TypeWithKeyword *T) {
+  void VisitTypeWithKeyword(TypeWithKeyword const *T) {
     ID.AddInteger(T->getKeyword());
     VisitType(T);
   };
 
-  void VisitDependentNameType(const DependentNameType *T) {
+  void VisitDependentNameType(DependentNameType const *T) {
     AddNestedNameSpecifier(T->getQualifier());
     AddIdentifierInfo(T->getIdentifier());
     VisitTypeWithKeyword(T);
   }
 
   void VisitDependentTemplateSpecializationType(
-      const DependentTemplateSpecializationType *T) {
+      DependentTemplateSpecializationType const *T) {
     AddIdentifierInfo(T->getIdentifier());
     AddNestedNameSpecifier(T->getQualifier());
     ID.AddInteger(T->getNumArgs());
-    for (const auto &TA : T->template_arguments()) {
+    for (auto const &TA : T->template_arguments()) {
       Hash.AddTemplateArgument(TA);
     }
     VisitTypeWithKeyword(T);
   }
 
-  void VisitElaboratedType(const ElaboratedType *T) {
+  void VisitElaboratedType(ElaboratedType const *T) {
     AddNestedNameSpecifier(T->getQualifier());
     AddQualType(T->getNamedType());
     VisitTypeWithKeyword(T);
   }
 
-  void VisitUnaryTransformType(const UnaryTransformType *T) {
+  void VisitUnaryTransformType(UnaryTransformType const *T) {
     AddQualType(T->getUnderlyingType());
     AddQualType(T->getBaseType());
     VisitType(T);
   }
 
-  void VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
+  void VisitUnresolvedUsingType(UnresolvedUsingType const *T) {
     AddDecl(T->getDecl());
     VisitType(T);
   }
 
-  void VisitVectorType(const VectorType *T) {
+  void VisitVectorType(VectorType const *T) {
     AddQualType(T->getElementType());
     ID.AddInteger(T->getNumElements());
     ID.AddInteger(T->getVectorKind());
     VisitType(T);
   }
 
-  void VisitExtVectorType(const ExtVectorType * T) {
-    VisitVectorType(T);
-  }
+  void VisitExtVectorType(ExtVectorType const *T) { VisitVectorType(T); }
 };
 } // namespace
 
-void ODRHash::AddType(const Type *T) {
+void ODRHash::AddType(Type const *T) {
   assert(T && "Expecting non-null pointer.");
   ODRTypeVisitor(ID, *this).Visit(T);
 }
@@ -1130,6 +1126,4 @@
   AddType(split.Ty);
 }
 
-void ODRHash::AddBoolean(bool Value) {
-  Bools.push_back(Value);
-}
+void ODRHash::AddBoolean(bool Value) { Bools.push_back(Value); }
Index: clang/lib/AST/OSLog.cpp
===================================================================
--- clang/lib/AST/OSLog.cpp
+++ clang/lib/AST/OSLog.cpp
@@ -19,17 +19,17 @@
     : public analyze_format_string::FormatStringHandler {
 private:
   struct ArgData {
-    const Expr *E = nullptr;
+    Expr const *E = nullptr;
     Optional<OSLogBufferItem::Kind> Kind;
     Optional<unsigned> Size;
-    Optional<const Expr *> Count;
-    Optional<const Expr *> Precision;
-    Optional<const Expr *> FieldWidth;
+    Optional<Expr const *> Count;
+    Optional<Expr const *> Precision;
+    Optional<Expr const *> FieldWidth;
     unsigned char Flags = 0;
     StringRef MaskType;
   };
   SmallVector<ArgData, 4> ArgsData;
-  ArrayRef<const Expr *> Args;
+  ArrayRef<Expr const *> Args;
 
   OSLogBufferItem::Kind
   getKind(analyze_format_string::ConversionSpecifier::Kind K) {
@@ -51,12 +51,12 @@
   }
 
 public:
-  OSLogFormatStringHandler(ArrayRef<const Expr *> Args) : Args(Args) {
+  OSLogFormatStringHandler(ArrayRef<Expr const *> Args) : Args(Args) {
     ArgsData.reserve(Args.size());
   }
 
-  bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS,
-                             const char *StartSpecifier,
+  bool HandlePrintfSpecifier(analyze_printf::PrintfSpecifier const &FS,
+                             char const *StartSpecifier,
                              unsigned SpecifierLen) override {
     if (!FS.consumesDataArgument() &&
         FS.getConversionSpecifier().getKind() !=
@@ -137,8 +137,8 @@
     for (auto &Data : ArgsData) {
       if (!Data.MaskType.empty()) {
         CharUnits Size = CharUnits::fromQuantity(8);
-        Layout.Items.emplace_back(OSLogBufferItem::MaskKind, nullptr,
-                                  Size, 0, Data.MaskType);
+        Layout.Items.emplace_back(OSLogBufferItem::MaskKind, nullptr, Size, 0,
+                                  Data.MaskType);
       }
 
       if (Data.FieldWidth) {
@@ -178,11 +178,11 @@
 } // end anonymous namespace
 
 bool clang::analyze_os_log::computeOSLogBufferLayout(
-    ASTContext &Ctx, const CallExpr *E, OSLogBufferLayout &Layout) {
-  ArrayRef<const Expr *> Args(E->getArgs(), E->getArgs() + E->getNumArgs());
+    ASTContext &Ctx, CallExpr const *E, OSLogBufferLayout &Layout) {
+  ArrayRef<Expr const *> Args(E->getArgs(), E->getArgs() + E->getNumArgs());
 
-  const Expr *StringArg;
-  ArrayRef<const Expr *> VarArgs;
+  Expr const *StringArg;
+  ArrayRef<Expr const *> VarArgs;
   switch (E->getBuiltinCallee()) {
   case Builtin::BI__builtin_os_log_format_buffer_size:
     assert(E->getNumArgs() >= 1 &&
@@ -200,7 +200,7 @@
     llvm_unreachable("non-os_log builtin passed to computeOSLogBufferLayout");
   }
 
-  const StringLiteral *Lit = cast<StringLiteral>(StringArg->IgnoreParenCasts());
+  StringLiteral const *Lit = cast<StringLiteral>(StringArg->IgnoreParenCasts());
   assert(Lit && (Lit->isAscii() || Lit->isUTF8()));
   StringRef Data = Lit->getString();
   OSLogFormatStringHandler H(VarArgs);
Index: clang/lib/AST/OpenMPClause.cpp
===================================================================
--- clang/lib/AST/OpenMPClause.cpp
+++ clang/lib/AST/OpenMPClause.cpp
@@ -56,52 +56,52 @@
 }
 
 OMPClauseWithPreInit *OMPClauseWithPreInit::get(OMPClause *C) {
-  auto *Res = OMPClauseWithPreInit::get(const_cast<const OMPClause *>(C));
+  auto *Res = OMPClauseWithPreInit::get(const_cast<OMPClause const *>(C));
   return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr;
 }
 
-const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
+OMPClauseWithPreInit const *OMPClauseWithPreInit::get(OMPClause const *C) {
   switch (C->getClauseKind()) {
   case OMPC_schedule:
-    return static_cast<const OMPScheduleClause *>(C);
+    return static_cast<OMPScheduleClause const *>(C);
   case OMPC_dist_schedule:
-    return static_cast<const OMPDistScheduleClause *>(C);
+    return static_cast<OMPDistScheduleClause const *>(C);
   case OMPC_firstprivate:
-    return static_cast<const OMPFirstprivateClause *>(C);
+    return static_cast<OMPFirstprivateClause const *>(C);
   case OMPC_lastprivate:
-    return static_cast<const OMPLastprivateClause *>(C);
+    return static_cast<OMPLastprivateClause const *>(C);
   case OMPC_reduction:
-    return static_cast<const OMPReductionClause *>(C);
+    return static_cast<OMPReductionClause const *>(C);
   case OMPC_task_reduction:
-    return static_cast<const OMPTaskReductionClause *>(C);
+    return static_cast<OMPTaskReductionClause const *>(C);
   case OMPC_in_reduction:
-    return static_cast<const OMPInReductionClause *>(C);
+    return static_cast<OMPInReductionClause const *>(C);
   case OMPC_linear:
-    return static_cast<const OMPLinearClause *>(C);
+    return static_cast<OMPLinearClause const *>(C);
   case OMPC_if:
-    return static_cast<const OMPIfClause *>(C);
+    return static_cast<OMPIfClause const *>(C);
   case OMPC_num_threads:
-    return static_cast<const OMPNumThreadsClause *>(C);
+    return static_cast<OMPNumThreadsClause const *>(C);
   case OMPC_num_teams:
-    return static_cast<const OMPNumTeamsClause *>(C);
+    return static_cast<OMPNumTeamsClause const *>(C);
   case OMPC_thread_limit:
-    return static_cast<const OMPThreadLimitClause *>(C);
+    return static_cast<OMPThreadLimitClause const *>(C);
   case OMPC_device:
-    return static_cast<const OMPDeviceClause *>(C);
+    return static_cast<OMPDeviceClause const *>(C);
   case OMPC_grainsize:
-    return static_cast<const OMPGrainsizeClause *>(C);
+    return static_cast<OMPGrainsizeClause const *>(C);
   case OMPC_num_tasks:
-    return static_cast<const OMPNumTasksClause *>(C);
+    return static_cast<OMPNumTasksClause const *>(C);
   case OMPC_final:
-    return static_cast<const OMPFinalClause *>(C);
+    return static_cast<OMPFinalClause const *>(C);
   case OMPC_priority:
-    return static_cast<const OMPPriorityClause *>(C);
+    return static_cast<OMPPriorityClause const *>(C);
   case OMPC_novariants:
-    return static_cast<const OMPNovariantsClause *>(C);
+    return static_cast<OMPNovariantsClause const *>(C);
   case OMPC_nocontext:
-    return static_cast<const OMPNocontextClause *>(C);
+    return static_cast<OMPNocontextClause const *>(C);
   case OMPC_filter:
-    return static_cast<const OMPFilterClause *>(C);
+    return static_cast<OMPFilterClause const *>(C);
   case OMPC_default:
   case OMPC_proc_bind:
   case OMPC_safelen:
@@ -169,22 +169,23 @@
 }
 
 OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) {
-  auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C));
+  auto *Res = OMPClauseWithPostUpdate::get(const_cast<OMPClause const *>(C));
   return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr;
 }
 
-const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) {
+OMPClauseWithPostUpdate const *
+OMPClauseWithPostUpdate::get(OMPClause const *C) {
   switch (C->getClauseKind()) {
   case OMPC_lastprivate:
-    return static_cast<const OMPLastprivateClause *>(C);
+    return static_cast<OMPLastprivateClause const *>(C);
   case OMPC_reduction:
-    return static_cast<const OMPReductionClause *>(C);
+    return static_cast<OMPReductionClause const *>(C);
   case OMPC_task_reduction:
-    return static_cast<const OMPTaskReductionClause *>(C);
+    return static_cast<OMPTaskReductionClause const *>(C);
   case OMPC_in_reduction:
-    return static_cast<const OMPInReductionClause *>(C);
+    return static_cast<OMPInReductionClause const *>(C);
   case OMPC_linear:
-    return static_cast<const OMPLinearClause *>(C);
+    return static_cast<OMPLinearClause const *>(C);
   case OMPC_schedule:
   case OMPC_dist_schedule:
   case OMPC_firstprivate:
@@ -320,7 +321,7 @@
   return child_range(&Condition, &Condition + 1);
 }
 
-OMPOrderedClause *OMPOrderedClause::Create(const ASTContext &C, Expr *Num,
+OMPOrderedClause *OMPOrderedClause::Create(ASTContext const &C, Expr *Num,
                                            unsigned NumLoops,
                                            SourceLocation StartLoc,
                                            SourceLocation LParenLoc,
@@ -335,7 +336,7 @@
   return Clause;
 }
 
-OMPOrderedClause *OMPOrderedClause::CreateEmpty(const ASTContext &C,
+OMPOrderedClause *OMPOrderedClause::CreateEmpty(ASTContext const &C,
                                                 unsigned NumLoops) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops));
   auto *Clause = new (Mem) OMPOrderedClause(NumLoops);
@@ -366,19 +367,19 @@
   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
 }
 
-const Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) const {
+Expr const *OMPOrderedClause::getLoopCounter(unsigned NumLoop) const {
   assert(NumLoop < NumberOfLoops && "out of loops number.");
   return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop];
 }
 
-OMPUpdateClause *OMPUpdateClause::Create(const ASTContext &C,
+OMPUpdateClause *OMPUpdateClause::Create(ASTContext const &C,
                                          SourceLocation StartLoc,
                                          SourceLocation EndLoc) {
   return new (C) OMPUpdateClause(StartLoc, EndLoc, /*IsExtended=*/false);
 }
 
 OMPUpdateClause *
-OMPUpdateClause::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPUpdateClause::Create(ASTContext const &C, SourceLocation StartLoc,
                         SourceLocation LParenLoc, SourceLocation ArgumentLoc,
                         OpenMPDependClauseKind DK, SourceLocation EndLoc) {
   void *Mem =
@@ -392,7 +393,7 @@
   return Clause;
 }
 
-OMPUpdateClause *OMPUpdateClause::CreateEmpty(const ASTContext &C,
+OMPUpdateClause *OMPUpdateClause::CreateEmpty(ASTContext const &C,
                                               bool IsExtended) {
   if (!IsExtended)
     return new (C) OMPUpdateClause(/*IsExtended=*/false);
@@ -411,7 +412,7 @@
 }
 
 OMPPrivateClause *
-OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPPrivateClause::Create(ASTContext const &C, SourceLocation StartLoc,
                          SourceLocation LParenLoc, SourceLocation EndLoc,
                          ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
   // Allocate space for private variables and initializer expressions.
@@ -423,7 +424,7 @@
   return Clause;
 }
 
-OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
+OMPPrivateClause *OMPPrivateClause::CreateEmpty(ASTContext const &C,
                                                 unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
   return new (Mem) OMPPrivateClause(N);
@@ -442,7 +443,7 @@
 }
 
 OMPFirstprivateClause *
-OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPFirstprivateClause::Create(ASTContext const &C, SourceLocation StartLoc,
                               SourceLocation LParenLoc, SourceLocation EndLoc,
                               ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
                               ArrayRef<Expr *> InitVL, Stmt *PreInit) {
@@ -456,7 +457,7 @@
   return Clause;
 }
 
-OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
+OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(ASTContext const &C,
                                                           unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N));
   return new (Mem) OMPFirstprivateClause(N);
@@ -491,7 +492,7 @@
 }
 
 OMPLastprivateClause *OMPLastprivateClause::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps,
     OpenMPLastprivateModifier LPKind, SourceLocation LPKindLoc,
@@ -508,13 +509,13 @@
   return Clause;
 }
 
-OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
+OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(ASTContext const &C,
                                                         unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
   return new (Mem) OMPLastprivateClause(N);
 }
 
-OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
+OMPSharedClause *OMPSharedClause::Create(ASTContext const &C,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation EndLoc,
@@ -526,7 +527,7 @@
   return Clause;
 }
 
-OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
+OMPSharedClause *OMPSharedClause::CreateEmpty(ASTContext const &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPSharedClause(N);
 }
@@ -563,7 +564,7 @@
 }
 
 OMPLinearClause *OMPLinearClause::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
     SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
     ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep,
@@ -592,11 +593,12 @@
   return Clause;
 }
 
-OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
+OMPLinearClause *OMPLinearClause::CreateEmpty(ASTContext const &C,
                                               unsigned NumVars) {
   // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions
   // (Step and CalcStep), list of used expression + step.
-  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars  +1));
+  void *Mem =
+      C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars + 1));
   return new (Mem) OMPLinearClause(NumVars);
 }
 
@@ -608,7 +610,7 @@
 }
 
 OMPAlignedClause *
-OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPAlignedClause::Create(ASTContext const &C, SourceLocation StartLoc,
                          SourceLocation LParenLoc, SourceLocation ColonLoc,
                          SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1));
@@ -619,7 +621,7 @@
   return Clause;
 }
 
-OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
+OMPAlignedClause *OMPAlignedClause::CreateEmpty(ASTContext const &C,
                                                 unsigned NumVars) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1));
   return new (Mem) OMPAlignedClause(NumVars);
@@ -648,7 +650,7 @@
 }
 
 OMPCopyinClause *OMPCopyinClause::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
@@ -661,7 +663,7 @@
   return Clause;
 }
 
-OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) {
+OMPCopyinClause *OMPCopyinClause::CreateEmpty(ASTContext const &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
   return new (Mem) OMPCopyinClause(N);
 }
@@ -689,7 +691,7 @@
 }
 
 OMPCopyprivateClause *OMPCopyprivateClause::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
     ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size()));
@@ -702,7 +704,7 @@
   return Clause;
 }
 
-OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
+OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(ASTContext const &C,
                                                         unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N));
   return new (Mem) OMPCopyprivateClause(N);
@@ -762,10 +764,10 @@
 }
 
 OMPReductionClause *OMPReductionClause::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation ModifierLoc, SourceLocation EndLoc, SourceLocation ColonLoc,
     OpenMPReductionClauseModifier Modifier, ArrayRef<Expr *> VL,
-    NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
+    NestedNameSpecifierLoc QualifierLoc, DeclarationNameInfo const &NameInfo,
     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
     ArrayRef<Expr *> CopyOps, ArrayRef<Expr *> CopyArrayTemps,
@@ -798,7 +800,7 @@
 }
 
 OMPReductionClause *
-OMPReductionClause::CreateEmpty(const ASTContext &C, unsigned N,
+OMPReductionClause::CreateEmpty(ASTContext const &C, unsigned N,
                                 OpenMPReductionClauseModifier Modifier) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(
       (Modifier == OMPC_REDUCTION_inscan ? 8 : 5) * N));
@@ -835,9 +837,9 @@
 }
 
 OMPTaskReductionClause *OMPTaskReductionClause::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
-    NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
+    NestedNameSpecifierLoc QualifierLoc, DeclarationNameInfo const &NameInfo,
     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
     Expr *PostUpdate) {
@@ -854,7 +856,7 @@
   return Clause;
 }
 
-OMPTaskReductionClause *OMPTaskReductionClause::CreateEmpty(const ASTContext &C,
+OMPTaskReductionClause *OMPTaskReductionClause::CreateEmpty(ASTContext const &C,
                                                             unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N));
   return new (Mem) OMPTaskReductionClause(N);
@@ -897,9 +899,9 @@
 }
 
 OMPInReductionClause *OMPInReductionClause::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation LParenLoc,
     SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
-    NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
+    NestedNameSpecifierLoc QualifierLoc, DeclarationNameInfo const &NameInfo,
     ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
     ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps,
     ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) {
@@ -917,13 +919,13 @@
   return Clause;
 }
 
-OMPInReductionClause *OMPInReductionClause::CreateEmpty(const ASTContext &C,
+OMPInReductionClause *OMPInReductionClause::CreateEmpty(ASTContext const &C,
                                                         unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * N));
   return new (Mem) OMPInReductionClause(N);
 }
 
-OMPSizesClause *OMPSizesClause::Create(const ASTContext &C,
+OMPSizesClause *OMPSizesClause::Create(ASTContext const &C,
                                        SourceLocation StartLoc,
                                        SourceLocation LParenLoc,
                                        SourceLocation EndLoc,
@@ -936,13 +938,13 @@
   return Clause;
 }
 
-OMPSizesClause *OMPSizesClause::CreateEmpty(const ASTContext &C,
+OMPSizesClause *OMPSizesClause::CreateEmpty(ASTContext const &C,
                                             unsigned NumSizes) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumSizes));
   return new (Mem) OMPSizesClause(NumSizes);
 }
 
-OMPFullClause *OMPFullClause::Create(const ASTContext &C,
+OMPFullClause *OMPFullClause::Create(ASTContext const &C,
                                      SourceLocation StartLoc,
                                      SourceLocation EndLoc) {
   OMPFullClause *Clause = CreateEmpty(C);
@@ -951,11 +953,11 @@
   return Clause;
 }
 
-OMPFullClause *OMPFullClause::CreateEmpty(const ASTContext &C) {
+OMPFullClause *OMPFullClause::CreateEmpty(ASTContext const &C) {
   return new (C) OMPFullClause();
 }
 
-OMPPartialClause *OMPPartialClause::Create(const ASTContext &C,
+OMPPartialClause *OMPPartialClause::Create(ASTContext const &C,
                                            SourceLocation StartLoc,
                                            SourceLocation LParenLoc,
                                            SourceLocation EndLoc,
@@ -968,12 +970,12 @@
   return Clause;
 }
 
-OMPPartialClause *OMPPartialClause::CreateEmpty(const ASTContext &C) {
+OMPPartialClause *OMPPartialClause::CreateEmpty(ASTContext const &C) {
   return new (C) OMPPartialClause();
 }
 
 OMPAllocateClause *
-OMPAllocateClause::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPAllocateClause::Create(ASTContext const &C, SourceLocation StartLoc,
                           SourceLocation LParenLoc, Expr *Allocator,
                           SourceLocation ColonLoc, SourceLocation EndLoc,
                           ArrayRef<Expr *> VL) {
@@ -985,13 +987,13 @@
   return Clause;
 }
 
-OMPAllocateClause *OMPAllocateClause::CreateEmpty(const ASTContext &C,
+OMPAllocateClause *OMPAllocateClause::CreateEmpty(ASTContext const &C,
                                                   unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPAllocateClause(N);
 }
 
-OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
+OMPFlushClause *OMPFlushClause::Create(ASTContext const &C,
                                        SourceLocation StartLoc,
                                        SourceLocation LParenLoc,
                                        SourceLocation EndLoc,
@@ -1003,12 +1005,12 @@
   return Clause;
 }
 
-OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
+OMPFlushClause *OMPFlushClause::CreateEmpty(ASTContext const &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPFlushClause(N);
 }
 
-OMPDepobjClause *OMPDepobjClause::Create(const ASTContext &C,
+OMPDepobjClause *OMPDepobjClause::Create(ASTContext const &C,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation RParenLoc,
@@ -1018,12 +1020,12 @@
   return Clause;
 }
 
-OMPDepobjClause *OMPDepobjClause::CreateEmpty(const ASTContext &C) {
+OMPDepobjClause *OMPDepobjClause::CreateEmpty(ASTContext const &C) {
   return new (C) OMPDepobjClause();
 }
 
 OMPDependClause *
-OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPDependClause::Create(ASTContext const &C, SourceLocation StartLoc,
                         SourceLocation LParenLoc, SourceLocation EndLoc,
                         Expr *DepModifier, OpenMPDependClauseKind DepKind,
                         SourceLocation DepLoc, SourceLocation ColonLoc,
@@ -1038,12 +1040,12 @@
   Clause->setDependencyLoc(DepLoc);
   Clause->setColonLoc(ColonLoc);
   Clause->setModifier(DepModifier);
-  for (unsigned I = 0 ; I < NumLoops; ++I)
+  for (unsigned I = 0; I < NumLoops; ++I)
     Clause->setLoopData(I, nullptr);
   return Clause;
 }
 
-OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N,
+OMPDependClause *OMPDependClause::CreateEmpty(ASTContext const &C, unsigned N,
                                               unsigned NumLoops) {
   void *Mem =
       C.Allocate(totalSizeToAlloc<Expr *>(N + /*depend-modifier*/ 1 + NumLoops),
@@ -1071,13 +1073,13 @@
   return *It;
 }
 
-const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const {
+Expr const *OMPDependClause::getLoopData(unsigned NumLoop) const {
   assert((getDependencyKind() == OMPC_DEPEND_sink ||
           getDependencyKind() == OMPC_DEPEND_source) &&
          NumLoop < NumLoops &&
          "Expected sink or source depend + loop index must be less number of "
          "loops.");
-  const auto *It = std::next(getVarRefs().end(), NumLoop + 1);
+  auto const *It = std::next(getVarRefs().end(), NumLoop + 1);
   return *It;
 }
 
@@ -1095,11 +1097,11 @@
 }
 
 unsigned OMPClauseMappableExprCommon::getUniqueDeclarationsTotalNumber(
-    ArrayRef<const ValueDecl *> Declarations) {
+    ArrayRef<ValueDecl const *> Declarations) {
   unsigned TotalNum = 0u;
-  llvm::SmallPtrSet<const ValueDecl *, 8> Cache;
-  for (const ValueDecl *D : Declarations) {
-    const ValueDecl *VD = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
+  llvm::SmallPtrSet<ValueDecl const *, 8> Cache;
+  for (ValueDecl const *D : Declarations) {
+    ValueDecl const *VD = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
     if (Cache.count(VD))
       continue;
     ++TotalNum;
@@ -1109,7 +1111,7 @@
 }
 
 OMPMapClause *OMPMapClause::Create(
-    const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
+    ASTContext const &C, OMPVarListLocTy const &Locs, ArrayRef<Expr *> Vars,
     ArrayRef<ValueDecl *> Declarations,
     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
     ArrayRef<OpenMPMapModifierKind> MapModifiers,
@@ -1151,8 +1153,8 @@
 }
 
 OMPMapClause *
-OMPMapClause::CreateEmpty(const ASTContext &C,
-                          const OMPMappableExprListSizeTy &Sizes) {
+OMPMapClause::CreateEmpty(ASTContext const &C,
+                          OMPMappableExprListSizeTy const &Sizes) {
   void *Mem = C.Allocate(
       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
                        OMPClauseMappableExprCommon::MappableComponent>(
@@ -1163,7 +1165,7 @@
 }
 
 OMPToClause *OMPToClause::Create(
-    const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
+    ASTContext const &C, OMPVarListLocTy const &Locs, ArrayRef<Expr *> Vars,
     ArrayRef<ValueDecl *> Declarations,
     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
     ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
@@ -1201,8 +1203,8 @@
   return Clause;
 }
 
-OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C,
-                                      const OMPMappableExprListSizeTy &Sizes) {
+OMPToClause *OMPToClause::CreateEmpty(ASTContext const &C,
+                                      OMPMappableExprListSizeTy const &Sizes) {
   void *Mem = C.Allocate(
       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
                        OMPClauseMappableExprCommon::MappableComponent>(
@@ -1213,7 +1215,7 @@
 }
 
 OMPFromClause *OMPFromClause::Create(
-    const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
+    ASTContext const &C, OMPVarListLocTy const &Locs, ArrayRef<Expr *> Vars,
     ArrayRef<ValueDecl *> Declarations,
     MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs,
     ArrayRef<OpenMPMotionModifierKind> MotionModifiers,
@@ -1253,8 +1255,8 @@
 }
 
 OMPFromClause *
-OMPFromClause::CreateEmpty(const ASTContext &C,
-                           const OMPMappableExprListSizeTy &Sizes) {
+OMPFromClause::CreateEmpty(ASTContext const &C,
+                           OMPMappableExprListSizeTy const &Sizes) {
   void *Mem = C.Allocate(
       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
                        OMPClauseMappableExprCommon::MappableComponent>(
@@ -1277,7 +1279,7 @@
 }
 
 OMPUseDevicePtrClause *OMPUseDevicePtrClause::Create(
-    const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars,
+    ASTContext const &C, OMPVarListLocTy const &Locs, ArrayRef<Expr *> Vars,
     ArrayRef<Expr *> PrivateVars, ArrayRef<Expr *> Inits,
     ArrayRef<ValueDecl *> Declarations,
     MappableExprComponentListsRef ComponentLists) {
@@ -1314,8 +1316,8 @@
 }
 
 OMPUseDevicePtrClause *
-OMPUseDevicePtrClause::CreateEmpty(const ASTContext &C,
-                                   const OMPMappableExprListSizeTy &Sizes) {
+OMPUseDevicePtrClause::CreateEmpty(ASTContext const &C,
+                                   OMPMappableExprListSizeTy const &Sizes) {
   void *Mem = C.Allocate(
       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
                        OMPClauseMappableExprCommon::MappableComponent>(
@@ -1326,7 +1328,7 @@
 }
 
 OMPUseDeviceAddrClause *
-OMPUseDeviceAddrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
+OMPUseDeviceAddrClause::Create(ASTContext const &C, OMPVarListLocTy const &Locs,
                                ArrayRef<Expr *> Vars,
                                ArrayRef<ValueDecl *> Declarations,
                                MappableExprComponentListsRef ComponentLists) {
@@ -1361,8 +1363,8 @@
 }
 
 OMPUseDeviceAddrClause *
-OMPUseDeviceAddrClause::CreateEmpty(const ASTContext &C,
-                                    const OMPMappableExprListSizeTy &Sizes) {
+OMPUseDeviceAddrClause::CreateEmpty(ASTContext const &C,
+                                    OMPMappableExprListSizeTy const &Sizes) {
   void *Mem = C.Allocate(
       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
                        OMPClauseMappableExprCommon::MappableComponent>(
@@ -1373,7 +1375,7 @@
 }
 
 OMPIsDevicePtrClause *
-OMPIsDevicePtrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs,
+OMPIsDevicePtrClause::Create(ASTContext const &C, OMPVarListLocTy const &Locs,
                              ArrayRef<Expr *> Vars,
                              ArrayRef<ValueDecl *> Declarations,
                              MappableExprComponentListsRef ComponentLists) {
@@ -1408,8 +1410,8 @@
 }
 
 OMPIsDevicePtrClause *
-OMPIsDevicePtrClause::CreateEmpty(const ASTContext &C,
-                                  const OMPMappableExprListSizeTy &Sizes) {
+OMPIsDevicePtrClause::CreateEmpty(ASTContext const &C,
+                                  OMPMappableExprListSizeTy const &Sizes) {
   void *Mem = C.Allocate(
       totalSizeToAlloc<Expr *, ValueDecl *, unsigned,
                        OMPClauseMappableExprCommon::MappableComponent>(
@@ -1419,7 +1421,7 @@
   return new (Mem) OMPIsDevicePtrClause(Sizes);
 }
 
-OMPNontemporalClause *OMPNontemporalClause::Create(const ASTContext &C,
+OMPNontemporalClause *OMPNontemporalClause::Create(ASTContext const &C,
                                                    SourceLocation StartLoc,
                                                    SourceLocation LParenLoc,
                                                    SourceLocation EndLoc,
@@ -1432,7 +1434,7 @@
   return Clause;
 }
 
-OMPNontemporalClause *OMPNontemporalClause::CreateEmpty(const ASTContext &C,
+OMPNontemporalClause *OMPNontemporalClause::CreateEmpty(ASTContext const &C,
                                                         unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N));
   return new (Mem) OMPNontemporalClause(N);
@@ -1444,7 +1446,7 @@
   std::copy(VL.begin(), VL.end(), varlist_end());
 }
 
-OMPInclusiveClause *OMPInclusiveClause::Create(const ASTContext &C,
+OMPInclusiveClause *OMPInclusiveClause::Create(ASTContext const &C,
                                                SourceLocation StartLoc,
                                                SourceLocation LParenLoc,
                                                SourceLocation EndLoc,
@@ -1456,13 +1458,13 @@
   return Clause;
 }
 
-OMPInclusiveClause *OMPInclusiveClause::CreateEmpty(const ASTContext &C,
+OMPInclusiveClause *OMPInclusiveClause::CreateEmpty(ASTContext const &C,
                                                     unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPInclusiveClause(N);
 }
 
-OMPExclusiveClause *OMPExclusiveClause::Create(const ASTContext &C,
+OMPExclusiveClause *OMPExclusiveClause::Create(ASTContext const &C,
                                                SourceLocation StartLoc,
                                                SourceLocation LParenLoc,
                                                SourceLocation EndLoc,
@@ -1474,7 +1476,7 @@
   return Clause;
 }
 
-OMPExclusiveClause *OMPExclusiveClause::CreateEmpty(const ASTContext &C,
+OMPExclusiveClause *OMPExclusiveClause::CreateEmpty(ASTContext const &C,
                                                     unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPExclusiveClause(N);
@@ -1485,7 +1487,7 @@
   assert(Data.size() == NumOfAllocators &&
          "Size of allocators data is not the same as the preallocated buffer.");
   for (unsigned I = 0, E = Data.size(); I < E; ++I) {
-    const OMPUsesAllocatorsClause::Data &D = Data[I];
+    OMPUsesAllocatorsClause::Data const &D = Data[I];
     getTrailingObjects<Expr *>()[I * static_cast<int>(ExprOffsets::Total) +
                                  static_cast<int>(ExprOffsets::Allocator)] =
         D.Allocator;
@@ -1524,7 +1526,7 @@
 }
 
 OMPUsesAllocatorsClause *
-OMPUsesAllocatorsClause::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPUsesAllocatorsClause::Create(ASTContext const &C, SourceLocation StartLoc,
                                 SourceLocation LParenLoc, SourceLocation EndLoc,
                                 ArrayRef<OMPUsesAllocatorsClause::Data> Data) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *, SourceLocation>(
@@ -1537,7 +1539,7 @@
 }
 
 OMPUsesAllocatorsClause *
-OMPUsesAllocatorsClause::CreateEmpty(const ASTContext &C, unsigned N) {
+OMPUsesAllocatorsClause::CreateEmpty(ASTContext const &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *, SourceLocation>(
       static_cast<int>(ExprOffsets::Total) * N,
       static_cast<int>(ParenLocsOffsets::Total) * N));
@@ -1545,7 +1547,7 @@
 }
 
 OMPAffinityClause *
-OMPAffinityClause::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPAffinityClause::Create(ASTContext const &C, SourceLocation StartLoc,
                           SourceLocation LParenLoc, SourceLocation ColonLoc,
                           SourceLocation EndLoc, Expr *Modifier,
                           ArrayRef<Expr *> Locators) {
@@ -1557,13 +1559,13 @@
   return Clause;
 }
 
-OMPAffinityClause *OMPAffinityClause::CreateEmpty(const ASTContext &C,
+OMPAffinityClause *OMPAffinityClause::CreateEmpty(ASTContext const &C,
                                                   unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N + 1));
   return new (Mem) OMPAffinityClause(N);
 }
 
-OMPInitClause *OMPInitClause::Create(const ASTContext &C, Expr *InteropVar,
+OMPInitClause *OMPInitClause::Create(ASTContext const &C, Expr *InteropVar,
                                      ArrayRef<Expr *> PrefExprs, bool IsTarget,
                                      bool IsTargetSync, SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
@@ -1579,7 +1581,7 @@
   return Clause;
 }
 
-OMPInitClause *OMPInitClause::CreateEmpty(const ASTContext &C, unsigned N) {
+OMPInitClause *OMPInitClause::CreateEmpty(ASTContext const &C, unsigned N) {
   void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N));
   return new (Mem) OMPInitClause(N);
 }
@@ -1841,7 +1843,7 @@
 void OMPClausePrinter::VisitOMPInitClause(OMPInitClause *Node) {
   OS << "init(";
   bool First = true;
-  for (const Expr *E : Node->prefs()) {
+  for (Expr const *E : Node->prefs()) {
     if (First)
       OS << "prefer_type(";
     else
@@ -1896,7 +1898,7 @@
   }
 }
 
-template<typename T>
+template <typename T>
 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
   for (typename T::varlist_iterator I = Node->varlist_begin(),
                                     E = Node->varlist_end();
@@ -2112,7 +2114,7 @@
 
 template <typename T>
 static void PrintMapper(raw_ostream &OS, T *Node,
-                        const PrintingPolicy &Policy) {
+                        PrintingPolicy const &Policy) {
   OS << '(';
   NestedNameSpecifier *MapperNNS =
       Node->getMapperQualifierLoc().getNestedNameSpecifier();
@@ -2180,8 +2182,9 @@
 }
 
 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) {
-  OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName(
-                           OMPC_dist_schedule, Node->getDistScheduleKind());
+  OS << "dist_schedule("
+     << getOpenMPSimpleClauseTypeName(OMPC_dist_schedule,
+                                      Node->getDistScheduleKind());
   if (auto *E = Node->getChunkSize()) {
     OS << ", ";
     E->printPretty(OS, nullptr, Policy);
@@ -2297,8 +2300,8 @@
 
 void OMPTraitInfo::getAsVariantMatchInfo(ASTContext &ASTCtx,
                                          VariantMatchInfo &VMI) const {
-  for (const OMPTraitSet &Set : Sets) {
-    for (const OMPTraitSelector &Selector : Set.Selectors) {
+  for (OMPTraitSet const &Set : Sets) {
+    for (OMPTraitSelector const &Selector : Set.Selectors) {
 
       // User conditions are special as we evaluate the condition here.
       if (Selector.Kind == TraitSelector::user_condition) {
@@ -2330,7 +2333,7 @@
                        "<non-constant-score>");
       }
 
-      for (const OMPTraitProperty &Property : Selector.Properties)
+      for (OMPTraitProperty const &Property : Selector.Properties)
         VMI.addTrait(Set.Kind, Property.Kind, Property.RawString, ScorePtr);
 
       if (Set.Kind != TraitSet::construct)
@@ -2339,8 +2342,7 @@
       // TODO: This might not hold once we implement SIMD properly.
       assert(Selector.Properties.size() == 1 &&
              Selector.Properties.front().Kind ==
-                 getOpenMPContextTraitPropertyForSelector(
-                     Selector.Kind) &&
+                 getOpenMPContextTraitPropertyForSelector(Selector.Kind) &&
              "Ill-formed construct selector!");
 
       VMI.ConstructTraits.push_back(Selector.Properties.front().Kind);
@@ -2349,16 +2351,16 @@
 }
 
 void OMPTraitInfo::print(llvm::raw_ostream &OS,
-                         const PrintingPolicy &Policy) const {
+                         PrintingPolicy const &Policy) const {
   bool FirstSet = true;
-  for (const OMPTraitSet &Set : Sets) {
+  for (OMPTraitSet const &Set : Sets) {
     if (!FirstSet)
       OS << ", ";
     FirstSet = false;
     OS << getOpenMPContextTraitSetName(Set.Kind) << "={";
 
     bool FirstSelector = true;
-    for (const OMPTraitSelector &Selector : Set.Selectors) {
+    for (OMPTraitSelector const &Selector : Set.Selectors) {
       if (!FirstSelector)
         OS << ", ";
       FirstSelector = false;
@@ -2366,8 +2368,8 @@
 
       bool AllowsTraitScore = false;
       bool RequiresProperty = false;
-      isValidTraitSelectorForTraitSet(
-          Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
+      isValidTraitSelectorForTraitSet(Selector.Kind, Set.Kind, AllowsTraitScore,
+                                      RequiresProperty);
 
       if (!RequiresProperty)
         continue;
@@ -2387,7 +2389,7 @@
         }
 
         bool FirstProperty = true;
-        for (const OMPTraitProperty &Property : Selector.Properties) {
+        for (OMPTraitProperty const &Property : Selector.Properties) {
           if (!FirstProperty)
             OS << ", ";
           FirstProperty = false;
@@ -2404,21 +2406,20 @@
 std::string OMPTraitInfo::getMangledName() const {
   std::string MangledName;
   llvm::raw_string_ostream OS(MangledName);
-  for (const OMPTraitSet &Set : Sets) {
+  for (OMPTraitSet const &Set : Sets) {
     OS << '$' << 'S' << unsigned(Set.Kind);
-    for (const OMPTraitSelector &Selector : Set.Selectors) {
+    for (OMPTraitSelector const &Selector : Set.Selectors) {
 
       bool AllowsTraitScore = false;
       bool RequiresProperty = false;
-      isValidTraitSelectorForTraitSet(
-          Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty);
+      isValidTraitSelectorForTraitSet(Selector.Kind, Set.Kind, AllowsTraitScore,
+                                      RequiresProperty);
       OS << '$' << 's' << unsigned(Selector.Kind);
 
-      if (!RequiresProperty ||
-          Selector.Kind == TraitSelector::user_condition)
+      if (!RequiresProperty || Selector.Kind == TraitSelector::user_condition)
         continue;
 
-      for (const OMPTraitProperty &Property : Selector.Properties)
+      for (OMPTraitProperty const &Property : Selector.Properties)
         OS << '$' << 'P'
            << getOpenMPContextTraitPropertyName(Property.Kind,
                                                 Property.RawString);
@@ -2461,20 +2462,20 @@
 }
 
 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
-                                     const OMPTraitInfo &TI) {
+                                     OMPTraitInfo const &TI) {
   LangOptions LO;
   PrintingPolicy Policy(LO);
   TI.print(OS, Policy);
   return OS;
 }
 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS,
-                                     const OMPTraitInfo *TI) {
+                                     OMPTraitInfo const *TI) {
   return TI ? OS << *TI : OS;
 }
 
 TargetOMPContext::TargetOMPContext(
     ASTContext &ASTCtx, std::function<void(StringRef)> &&DiagUnknownTrait,
-    const FunctionDecl *CurrentFunctionDecl)
+    FunctionDecl const *CurrentFunctionDecl)
     : OMPContext(ASTCtx.getLangOpts().OpenMPIsDevice,
                  ASTCtx.getTargetInfo().getTriple()),
       FeatureValidityCheck([&](StringRef FeatureName) {
Index: clang/lib/AST/ParentMap.cpp
===================================================================
--- clang/lib/AST/ParentMap.cpp
+++ clang/lib/AST/ParentMap.cpp
@@ -19,14 +19,11 @@
 
 using namespace clang;
 
-typedef llvm::DenseMap<Stmt*, Stmt*> MapTy;
+typedef llvm::DenseMap<Stmt *, Stmt *> MapTy;
 
-enum OpaqueValueMode {
-  OV_Transparent,
-  OV_Opaque
-};
+enum OpaqueValueMode { OV_Transparent, OV_Opaque };
 
-static void BuildParentMap(MapTy& M, Stmt* S,
+static void BuildParentMap(MapTy &M, Stmt *S,
                            OpaqueValueMode OVMode = OV_Transparent) {
   if (!S)
     return;
@@ -114,39 +111,38 @@
   }
 }
 
-ParentMap::~ParentMap() {
-  delete (MapTy*) Impl;
-}
+ParentMap::~ParentMap() { delete (MapTy *)Impl; }
 
-void ParentMap::addStmt(Stmt* S) {
+void ParentMap::addStmt(Stmt *S) {
   if (S) {
-    BuildParentMap(*(MapTy*) Impl, S);
+    BuildParentMap(*(MapTy *)Impl, S);
   }
 }
 
-void ParentMap::setParent(const Stmt *S, const Stmt *Parent) {
+void ParentMap::setParent(Stmt const *S, Stmt const *Parent) {
   assert(S);
   assert(Parent);
   MapTy *M = reinterpret_cast<MapTy *>(Impl);
   M->insert(std::make_pair(const_cast<Stmt *>(S), const_cast<Stmt *>(Parent)));
 }
 
-Stmt* ParentMap::getParent(Stmt* S) const {
-  MapTy* M = (MapTy*) Impl;
+Stmt *ParentMap::getParent(Stmt *S) const {
+  MapTy *M = (MapTy *)Impl;
   MapTy::iterator I = M->find(S);
   return I == M->end() ? nullptr : I->second;
 }
 
 Stmt *ParentMap::getParentIgnoreParens(Stmt *S) const {
-  do { S = getParent(S); } while (S && isa<ParenExpr>(S));
+  do {
+    S = getParent(S);
+  } while (S && isa<ParenExpr>(S));
   return S;
 }
 
 Stmt *ParentMap::getParentIgnoreParenCasts(Stmt *S) const {
   do {
     S = getParent(S);
-  }
-  while (S && (isa<ParenExpr>(S) || isa<CastExpr>(S)));
+  } while (S && (isa<ParenExpr>(S) || isa<CastExpr>(S)));
 
   return S;
 }
@@ -168,13 +164,12 @@
   return Paren;
 }
 
-bool ParentMap::isConsumedExpr(Expr* E) const {
+bool ParentMap::isConsumedExpr(Expr *E) const {
   Stmt *P = getParent(E);
   Stmt *DirectChild = E;
 
   // Ignore parents that don't guarantee consumption.
-  while (P && (isa<ParenExpr>(P) || isa<CastExpr>(P) ||
-               isa<FullExpr>(P))) {
+  while (P && (isa<ParenExpr>(P) || isa<CastExpr>(P) || isa<FullExpr>(P))) {
     DirectChild = P;
     P = getParent(P);
   }
@@ -183,32 +178,31 @@
     return false;
 
   switch (P->getStmtClass()) {
-    default:
-      return isa<Expr>(P);
-    case Stmt::DeclStmtClass:
-      return true;
-    case Stmt::BinaryOperatorClass: {
-      BinaryOperator *BE = cast<BinaryOperator>(P);
-      // If it is a comma, only the right side is consumed.
-      // If it isn't a comma, both sides are consumed.
-      return BE->getOpcode()!=BO_Comma ||DirectChild==BE->getRHS();
-    }
-    case Stmt::ForStmtClass:
-      return DirectChild == cast<ForStmt>(P)->getCond();
-    case Stmt::WhileStmtClass:
-      return DirectChild == cast<WhileStmt>(P)->getCond();
-    case Stmt::DoStmtClass:
-      return DirectChild == cast<DoStmt>(P)->getCond();
-    case Stmt::IfStmtClass:
-      return DirectChild == cast<IfStmt>(P)->getCond();
-    case Stmt::IndirectGotoStmtClass:
-      return DirectChild == cast<IndirectGotoStmt>(P)->getTarget();
-    case Stmt::SwitchStmtClass:
-      return DirectChild == cast<SwitchStmt>(P)->getCond();
-    case Stmt::ObjCForCollectionStmtClass:
-      return DirectChild == cast<ObjCForCollectionStmt>(P)->getCollection();
-    case Stmt::ReturnStmtClass:
-      return true;
+  default:
+    return isa<Expr>(P);
+  case Stmt::DeclStmtClass:
+    return true;
+  case Stmt::BinaryOperatorClass: {
+    BinaryOperator *BE = cast<BinaryOperator>(P);
+    // If it is a comma, only the right side is consumed.
+    // If it isn't a comma, both sides are consumed.
+    return BE->getOpcode() != BO_Comma || DirectChild == BE->getRHS();
+  }
+  case Stmt::ForStmtClass:
+    return DirectChild == cast<ForStmt>(P)->getCond();
+  case Stmt::WhileStmtClass:
+    return DirectChild == cast<WhileStmt>(P)->getCond();
+  case Stmt::DoStmtClass:
+    return DirectChild == cast<DoStmt>(P)->getCond();
+  case Stmt::IfStmtClass:
+    return DirectChild == cast<IfStmt>(P)->getCond();
+  case Stmt::IndirectGotoStmtClass:
+    return DirectChild == cast<IndirectGotoStmt>(P)->getTarget();
+  case Stmt::SwitchStmtClass:
+    return DirectChild == cast<SwitchStmt>(P)->getCond();
+  case Stmt::ObjCForCollectionStmtClass:
+    return DirectChild == cast<ObjCForCollectionStmt>(P)->getCollection();
+  case Stmt::ReturnStmtClass:
+    return true;
   }
 }
-
Index: clang/lib/AST/ParentMapContext.cpp
===================================================================
--- clang/lib/AST/ParentMapContext.cpp
+++ clang/lib/AST/ParentMapContext.cpp
@@ -12,9 +12,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ParentMapContext.h"
-#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TemplateBase.h"
 
 using namespace clang;
@@ -25,7 +25,7 @@
 
 void ParentMapContext::clear() { Parents.reset(); }
 
-const Expr *ParentMapContext::traverseIgnored(const Expr *E) const {
+Expr const *ParentMapContext::traverseIgnored(Expr const *E) const {
   return traverseIgnored(const_cast<Expr *>(E));
 }
 
@@ -42,8 +42,8 @@
   llvm_unreachable("Invalid Traversal type!");
 }
 
-DynTypedNode ParentMapContext::traverseIgnored(const DynTypedNode &N) const {
-  if (const auto *E = N.get<Expr>()) {
+DynTypedNode ParentMapContext::traverseIgnored(DynTypedNode const &N) const {
+  if (auto const *E = N.get<Expr>()) {
     return DynTypedNode::create(*traverseIgnored(E));
   }
   return N;
@@ -51,7 +51,7 @@
 
 template <typename T, typename... U>
 std::tuple<bool, DynTypedNodeList, const T *, const U *...>
-matchParents(const DynTypedNodeList &NodeList,
+matchParents(DynTypedNodeList const &NodeList,
              ParentMapContext::ParentMap *ParentMap);
 
 template <typename, typename...> struct MatchParents;
@@ -67,15 +67,15 @@
   /// pointer identity only, which are more common and we can save space by
   /// only storing a unique pointer to them.
   using ParentMapPointers =
-      llvm::DenseMap<const void *,
-                     llvm::PointerUnion<const Decl *, const Stmt *,
+      llvm::DenseMap<void const *,
+                     llvm::PointerUnion<Decl const *, Stmt const *,
                                         DynTypedNode *, ParentVector *>>;
 
   /// Parent map for nodes without pointer identity. We store a full
   /// DynTypedNode for all keys.
   using ParentMapOtherNodes =
       llvm::DenseMap<DynTypedNode,
-                     llvm::PointerUnion<const Decl *, const Stmt *,
+                     llvm::PointerUnion<Decl const *, Stmt const *,
                                         DynTypedNode *, ParentVector *>>;
 
   ParentMapPointers PointerParents;
@@ -84,21 +84,21 @@
 
   static DynTypedNode
   getSingleDynTypedNodeFromParentMap(ParentMapPointers::mapped_type U) {
-    if (const auto *D = U.dyn_cast<const Decl *>())
+    if (auto const *D = U.dyn_cast<Decl const *>())
       return DynTypedNode::create(*D);
-    if (const auto *S = U.dyn_cast<const Stmt *>())
+    if (auto const *S = U.dyn_cast<Stmt const *>())
       return DynTypedNode::create(*S);
     return *U.get<DynTypedNode *>();
   }
 
   template <typename NodeTy, typename MapTy>
-  static DynTypedNodeList getDynNodeFromMap(const NodeTy &Node,
-                                                        const MapTy &Map) {
+  static DynTypedNodeList getDynNodeFromMap(NodeTy const &Node,
+                                            MapTy const &Map) {
     auto I = Map.find(Node);
     if (I == Map.end()) {
       return llvm::ArrayRef<DynTypedNode>();
     }
-    if (const auto *V = I->second.template dyn_cast<ParentVector *>()) {
+    if (auto const *V = I->second.template dyn_cast<ParentVector *>()) {
       return llvm::makeArrayRef(*V);
     }
     return getSingleDynTypedNodeFromParentMap(I->second);
@@ -107,14 +107,14 @@
 public:
   ParentMap(ASTContext &Ctx);
   ~ParentMap() {
-    for (const auto &Entry : PointerParents) {
+    for (auto const &Entry : PointerParents) {
       if (Entry.second.is<DynTypedNode *>()) {
         delete Entry.second.get<DynTypedNode *>();
       } else if (Entry.second.is<ParentVector *>()) {
         delete Entry.second.get<ParentVector *>();
       }
     }
-    for (const auto &Entry : OtherParents) {
+    for (auto const &Entry : OtherParents) {
       if (Entry.second.is<DynTypedNode *>()) {
         delete Entry.second.get<DynTypedNode *>();
       } else if (Entry.second.is<ParentVector *>()) {
@@ -123,13 +123,13 @@
     }
   }
 
-  DynTypedNodeList getParents(TraversalKind TK, const DynTypedNode &Node) {
+  DynTypedNodeList getParents(TraversalKind TK, DynTypedNode const &Node) {
     if (Node.getNodeKind().hasPointerIdentity()) {
       auto ParentList =
           getDynNodeFromMap(Node.getMemoizationData(), PointerParents);
       if (ParentList.size() > 0 && TK == TK_IgnoreUnlessSpelledInSource) {
 
-        const auto *ChildExpr = Node.get<Expr>();
+        auto const *ChildExpr = Node.get<Expr>();
 
         {
           // Don't match explicit node types because different stdlib
@@ -141,11 +141,11 @@
           int I = 0;
           while (ChildExpr && RewrittenBinOpParentsList.size() == 1 &&
                  I++ < 4) {
-            const auto *S = RewrittenBinOpParentsList[0].get<Stmt>();
+            auto const *S = RewrittenBinOpParentsList[0].get<Stmt>();
             if (!S)
               break;
 
-            const auto *RWBO = dyn_cast<CXXRewrittenBinaryOperator>(S);
+            auto const *RWBO = dyn_cast<CXXRewrittenBinaryOperator>(S);
             if (!RWBO) {
               RewrittenBinOpParentsList = getDynNodeFromMap(S, PointerParents);
               continue;
@@ -157,7 +157,7 @@
           }
         }
 
-        const auto *ParentExpr = ParentList[0].get<Expr>();
+        auto const *ParentExpr = ParentList[0].get<Expr>();
         if (ParentExpr && ChildExpr)
           return AscendIgnoreUnlessSpelledInSource(ParentExpr, ChildExpr);
 
@@ -165,18 +165,18 @@
           auto AncestorNodes =
               matchParents<DeclStmt, CXXForRangeStmt>(ParentList, this);
           if (std::get<bool>(AncestorNodes) &&
-              std::get<const CXXForRangeStmt *>(AncestorNodes)
+              std::get<CXXForRangeStmt const *>(AncestorNodes)
                       ->getLoopVarStmt() ==
-                  std::get<const DeclStmt *>(AncestorNodes))
+                  std::get<DeclStmt const *>(AncestorNodes))
             return std::get<DynTypedNodeList>(AncestorNodes);
         }
         {
           auto AncestorNodes = matchParents<VarDecl, DeclStmt, CXXForRangeStmt>(
               ParentList, this);
           if (std::get<bool>(AncestorNodes) &&
-              std::get<const CXXForRangeStmt *>(AncestorNodes)
+              std::get<CXXForRangeStmt const *>(AncestorNodes)
                       ->getRangeStmt() ==
-                  std::get<const DeclStmt *>(AncestorNodes))
+                  std::get<DeclStmt const *>(AncestorNodes))
             return std::get<DynTypedNodeList>(AncestorNodes);
         }
         {
@@ -199,10 +199,10 @@
     return getDynNodeFromMap(Node, OtherParents);
   }
 
-  DynTypedNodeList AscendIgnoreUnlessSpelledInSource(const Expr *E,
-                                                     const Expr *Child) {
+  DynTypedNodeList AscendIgnoreUnlessSpelledInSource(Expr const *E,
+                                                     Expr const *Child) {
 
-    auto ShouldSkip = [](const Expr *E, const Expr *Child) {
+    auto ShouldSkip = [](Expr const *E, Expr const *Child) {
       if (isa<ImplicitCastExpr>(E))
         return true;
 
@@ -249,13 +249,13 @@
       auto It = PointerParents.find(E);
       if (It == PointerParents.end())
         break;
-      const auto *S = It->second.dyn_cast<const Stmt *>();
+      auto const *S = It->second.dyn_cast<Stmt const *>();
       if (!S) {
         if (auto *Vec = It->second.dyn_cast<ParentVector *>())
           return llvm::makeArrayRef(*Vec);
         return getSingleDynTypedNodeFromParentMap(It->second);
       }
-      const auto *P = dyn_cast<Expr>(S);
+      auto const *P = dyn_cast<Expr>(S);
       if (!P)
         return DynTypedNode::create(*S);
       Child = E;
@@ -266,20 +266,20 @@
 };
 
 template <typename Tuple, std::size_t... Is>
-auto tuple_pop_front_impl(const Tuple &tuple, std::index_sequence<Is...>) {
+auto tuple_pop_front_impl(Tuple const &tuple, std::index_sequence<Is...>) {
   return std::make_tuple(std::get<1 + Is>(tuple)...);
 }
 
-template <typename Tuple> auto tuple_pop_front(const Tuple &tuple) {
+template <typename Tuple> auto tuple_pop_front(Tuple const &tuple) {
   return tuple_pop_front_impl(
       tuple, std::make_index_sequence<std::tuple_size<Tuple>::value - 1>());
 }
 
 template <typename T, typename... U> struct MatchParents {
   static std::tuple<bool, DynTypedNodeList, const T *, const U *...>
-  match(const DynTypedNodeList &NodeList,
+  match(DynTypedNodeList const &NodeList,
         ParentMapContext::ParentMap *ParentMap) {
-    if (const auto *TypedNode = NodeList[0].get<T>()) {
+    if (auto const *TypedNode = NodeList[0].get<T>()) {
       auto NextParentList =
           ParentMap->getDynNodeFromMap(TypedNode, ParentMap->PointerParents);
       if (NextParentList.size() == 1) {
@@ -299,9 +299,9 @@
 
 template <typename T> struct MatchParents<T> {
   static std::tuple<bool, DynTypedNodeList, const T *>
-  match(const DynTypedNodeList &NodeList,
+  match(DynTypedNodeList const &NodeList,
         ParentMapContext::ParentMap *ParentMap) {
-    if (const auto *TypedNode = NodeList[0].get<T>()) {
+    if (auto const *TypedNode = NodeList[0].get<T>()) {
       auto NextParentList =
           ParentMap->getDynNodeFromMap(TypedNode, ParentMap->PointerParents);
       if (NextParentList.size() == 1)
@@ -313,7 +313,7 @@
 
 template <typename T, typename... U>
 std::tuple<bool, DynTypedNodeList, const T *, const U *...>
-matchParents(const DynTypedNodeList &NodeList,
+matchParents(DynTypedNodeList const &NodeList,
              ParentMapContext::ParentMap *ParentMap) {
   return MatchParents<T, U...>::match(NodeList, ParentMap);
 }
@@ -323,11 +323,11 @@
 template <typename T> static DynTypedNode createDynTypedNode(const T &Node) {
   return DynTypedNode::create(*Node);
 }
-template <> DynTypedNode createDynTypedNode(const TypeLoc &Node) {
+template <> DynTypedNode createDynTypedNode(TypeLoc const &Node) {
   return DynTypedNode::create(Node);
 }
 template <>
-DynTypedNode createDynTypedNode(const NestedNameSpecifierLoc &Node) {
+DynTypedNode createDynTypedNode(NestedNameSpecifierLoc const &Node) {
   return DynTypedNode::create(Node);
 }
 /// @}
@@ -372,9 +372,9 @@
     // do not have pointer identity.
     auto &NodeOrVector = (*Parents)[MapNode];
     if (NodeOrVector.isNull()) {
-      if (const auto *D = ParentStack.back().get<Decl>())
+      if (auto const *D = ParentStack.back().get<Decl>())
         NodeOrVector = D;
-      else if (const auto *S = ParentStack.back().get<Stmt>())
+      else if (auto const *S = ParentStack.back().get<Stmt>())
         NodeOrVector = S;
       else
         NodeOrVector = new DynTypedNode(ParentStack.back());
@@ -454,7 +454,7 @@
   ASTVisitor(*this).TraverseAST(Ctx);
 }
 
-DynTypedNodeList ParentMapContext::getParents(const DynTypedNode &Node) {
+DynTypedNodeList ParentMapContext::getParents(DynTypedNode const &Node) {
   if (!Parents)
     // We build the parent map for the traversal scope (usually whole TU), as
     // hasAncestor can escape any subtree.
Index: clang/lib/AST/PrintfFormatString.cpp
===================================================================
--- clang/lib/AST/PrintfFormatString.cpp
+++ clang/lib/AST/PrintfFormatString.cpp
@@ -18,16 +18,16 @@
 #include "llvm/Support/Regex.h"
 
 using clang::analyze_format_string::ArgType;
+using clang::analyze_format_string::ConversionSpecifier;
 using clang::analyze_format_string::FormatStringHandler;
 using clang::analyze_format_string::LengthModifier;
 using clang::analyze_format_string::OptionalAmount;
-using clang::analyze_format_string::ConversionSpecifier;
 using clang::analyze_printf::PrintfSpecifier;
 
 using namespace clang;
 
 typedef clang::analyze_format_string::SpecifierResult<PrintfSpecifier>
-        PrintfSpecifierResult;
+    PrintfSpecifierResult;
 
 //===----------------------------------------------------------------------===//
 // Methods for parsing format strings.
@@ -36,13 +36,13 @@
 using analyze_format_string::ParseNonPositionAmount;
 
 static bool ParsePrecision(FormatStringHandler &H, PrintfSpecifier &FS,
-                           const char *Start, const char *&Beg, const char *E,
+                           char const *Start, char const *&Beg, char const *E,
                            unsigned *argIndex) {
   if (argIndex) {
     FS.setPrecision(ParseNonPositionAmount(Beg, E, *argIndex));
   } else {
-    const OptionalAmount Amt = ParsePositionAmount(H, Start, Beg, E,
-                                           analyze_format_string::PrecisionPos);
+    const OptionalAmount Amt = ParsePositionAmount(
+        H, Start, Beg, E, analyze_format_string::PrecisionPos);
     if (Amt.isInvalid())
       return true;
     FS.setPrecision(Amt);
@@ -51,41 +51,38 @@
 }
 
 static bool ParseObjCFlags(FormatStringHandler &H, PrintfSpecifier &FS,
-                           const char *FlagBeg, const char *E, bool Warn) {
-   StringRef Flag(FlagBeg, E - FlagBeg);
-   // Currently there is only one flag.
-   if (Flag == "tt") {
-     FS.setHasObjCTechnicalTerm(FlagBeg);
-     return false;
-   }
-   // Handle either the case of no flag or an invalid flag.
-   if (Warn) {
-     if (Flag == "")
-       H.HandleEmptyObjCModifierFlag(FlagBeg, E  - FlagBeg);
-     else
-       H.HandleInvalidObjCModifierFlag(FlagBeg, E  - FlagBeg);
-   }
-   return true;
+                           char const *FlagBeg, char const *E, bool Warn) {
+  StringRef Flag(FlagBeg, E - FlagBeg);
+  // Currently there is only one flag.
+  if (Flag == "tt") {
+    FS.setHasObjCTechnicalTerm(FlagBeg);
+    return false;
+  }
+  // Handle either the case of no flag or an invalid flag.
+  if (Warn) {
+    if (Flag == "")
+      H.HandleEmptyObjCModifierFlag(FlagBeg, E - FlagBeg);
+    else
+      H.HandleInvalidObjCModifierFlag(FlagBeg, E - FlagBeg);
+  }
+  return true;
 }
 
-static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
-                                                  const char *&Beg,
-                                                  const char *E,
-                                                  unsigned &argIndex,
-                                                  const LangOptions &LO,
-                                                  const TargetInfo &Target,
-                                                  bool Warn,
-                                                  bool isFreeBSDKPrintf) {
+static PrintfSpecifierResult
+ParsePrintfSpecifier(FormatStringHandler &H, char const *&Beg, char const *E,
+                     unsigned &argIndex, LangOptions const &LO,
+                     TargetInfo const &Target, bool Warn,
+                     bool isFreeBSDKPrintf) {
 
   using namespace clang::analyze_format_string;
   using namespace clang::analyze_printf;
 
-  const char *I = Beg;
-  const char *Start = nullptr;
-  UpdateOnReturn <const char*> UpdateBeg(Beg, I);
+  char const *I = Beg;
+  char const *Start = nullptr;
+  UpdateOnReturn<char const *> UpdateBeg(Beg, I);
 
   // Look for a '%' character that indicates the start of a format specifier.
-  for ( ; I != E ; ++I) {
+  for (; I != E; ++I) {
     char c = *I;
     if (c == '\0') {
       // Detect spurious null characters, which are likely errors.
@@ -93,7 +90,7 @@
       return true;
     }
     if (c == '%') {
-      Start = I++;  // Record the start of the format specifier.
+      Start = I++; // Record the start of the format specifier.
       break;
     }
   }
@@ -149,7 +146,7 @@
         } else if (MatchedStr.equals("sensitive"))
           PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsSensitive;
         else if (PrivacyFlags !=
-                 clang::analyze_os_log::OSLogBufferItem::IsSensitive &&
+                     clang::analyze_os_log::OSLogBufferItem::IsSensitive &&
                  MatchedStr.equals("private"))
           PrivacyFlags = clang::analyze_os_log::OSLogBufferItem::IsPrivate;
         else if (PrivacyFlags == 0 && MatchedStr.equals("public"))
@@ -190,18 +187,30 @@
 
   // Look for flags (if any).
   bool hasMore = true;
-  for ( ; I != E; ++I) {
+  for (; I != E; ++I) {
     switch (*I) {
-      default: hasMore = false; break;
-      case '\'':
-        // FIXME: POSIX specific.  Always accept?
-        FS.setHasThousandsGrouping(I);
-        break;
-      case '-': FS.setIsLeftJustified(I); break;
-      case '+': FS.setHasPlusPrefix(I); break;
-      case ' ': FS.setHasSpacePrefix(I); break;
-      case '#': FS.setHasAlternativeForm(I); break;
-      case '0': FS.setHasLeadingZeros(I); break;
+    default:
+      hasMore = false;
+      break;
+    case '\'':
+      // FIXME: POSIX specific.  Always accept?
+      FS.setHasThousandsGrouping(I);
+      break;
+    case '-':
+      FS.setIsLeftJustified(I);
+      break;
+    case '+':
+      FS.setHasPlusPrefix(I);
+      break;
+    case ' ':
+      FS.setHasSpacePrefix(I);
+      break;
+    case '#':
+      FS.setHasAlternativeForm(I);
+      break;
+    case '0':
+      FS.setHasLeadingZeros(I);
+      break;
     }
     if (!hasMore)
       break;
@@ -264,8 +273,7 @@
   // later if the conversion specifier isn't '@'.  This
   // enables better recovery, and we don't know if
   // these flags are applicable until later.
-  const char *ObjCModifierFlagsStart = nullptr,
-             *ObjCModifierFlagsEnd = nullptr;
+  char const *ObjCModifierFlagsStart = nullptr, *ObjCModifierFlagsEnd = nullptr;
   if (*I == '[') {
     ObjCModifierFlagsStart = I;
     ++I;
@@ -297,89 +305,131 @@
   }
 
   // Finally, look for the conversion specifier.
-  const char *conversionPosition = I++;
+  char const *conversionPosition = I++;
   ConversionSpecifier::Kind k = ConversionSpecifier::InvalidSpecifier;
   switch (*conversionPosition) {
-    default:
-      break;
-    // C99: 7.19.6.1 (section 8).
-    case '%': k = ConversionSpecifier::PercentArg;   break;
-    case 'A': k = ConversionSpecifier::AArg; break;
-    case 'E': k = ConversionSpecifier::EArg; break;
-    case 'F': k = ConversionSpecifier::FArg; break;
-    case 'G': k = ConversionSpecifier::GArg; break;
-    case 'X': k = ConversionSpecifier::XArg; break;
-    case 'a': k = ConversionSpecifier::aArg; break;
-    case 'c': k = ConversionSpecifier::cArg; break;
-    case 'd': k = ConversionSpecifier::dArg; break;
-    case 'e': k = ConversionSpecifier::eArg; break;
-    case 'f': k = ConversionSpecifier::fArg; break;
-    case 'g': k = ConversionSpecifier::gArg; break;
-    case 'i': k = ConversionSpecifier::iArg; break;
-    case 'n':
-      // Not handled, but reserved in OpenCL.
-      if (!LO.OpenCL)
-        k = ConversionSpecifier::nArg;
-      break;
-    case 'o': k = ConversionSpecifier::oArg; break;
-    case 'p': k = ConversionSpecifier::pArg; break;
-    case 's': k = ConversionSpecifier::sArg; break;
-    case 'u': k = ConversionSpecifier::uArg; break;
-    case 'x': k = ConversionSpecifier::xArg; break;
-    // POSIX specific.
-    case 'C': k = ConversionSpecifier::CArg; break;
-    case 'S': k = ConversionSpecifier::SArg; break;
-    // Apple extension for os_log
-    case 'P':
-      k = ConversionSpecifier::PArg;
-      break;
-    // Objective-C.
-    case '@': k = ConversionSpecifier::ObjCObjArg; break;
-    // Glibc specific.
-    case 'm': k = ConversionSpecifier::PrintErrno; break;
-    // FreeBSD kernel specific.
-    case 'b':
-      if (isFreeBSDKPrintf)
-        k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
-      break;
-    case 'r':
-      if (isFreeBSDKPrintf)
-        k = ConversionSpecifier::FreeBSDrArg; // int
-      break;
-    case 'y':
-      if (isFreeBSDKPrintf)
-        k = ConversionSpecifier::FreeBSDyArg; // int
-      break;
-    // Apple-specific.
-    case 'D':
-      if (isFreeBSDKPrintf)
-        k = ConversionSpecifier::FreeBSDDArg; // void * followed by char *
-      else if (Target.getTriple().isOSDarwin())
-        k = ConversionSpecifier::DArg;
-      break;
-    case 'O':
-      if (Target.getTriple().isOSDarwin())
-        k = ConversionSpecifier::OArg;
-      break;
-    case 'U':
-      if (Target.getTriple().isOSDarwin())
-        k = ConversionSpecifier::UArg;
-      break;
-    // MS specific.
-    case 'Z':
-      if (Target.getTriple().isOSMSVCRT())
-        k = ConversionSpecifier::ZArg;
-      break;
+  default:
+    break;
+  // C99: 7.19.6.1 (section 8).
+  case '%':
+    k = ConversionSpecifier::PercentArg;
+    break;
+  case 'A':
+    k = ConversionSpecifier::AArg;
+    break;
+  case 'E':
+    k = ConversionSpecifier::EArg;
+    break;
+  case 'F':
+    k = ConversionSpecifier::FArg;
+    break;
+  case 'G':
+    k = ConversionSpecifier::GArg;
+    break;
+  case 'X':
+    k = ConversionSpecifier::XArg;
+    break;
+  case 'a':
+    k = ConversionSpecifier::aArg;
+    break;
+  case 'c':
+    k = ConversionSpecifier::cArg;
+    break;
+  case 'd':
+    k = ConversionSpecifier::dArg;
+    break;
+  case 'e':
+    k = ConversionSpecifier::eArg;
+    break;
+  case 'f':
+    k = ConversionSpecifier::fArg;
+    break;
+  case 'g':
+    k = ConversionSpecifier::gArg;
+    break;
+  case 'i':
+    k = ConversionSpecifier::iArg;
+    break;
+  case 'n':
+    // Not handled, but reserved in OpenCL.
+    if (!LO.OpenCL)
+      k = ConversionSpecifier::nArg;
+    break;
+  case 'o':
+    k = ConversionSpecifier::oArg;
+    break;
+  case 'p':
+    k = ConversionSpecifier::pArg;
+    break;
+  case 's':
+    k = ConversionSpecifier::sArg;
+    break;
+  case 'u':
+    k = ConversionSpecifier::uArg;
+    break;
+  case 'x':
+    k = ConversionSpecifier::xArg;
+    break;
+  // POSIX specific.
+  case 'C':
+    k = ConversionSpecifier::CArg;
+    break;
+  case 'S':
+    k = ConversionSpecifier::SArg;
+    break;
+  // Apple extension for os_log
+  case 'P':
+    k = ConversionSpecifier::PArg;
+    break;
+  // Objective-C.
+  case '@':
+    k = ConversionSpecifier::ObjCObjArg;
+    break;
+  // Glibc specific.
+  case 'm':
+    k = ConversionSpecifier::PrintErrno;
+    break;
+  // FreeBSD kernel specific.
+  case 'b':
+    if (isFreeBSDKPrintf)
+      k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
+    break;
+  case 'r':
+    if (isFreeBSDKPrintf)
+      k = ConversionSpecifier::FreeBSDrArg; // int
+    break;
+  case 'y':
+    if (isFreeBSDKPrintf)
+      k = ConversionSpecifier::FreeBSDyArg; // int
+    break;
+  // Apple-specific.
+  case 'D':
+    if (isFreeBSDKPrintf)
+      k = ConversionSpecifier::FreeBSDDArg; // void * followed by char *
+    else if (Target.getTriple().isOSDarwin())
+      k = ConversionSpecifier::DArg;
+    break;
+  case 'O':
+    if (Target.getTriple().isOSDarwin())
+      k = ConversionSpecifier::OArg;
+    break;
+  case 'U':
+    if (Target.getTriple().isOSDarwin())
+      k = ConversionSpecifier::UArg;
+    break;
+  // MS specific.
+  case 'Z':
+    if (Target.getTriple().isOSMSVCRT())
+      k = ConversionSpecifier::ZArg;
+    break;
   }
 
   // Check to see if we used the Objective-C modifier flags with
   // a conversion specifier other than '@'.
   if (k != ConversionSpecifier::ObjCObjArg &&
-      k != ConversionSpecifier::InvalidSpecifier &&
-      ObjCModifierFlagsStart) {
-    H.HandleObjCFlagsWithNonObjCConversion(ObjCModifierFlagsStart,
-                                           ObjCModifierFlagsEnd + 1,
-                                           conversionPosition);
+      k != ConversionSpecifier::InvalidSpecifier && ObjCModifierFlagsStart) {
+    H.HandleObjCFlagsWithNonObjCConversion(
+        ObjCModifierFlagsStart, ObjCModifierFlagsEnd + 1, conversionPosition);
     return true;
   }
 
@@ -404,20 +454,16 @@
   return PrintfSpecifierResult(Start, FS);
 }
 
-bool clang::analyze_format_string::ParsePrintfString(FormatStringHandler &H,
-                                                     const char *I,
-                                                     const char *E,
-                                                     const LangOptions &LO,
-                                                     const TargetInfo &Target,
-                                                     bool isFreeBSDKPrintf) {
+bool clang::analyze_format_string::ParsePrintfString(
+    FormatStringHandler &H, char const *I, char const *E, LangOptions const &LO,
+    TargetInfo const &Target, bool isFreeBSDKPrintf) {
 
   unsigned argIndex = 0;
 
   // Keep looking for a format specifier until we have exhausted the string.
   while (I != E) {
-    const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex,
-                                                            LO, Target, true,
-                                                            isFreeBSDKPrintf);
+    PrintfSpecifierResult const &FSR = ParsePrintfSpecifier(
+        H, I, E, argIndex, LO, Target, true, isFreeBSDKPrintf);
     // Did a fail-stop error of any kind occur when parsing the specifier?
     // If so, don't do any more processing.
     if (FSR.shouldStop())
@@ -435,19 +481,17 @@
   return false;
 }
 
-bool clang::analyze_format_string::ParseFormatStringHasSArg(const char *I,
-                                                            const char *E,
-                                                            const LangOptions &LO,
-                                                            const TargetInfo &Target) {
+bool clang::analyze_format_string::ParseFormatStringHasSArg(
+    char const *I, char const *E, LangOptions const &LO,
+    TargetInfo const &Target) {
 
   unsigned argIndex = 0;
 
   // Keep looking for a %s format specifier until we have exhausted the string.
   FormatStringHandler H;
   while (I != E) {
-    const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex,
-                                                            LO, Target, false,
-                                                            false);
+    PrintfSpecifierResult const &FSR =
+        ParsePrintfSpecifier(H, I, E, argIndex, LO, Target, false, false);
     // Did a fail-stop error of any kind occur when parsing the specifier?
     // If so, don't do any more processing.
     if (FSR.shouldStop())
@@ -456,22 +500,23 @@
     // we can recover from?
     if (!FSR.hasValue())
       continue;
-    const analyze_printf::PrintfSpecifier &FS = FSR.getValue();
+    analyze_printf::PrintfSpecifier const &FS = FSR.getValue();
     // Return true if this a %s format specifier.
-    if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::Kind::sArg)
+    if (FS.getConversionSpecifier().getKind() ==
+        ConversionSpecifier::Kind::sArg)
       return true;
   }
   return false;
 }
 
 bool clang::analyze_format_string::parseFormatStringHasFormattingSpecifiers(
-    const char *Begin, const char *End, const LangOptions &LO,
-    const TargetInfo &Target) {
+    char const *Begin, char const *End, LangOptions const &LO,
+    TargetInfo const &Target) {
   unsigned ArgIndex = 0;
   // Keep looking for a formatting specifier until we have exhausted the string.
   FormatStringHandler H;
   while (Begin != End) {
-    const PrintfSpecifierResult &FSR =
+    PrintfSpecifierResult const &FSR =
         ParsePrintfSpecifier(H, Begin, End, ArgIndex, LO, Target, false, false);
     if (FSR.shouldStop())
       break;
@@ -489,88 +534,93 @@
                                           bool IsObjCLiteral) const {
   if (CS.getKind() == ConversionSpecifier::cArg)
     switch (LM.getKind()) {
-      case LengthModifier::None:
+    case LengthModifier::None:
+      return Ctx.IntTy;
+    case LengthModifier::AsLong:
+    case LengthModifier::AsWide:
+      return ArgType(ArgType::WIntTy, "wint_t");
+    case LengthModifier::AsShort:
+      if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
         return Ctx.IntTy;
-      case LengthModifier::AsLong:
-      case LengthModifier::AsWide:
-        return ArgType(ArgType::WIntTy, "wint_t");
-      case LengthModifier::AsShort:
-        if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
-          return Ctx.IntTy;
-        LLVM_FALLTHROUGH;
-      default:
-        return ArgType::Invalid();
+      LLVM_FALLTHROUGH;
+    default:
+      return ArgType::Invalid();
     }
 
   if (CS.isIntArg())
     switch (LM.getKind()) {
-      case LengthModifier::AsLongDouble:
-        // GNU extension.
-        return Ctx.LongLongTy;
-      case LengthModifier::None:
-      case LengthModifier::AsShortLong:
-        return Ctx.IntTy;
-      case LengthModifier::AsInt32:
-        return ArgType(Ctx.IntTy, "__int32");
-      case LengthModifier::AsChar:
-        return ArgType::AnyCharTy;
-      case LengthModifier::AsShort: return Ctx.ShortTy;
-      case LengthModifier::AsLong: return Ctx.LongTy;
-      case LengthModifier::AsLongLong:
-      case LengthModifier::AsQuad:
-        return Ctx.LongLongTy;
-      case LengthModifier::AsInt64:
-        return ArgType(Ctx.LongLongTy, "__int64");
-      case LengthModifier::AsIntMax:
-        return ArgType(Ctx.getIntMaxType(), "intmax_t");
-      case LengthModifier::AsSizeT:
-        return ArgType::makeSizeT(ArgType(Ctx.getSignedSizeType(), "ssize_t"));
-      case LengthModifier::AsInt3264:
-        return Ctx.getTargetInfo().getTriple().isArch64Bit()
-                   ? ArgType(Ctx.LongLongTy, "__int64")
-                   : ArgType(Ctx.IntTy, "__int32");
-      case LengthModifier::AsPtrDiff:
-        return ArgType::makePtrdiffT(
-            ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
-      case LengthModifier::AsAllocate:
-      case LengthModifier::AsMAllocate:
-      case LengthModifier::AsWide:
-        return ArgType::Invalid();
+    case LengthModifier::AsLongDouble:
+      // GNU extension.
+      return Ctx.LongLongTy;
+    case LengthModifier::None:
+    case LengthModifier::AsShortLong:
+      return Ctx.IntTy;
+    case LengthModifier::AsInt32:
+      return ArgType(Ctx.IntTy, "__int32");
+    case LengthModifier::AsChar:
+      return ArgType::AnyCharTy;
+    case LengthModifier::AsShort:
+      return Ctx.ShortTy;
+    case LengthModifier::AsLong:
+      return Ctx.LongTy;
+    case LengthModifier::AsLongLong:
+    case LengthModifier::AsQuad:
+      return Ctx.LongLongTy;
+    case LengthModifier::AsInt64:
+      return ArgType(Ctx.LongLongTy, "__int64");
+    case LengthModifier::AsIntMax:
+      return ArgType(Ctx.getIntMaxType(), "intmax_t");
+    case LengthModifier::AsSizeT:
+      return ArgType::makeSizeT(ArgType(Ctx.getSignedSizeType(), "ssize_t"));
+    case LengthModifier::AsInt3264:
+      return Ctx.getTargetInfo().getTriple().isArch64Bit()
+                 ? ArgType(Ctx.LongLongTy, "__int64")
+                 : ArgType(Ctx.IntTy, "__int32");
+    case LengthModifier::AsPtrDiff:
+      return ArgType::makePtrdiffT(
+          ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
+    case LengthModifier::AsAllocate:
+    case LengthModifier::AsMAllocate:
+    case LengthModifier::AsWide:
+      return ArgType::Invalid();
     }
 
   if (CS.isUIntArg())
     switch (LM.getKind()) {
-      case LengthModifier::AsLongDouble:
-        // GNU extension.
-        return Ctx.UnsignedLongLongTy;
-      case LengthModifier::None:
-      case LengthModifier::AsShortLong:
-        return Ctx.UnsignedIntTy;
-      case LengthModifier::AsInt32:
-        return ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
-      case LengthModifier::AsChar: return Ctx.UnsignedCharTy;
-      case LengthModifier::AsShort: return Ctx.UnsignedShortTy;
-      case LengthModifier::AsLong: return Ctx.UnsignedLongTy;
-      case LengthModifier::AsLongLong:
-      case LengthModifier::AsQuad:
-        return Ctx.UnsignedLongLongTy;
-      case LengthModifier::AsInt64:
-        return ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64");
-      case LengthModifier::AsIntMax:
-        return ArgType(Ctx.getUIntMaxType(), "uintmax_t");
-      case LengthModifier::AsSizeT:
-        return ArgType::makeSizeT(ArgType(Ctx.getSizeType(), "size_t"));
-      case LengthModifier::AsInt3264:
-        return Ctx.getTargetInfo().getTriple().isArch64Bit()
-                   ? ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64")
-                   : ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
-      case LengthModifier::AsPtrDiff:
-        return ArgType::makePtrdiffT(
-            ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptrdiff_t"));
-      case LengthModifier::AsAllocate:
-      case LengthModifier::AsMAllocate:
-      case LengthModifier::AsWide:
-        return ArgType::Invalid();
+    case LengthModifier::AsLongDouble:
+      // GNU extension.
+      return Ctx.UnsignedLongLongTy;
+    case LengthModifier::None:
+    case LengthModifier::AsShortLong:
+      return Ctx.UnsignedIntTy;
+    case LengthModifier::AsInt32:
+      return ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
+    case LengthModifier::AsChar:
+      return Ctx.UnsignedCharTy;
+    case LengthModifier::AsShort:
+      return Ctx.UnsignedShortTy;
+    case LengthModifier::AsLong:
+      return Ctx.UnsignedLongTy;
+    case LengthModifier::AsLongLong:
+    case LengthModifier::AsQuad:
+      return Ctx.UnsignedLongLongTy;
+    case LengthModifier::AsInt64:
+      return ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64");
+    case LengthModifier::AsIntMax:
+      return ArgType(Ctx.getUIntMaxType(), "uintmax_t");
+    case LengthModifier::AsSizeT:
+      return ArgType::makeSizeT(ArgType(Ctx.getSizeType(), "size_t"));
+    case LengthModifier::AsInt3264:
+      return Ctx.getTargetInfo().getTriple().isArch64Bit()
+                 ? ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64")
+                 : ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
+    case LengthModifier::AsPtrDiff:
+      return ArgType::makePtrdiffT(
+          ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptrdiff_t"));
+    case LengthModifier::AsAllocate:
+    case LengthModifier::AsMAllocate:
+    case LengthModifier::AsWide:
+      return ArgType::Invalid();
     }
 
   if (CS.isDoubleArg()) {
@@ -593,80 +643,78 @@
 
   if (CS.getKind() == ConversionSpecifier::nArg) {
     switch (LM.getKind()) {
-      case LengthModifier::None:
-        return ArgType::PtrTo(Ctx.IntTy);
-      case LengthModifier::AsChar:
-        return ArgType::PtrTo(Ctx.SignedCharTy);
-      case LengthModifier::AsShort:
-        return ArgType::PtrTo(Ctx.ShortTy);
-      case LengthModifier::AsLong:
-        return ArgType::PtrTo(Ctx.LongTy);
-      case LengthModifier::AsLongLong:
-      case LengthModifier::AsQuad:
-        return ArgType::PtrTo(Ctx.LongLongTy);
-      case LengthModifier::AsIntMax:
-        return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
-      case LengthModifier::AsSizeT:
-        return ArgType::PtrTo(ArgType(Ctx.getSignedSizeType(), "ssize_t"));
-      case LengthModifier::AsPtrDiff:
-        return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
-      case LengthModifier::AsLongDouble:
-        return ArgType(); // FIXME: Is this a known extension?
-      case LengthModifier::AsAllocate:
-      case LengthModifier::AsMAllocate:
-      case LengthModifier::AsInt32:
-      case LengthModifier::AsInt3264:
-      case LengthModifier::AsInt64:
-      case LengthModifier::AsWide:
-        return ArgType::Invalid();
-      case LengthModifier::AsShortLong:
-        llvm_unreachable("only used for OpenCL which doesn not handle nArg");
+    case LengthModifier::None:
+      return ArgType::PtrTo(Ctx.IntTy);
+    case LengthModifier::AsChar:
+      return ArgType::PtrTo(Ctx.SignedCharTy);
+    case LengthModifier::AsShort:
+      return ArgType::PtrTo(Ctx.ShortTy);
+    case LengthModifier::AsLong:
+      return ArgType::PtrTo(Ctx.LongTy);
+    case LengthModifier::AsLongLong:
+    case LengthModifier::AsQuad:
+      return ArgType::PtrTo(Ctx.LongLongTy);
+    case LengthModifier::AsIntMax:
+      return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
+    case LengthModifier::AsSizeT:
+      return ArgType::PtrTo(ArgType(Ctx.getSignedSizeType(), "ssize_t"));
+    case LengthModifier::AsPtrDiff:
+      return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
+    case LengthModifier::AsLongDouble:
+      return ArgType(); // FIXME: Is this a known extension?
+    case LengthModifier::AsAllocate:
+    case LengthModifier::AsMAllocate:
+    case LengthModifier::AsInt32:
+    case LengthModifier::AsInt3264:
+    case LengthModifier::AsInt64:
+    case LengthModifier::AsWide:
+      return ArgType::Invalid();
+    case LengthModifier::AsShortLong:
+      llvm_unreachable("only used for OpenCL which doesn not handle nArg");
     }
   }
 
   switch (CS.getKind()) {
-    case ConversionSpecifier::sArg:
-      if (LM.getKind() == LengthModifier::AsWideChar) {
-        if (IsObjCLiteral)
-          return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
-                         "const unichar *");
-        return ArgType(ArgType::WCStrTy, "wchar_t *");
-      }
-      if (LM.getKind() == LengthModifier::AsWide)
-        return ArgType(ArgType::WCStrTy, "wchar_t *");
-      return ArgType::CStrTy;
-    case ConversionSpecifier::SArg:
+  case ConversionSpecifier::sArg:
+    if (LM.getKind() == LengthModifier::AsWideChar) {
       if (IsObjCLiteral)
         return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
                        "const unichar *");
-      if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
-          LM.getKind() == LengthModifier::AsShort)
-        return ArgType::CStrTy;
       return ArgType(ArgType::WCStrTy, "wchar_t *");
-    case ConversionSpecifier::CArg:
-      if (IsObjCLiteral)
-        return ArgType(Ctx.UnsignedShortTy, "unichar");
-      if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
-          LM.getKind() == LengthModifier::AsShort)
-        return Ctx.IntTy;
-      return ArgType(Ctx.WideCharTy, "wchar_t");
-    case ConversionSpecifier::pArg:
-    case ConversionSpecifier::PArg:
-      return ArgType::CPointerTy;
-    case ConversionSpecifier::ObjCObjArg:
-      return ArgType::ObjCPointerTy;
-    default:
-      break;
+    }
+    if (LM.getKind() == LengthModifier::AsWide)
+      return ArgType(ArgType::WCStrTy, "wchar_t *");
+    return ArgType::CStrTy;
+  case ConversionSpecifier::SArg:
+    if (IsObjCLiteral)
+      return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
+                     "const unichar *");
+    if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
+        LM.getKind() == LengthModifier::AsShort)
+      return ArgType::CStrTy;
+    return ArgType(ArgType::WCStrTy, "wchar_t *");
+  case ConversionSpecifier::CArg:
+    if (IsObjCLiteral)
+      return ArgType(Ctx.UnsignedShortTy, "unichar");
+    if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
+        LM.getKind() == LengthModifier::AsShort)
+      return Ctx.IntTy;
+    return ArgType(Ctx.WideCharTy, "wchar_t");
+  case ConversionSpecifier::pArg:
+  case ConversionSpecifier::PArg:
+    return ArgType::CPointerTy;
+  case ConversionSpecifier::ObjCObjArg:
+    return ArgType::ObjCPointerTy;
+  default:
+    break;
   }
 
   // FIXME: Handle other cases.
   return ArgType();
 }
 
-
-ArgType PrintfSpecifier::getArgType(ASTContext &Ctx,
-                                    bool IsObjCLiteral) const {
-  const PrintfConversionSpecifier &CS = getConversionSpecifier();
+ArgType PrintfSpecifier::getArgType(ASTContext &Ctx, bool IsObjCLiteral) const {
+  PrintfConversionSpecifier const &CS = getConversionSpecifier();
 
   if (!CS.consumesDataArgument())
     return ArgType::Invalid();
@@ -678,7 +726,7 @@
   return ScalarTy.makeVectorType(Ctx, VectorNumElts.getConstantAmount());
 }
 
-bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt,
+bool PrintfSpecifier::fixType(QualType QT, LangOptions const &LangOpt,
                               ASTContext &Ctx, bool IsObjCLiteral) {
   // %n is different from other conversion specifiers; don't try to fix it.
   if (CS.getKind() == ConversionSpecifier::nArg)
@@ -724,12 +772,12 @@
   }
 
   // If it's an enum, get its underlying type.
-  if (const EnumType *ETy = QT->getAs<EnumType>())
+  if (EnumType const *ETy = QT->getAs<EnumType>())
     QT = ETy->getDecl()->getIntegerType();
 
-  const BuiltinType *BT = QT->getAs<BuiltinType>();
+  BuiltinType const *BT = QT->getAs<BuiltinType>();
   if (!BT) {
-    const VectorType *VT = QT->getAs<VectorType>();
+    VectorType const *VT = QT->getAs<VectorType>();
     if (VT) {
       QT = VT->getElementType();
       BT = QT->getAs<BuiltinType>();
@@ -783,25 +831,21 @@
     // Various types which are non-trivial to correct.
     return false;
 
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
   case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-  case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
 #include "clang/Basic/OpenCLExtensionTypes.def"
-#define SVE_TYPE(Name, Id, SingletonId) \
-  case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-  case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
 #define SIGNED_TYPE(Id, SingletonId)
 #define UNSIGNED_TYPE(Id, SingletonId)
 #define FLOATING_TYPE(Id, SingletonId)
-#define BUILTIN_TYPE(Id, SingletonId) \
-  case BuiltinType::Id:
+#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
     // Misc other stuff which doesn't make sense here.
     return false;
@@ -809,12 +853,12 @@
   case BuiltinType::UInt:
   case BuiltinType::Int:
   case BuiltinType::Float:
-    LM.setKind(VectorNumElts.isInvalid() ?
-               LengthModifier::None : LengthModifier::AsShortLong);
+    LM.setKind(VectorNumElts.isInvalid() ? LengthModifier::None
+                                         : LengthModifier::AsShortLong);
     break;
   case BuiltinType::Double:
-    LM.setKind(VectorNumElts.isInvalid() ?
-               LengthModifier::None : LengthModifier::AsLong);
+    LM.setKind(VectorNumElts.isInvalid() ? LengthModifier::None
+                                         : LengthModifier::AsLong);
     break;
   case BuiltinType::Char_U:
   case BuiltinType::UChar:
@@ -867,7 +911,7 @@
       break;
     }
 
-    const analyze_printf::ArgType &ATR = getArgType(Ctx, IsObjCLiteral);
+    analyze_printf::ArgType const &ATR = getArgType(Ctx, IsObjCLiteral);
     if (ATR.isValid() && ATR.matchesType(Ctx, QT))
       return true;
   }
@@ -885,12 +929,10 @@
   // Test for Floating type first as LongDouble can pass isUnsignedIntegerType
   else if (QT->isRealFloatingType()) {
     CS.setKind(ConversionSpecifier::fArg);
-  }
-  else if (QT->isSignedIntegerType()) {
+  } else if (QT->isSignedIntegerType()) {
     CS.setKind(ConversionSpecifier::dArg);
     HasAlternativeForm = 0;
-  }
-  else if (QT->isUnsignedIntegerType()) {
+  } else if (QT->isUnsignedIntegerType()) {
     CS.setKind(ConversionSpecifier::uArg);
     HasAlternativeForm = 0;
     HasPlusPrefix = 0;
@@ -912,11 +954,16 @@
   }
 
   // Conversion flags
-  if (IsLeftJustified)    os << "-";
-  if (HasPlusPrefix)      os << "+";
-  if (HasSpacePrefix)     os << " ";
-  if (HasAlternativeForm) os << "#";
-  if (HasLeadingZeroes)   os << "0";
+  if (IsLeftJustified)
+    os << "-";
+  if (HasPlusPrefix)
+    os << "+";
+  if (HasSpacePrefix)
+    os << " ";
+  if (HasAlternativeForm)
+    os << "#";
+  if (HasLeadingZeroes)
+    os << "0";
 
   // Minimum field width
   FieldWidth.toString(os);
@@ -1063,18 +1110,18 @@
     return true;
 
   switch (CS.getKind()) {
-    case ConversionSpecifier::dArg:
-    case ConversionSpecifier::DArg:
-    case ConversionSpecifier::iArg:
-    case ConversionSpecifier::uArg:
-    case ConversionSpecifier::UArg:
-    case ConversionSpecifier::fArg:
-    case ConversionSpecifier::FArg:
-    case ConversionSpecifier::gArg:
-    case ConversionSpecifier::GArg:
-      return true;
-    default:
-      return false;
+  case ConversionSpecifier::dArg:
+  case ConversionSpecifier::DArg:
+  case ConversionSpecifier::iArg:
+  case ConversionSpecifier::uArg:
+  case ConversionSpecifier::UArg:
+  case ConversionSpecifier::fArg:
+  case ConversionSpecifier::FArg:
+  case ConversionSpecifier::gArg:
+  case ConversionSpecifier::GArg:
+    return true;
+  default:
+    return false;
   }
 }
 
@@ -1113,7 +1160,7 @@
 }
 bool PrintfSpecifier::hasValidFieldWidth() const {
   if (FieldWidth.getHowSpecified() == OptionalAmount::NotSpecified)
-      return true;
+    return true;
 
   // The field width is valid for all conversions except n
   switch (CS.getKind()) {
Index: clang/lib/AST/QualTypeNames.cpp
===================================================================
--- clang/lib/AST/QualTypeNames.cpp
+++ clang/lib/AST/QualTypeNames.cpp
@@ -6,14 +6,14 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/AST/QualTypeNames.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/GlobalDecl.h"
 #include "clang/AST/Mangle.h"
-#include "clang/AST/QualTypeNames.h"
 
-#include <stdio.h>
 #include <memory>
+#include <stdio.h>
 
 namespace clang {
 
@@ -27,10 +27,9 @@
 /// is requested.
 /// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace
 /// specifier "::" should be prepended or not.
-static NestedNameSpecifier *createNestedNameSpecifier(
-    const ASTContext &Ctx,
-    const NamespaceDecl *Namesp,
-    bool WithGlobalNsPrefix);
+static NestedNameSpecifier *
+createNestedNameSpecifier(ASTContext const &Ctx, NamespaceDecl const *Namesp,
+                          bool WithGlobalNsPrefix);
 
 /// Create a NestedNameSpecifier for TagDecl and its enclosing
 /// scopes.
@@ -42,18 +41,20 @@
 /// qualified names.
 /// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace
 /// specifier "::" should be prepended or not.
-static NestedNameSpecifier *createNestedNameSpecifier(
-    const ASTContext &Ctx, const TypeDecl *TD,
-    bool FullyQualify, bool WithGlobalNsPrefix);
+static NestedNameSpecifier *createNestedNameSpecifier(ASTContext const &Ctx,
+                                                      TypeDecl const *TD,
+                                                      bool FullyQualify,
+                                                      bool WithGlobalNsPrefix);
 
-static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
-    const ASTContext &Ctx, const Decl *decl,
-    bool FullyQualified, bool WithGlobalNsPrefix);
+static NestedNameSpecifier *
+createNestedNameSpecifierForScopeOf(ASTContext const &Ctx, Decl const *decl,
+                                    bool FullyQualified,
+                                    bool WithGlobalNsPrefix);
 
 static NestedNameSpecifier *getFullyQualifiedNestedNameSpecifier(
-    const ASTContext &Ctx, NestedNameSpecifier *scope, bool WithGlobalNsPrefix);
+    ASTContext const &Ctx, NestedNameSpecifier *scope, bool WithGlobalNsPrefix);
 
-static bool getFullyQualifiedTemplateName(const ASTContext &Ctx,
+static bool getFullyQualifiedTemplateName(ASTContext const &Ctx,
                                           TemplateName &TName,
                                           bool WithGlobalNsPrefix) {
   bool Changed = false;
@@ -67,8 +68,8 @@
 
   if (QTName && !QTName->hasTemplateKeyword()) {
     NNS = QTName->getQualifier();
-    NestedNameSpecifier *QNNS = getFullyQualifiedNestedNameSpecifier(
-        Ctx, NNS, WithGlobalNsPrefix);
+    NestedNameSpecifier *QNNS =
+        getFullyQualifiedNestedNameSpecifier(Ctx, NNS, WithGlobalNsPrefix);
     if (QNNS != NNS) {
       Changed = true;
       NNS = QNNS;
@@ -76,8 +77,8 @@
       NNS = nullptr;
     }
   } else {
-    NNS = createNestedNameSpecifierForScopeOf(
-        Ctx, ArgTDecl, true, WithGlobalNsPrefix);
+    NNS = createNestedNameSpecifierForScopeOf(Ctx, ArgTDecl, true,
+                                              WithGlobalNsPrefix);
   }
   if (NNS) {
     TName = Ctx.getQualifiedTemplateName(NNS,
@@ -87,7 +88,7 @@
   return Changed;
 }
 
-static bool getFullyQualifiedTemplateArgument(const ASTContext &Ctx,
+static bool getFullyQualifiedTemplateArgument(ASTContext const &Ctx,
                                               TemplateArgument &Arg,
                                               bool WithGlobalNsPrefix) {
   bool Changed = false;
@@ -113,8 +114,8 @@
   return Changed;
 }
 
-static const Type *getFullyQualifiedTemplateType(const ASTContext &Ctx,
-                                                 const Type *TypePtr,
+static Type const *getFullyQualifiedTemplateType(ASTContext const &Ctx,
+                                                 Type const *TypePtr,
                                                  bool WithGlobalNsPrefix) {
   // DependentTemplateTypes exist within template declarations and
   // definitions. Therefore we shouldn't encounter them at the end of
@@ -122,7 +123,7 @@
   assert(!isa<DependentTemplateSpecializationType>(TypePtr));
   // In case of template specializations, iterate over the arguments
   // and fully qualify them as well.
-  if (const auto *TST = dyn_cast<const TemplateSpecializationType>(TypePtr)) {
+  if (auto const *TST = dyn_cast<const TemplateSpecializationType>(TypePtr)) {
     bool MightHaveChanged = false;
     SmallVector<TemplateArgument, 4> FQArgs;
     for (TemplateSpecializationType::iterator I = TST->begin(), E = TST->end();
@@ -130,8 +131,8 @@
       // Cheap to copy and potentially modified by
       // getFullyQualifedTemplateArgument.
       TemplateArgument Arg(*I);
-      MightHaveChanged |= getFullyQualifiedTemplateArgument(
-          Ctx, Arg, WithGlobalNsPrefix);
+      MightHaveChanged |=
+          getFullyQualifiedTemplateArgument(Ctx, Arg, WithGlobalNsPrefix);
       FQArgs.push_back(Arg);
     }
 
@@ -139,21 +140,20 @@
     // allocate new type in the AST.
     if (MightHaveChanged) {
       QualType QT = Ctx.getTemplateSpecializationType(
-          TST->getTemplateName(), FQArgs,
-          TST->getCanonicalTypeInternal());
+          TST->getTemplateName(), FQArgs, TST->getCanonicalTypeInternal());
       // getTemplateSpecializationType returns a fully qualified
       // version of the specialization itself, so no need to qualify
       // it.
       return QT.getTypePtr();
     }
-  } else if (const auto *TSTRecord = dyn_cast<const RecordType>(TypePtr)) {
+  } else if (auto const *TSTRecord = dyn_cast<const RecordType>(TypePtr)) {
     // We are asked to fully qualify and we have a Record Type,
     // which can point to a template instantiation with no sugar in any of
     // its template argument, however we still need to fully qualify them.
 
-    if (const auto *TSTDecl =
-        dyn_cast<ClassTemplateSpecializationDecl>(TSTRecord->getDecl())) {
-      const TemplateArgumentList &TemplateArgs = TSTDecl->getTemplateArgs();
+    if (auto const *TSTDecl =
+            dyn_cast<ClassTemplateSpecializationDecl>(TSTRecord->getDecl())) {
+      TemplateArgumentList const &TemplateArgs = TSTDecl->getTemplateArgs();
 
       bool MightHaveChanged = false;
       SmallVector<TemplateArgument, 4> FQArgs;
@@ -161,8 +161,8 @@
         // cheap to copy and potentially modified by
         // getFullyQualifedTemplateArgument
         TemplateArgument Arg(TemplateArgs[I]);
-        MightHaveChanged |= getFullyQualifiedTemplateArgument(
-            Ctx, Arg, WithGlobalNsPrefix);
+        MightHaveChanged |=
+            getFullyQualifiedTemplateArgument(Ctx, Arg, WithGlobalNsPrefix);
         FQArgs.push_back(Arg);
       }
 
@@ -171,8 +171,7 @@
       if (MightHaveChanged) {
         TemplateName TN(TSTDecl->getSpecializedTemplate());
         QualType QT = Ctx.getTemplateSpecializationType(
-            TN, FQArgs,
-            TSTRecord->getCanonicalTypeInternal());
+            TN, FQArgs, TSTRecord->getCanonicalTypeInternal());
         // getTemplateSpecializationType returns a fully qualified
         // version of the specialization itself, so no need to qualify
         // it.
@@ -183,11 +182,11 @@
   return TypePtr;
 }
 
-static NestedNameSpecifier *createOuterNNS(const ASTContext &Ctx, const Decl *D,
+static NestedNameSpecifier *createOuterNNS(ASTContext const &Ctx, Decl const *D,
                                            bool FullyQualify,
                                            bool WithGlobalNsPrefix) {
-  const DeclContext *DC = D->getDeclContext();
-  if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
+  DeclContext const *DC = D->getDeclContext();
+  if (auto const *NS = dyn_cast<NamespaceDecl>(DC)) {
     while (NS && NS->isInline()) {
       // Ignore inline namespace;
       NS = dyn_cast<NamespaceDecl>(NS->getDeclContext());
@@ -195,82 +194,81 @@
     if (NS && NS->getDeclName()) {
       return createNestedNameSpecifier(Ctx, NS, WithGlobalNsPrefix);
     }
-    return nullptr;  // no starting '::', no anonymous
-  } else if (const auto *TD = dyn_cast<TagDecl>(DC)) {
+    return nullptr; // no starting '::', no anonymous
+  } else if (auto const *TD = dyn_cast<TagDecl>(DC)) {
     return createNestedNameSpecifier(Ctx, TD, FullyQualify, WithGlobalNsPrefix);
-  } else if (const auto *TDD = dyn_cast<TypedefNameDecl>(DC)) {
-    return createNestedNameSpecifier(
-        Ctx, TDD, FullyQualify, WithGlobalNsPrefix);
+  } else if (auto const *TDD = dyn_cast<TypedefNameDecl>(DC)) {
+    return createNestedNameSpecifier(Ctx, TDD, FullyQualify,
+                                     WithGlobalNsPrefix);
   } else if (WithGlobalNsPrefix && DC->isTranslationUnit()) {
     return NestedNameSpecifier::GlobalSpecifier(Ctx);
   }
-  return nullptr;  // no starting '::' if |WithGlobalNsPrefix| is false
+  return nullptr; // no starting '::' if |WithGlobalNsPrefix| is false
 }
 
 /// Return a fully qualified version of this name specifier.
-static NestedNameSpecifier *getFullyQualifiedNestedNameSpecifier(
-    const ASTContext &Ctx, NestedNameSpecifier *Scope,
-    bool WithGlobalNsPrefix) {
+static NestedNameSpecifier *
+getFullyQualifiedNestedNameSpecifier(ASTContext const &Ctx,
+                                     NestedNameSpecifier *Scope,
+                                     bool WithGlobalNsPrefix) {
   switch (Scope->getKind()) {
-    case NestedNameSpecifier::Global:
-      // Already fully qualified
-      return Scope;
-    case NestedNameSpecifier::Namespace:
+  case NestedNameSpecifier::Global:
+    // Already fully qualified
+    return Scope;
+  case NestedNameSpecifier::Namespace:
+    return TypeName::createNestedNameSpecifier(Ctx, Scope->getAsNamespace(),
+                                               WithGlobalNsPrefix);
+  case NestedNameSpecifier::NamespaceAlias:
+    // Namespace aliases are only valid for the duration of the
+    // scope where they were introduced, and therefore are often
+    // invalid at the end of the TU.  So use the namespace name more
+    // likely to be valid at the end of the TU.
+    return TypeName::createNestedNameSpecifier(
+        Ctx, Scope->getAsNamespaceAlias()->getNamespace()->getCanonicalDecl(),
+        WithGlobalNsPrefix);
+  case NestedNameSpecifier::Identifier:
+    // A function or some other construct that makes it un-namable
+    // at the end of the TU. Skip the current component of the name,
+    // but use the name of it's prefix.
+    return getFullyQualifiedNestedNameSpecifier(Ctx, Scope->getPrefix(),
+                                                WithGlobalNsPrefix);
+  case NestedNameSpecifier::Super:
+  case NestedNameSpecifier::TypeSpec:
+  case NestedNameSpecifier::TypeSpecWithTemplate: {
+    Type const *Type = Scope->getAsType();
+    // Find decl context.
+    TagDecl const *TD = nullptr;
+    if (TagType const *TagDeclType = Type->getAs<TagType>()) {
+      TD = TagDeclType->getDecl();
+    } else {
+      TD = Type->getAsCXXRecordDecl();
+    }
+    if (TD) {
       return TypeName::createNestedNameSpecifier(
-          Ctx, Scope->getAsNamespace(), WithGlobalNsPrefix);
-    case NestedNameSpecifier::NamespaceAlias:
-      // Namespace aliases are only valid for the duration of the
-      // scope where they were introduced, and therefore are often
-      // invalid at the end of the TU.  So use the namespace name more
-      // likely to be valid at the end of the TU.
+          Ctx, TD, true /*FullyQualified*/, WithGlobalNsPrefix);
+    } else if (auto const *TDD = dyn_cast<TypedefType>(Type)) {
       return TypeName::createNestedNameSpecifier(
-          Ctx,
-          Scope->getAsNamespaceAlias()->getNamespace()->getCanonicalDecl(),
-          WithGlobalNsPrefix);
-    case NestedNameSpecifier::Identifier:
-      // A function or some other construct that makes it un-namable
-      // at the end of the TU. Skip the current component of the name,
-      // but use the name of it's prefix.
-      return getFullyQualifiedNestedNameSpecifier(
-          Ctx, Scope->getPrefix(), WithGlobalNsPrefix);
-    case NestedNameSpecifier::Super:
-    case NestedNameSpecifier::TypeSpec:
-    case NestedNameSpecifier::TypeSpecWithTemplate: {
-      const Type *Type = Scope->getAsType();
-      // Find decl context.
-      const TagDecl *TD = nullptr;
-      if (const TagType *TagDeclType = Type->getAs<TagType>()) {
-        TD = TagDeclType->getDecl();
-      } else {
-        TD = Type->getAsCXXRecordDecl();
-      }
-      if (TD) {
-        return TypeName::createNestedNameSpecifier(Ctx, TD,
-                                                   true /*FullyQualified*/,
-                                                   WithGlobalNsPrefix);
-      } else if (const auto *TDD = dyn_cast<TypedefType>(Type)) {
-        return TypeName::createNestedNameSpecifier(Ctx, TDD->getDecl(),
-                                                   true /*FullyQualified*/,
-                                                   WithGlobalNsPrefix);
-      }
-      return Scope;
+          Ctx, TDD->getDecl(), true /*FullyQualified*/, WithGlobalNsPrefix);
     }
+    return Scope;
+  }
   }
   llvm_unreachable("bad NNS kind");
 }
 
 /// Create a nested name specifier for the declaring context of
 /// the type.
-static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
-    const ASTContext &Ctx, const Decl *Decl,
-    bool FullyQualified, bool WithGlobalNsPrefix) {
+static NestedNameSpecifier *
+createNestedNameSpecifierForScopeOf(ASTContext const &Ctx, Decl const *Decl,
+                                    bool FullyQualified,
+                                    bool WithGlobalNsPrefix) {
   assert(Decl);
 
-  const DeclContext *DC = Decl->getDeclContext()->getRedeclContext();
-  const auto *Outer = dyn_cast_or_null<NamedDecl>(DC);
-  const auto *OuterNS = dyn_cast_or_null<NamespaceDecl>(DC);
+  DeclContext const *DC = Decl->getDeclContext()->getRedeclContext();
+  auto const *Outer = dyn_cast_or_null<NamedDecl>(DC);
+  auto const *OuterNS = dyn_cast_or_null<NamespaceDecl>(DC);
   if (Outer && !(OuterNS && OuterNS->isAnonymousNamespace())) {
-    if (const auto *CxxDecl = dyn_cast<CXXRecordDecl>(DC)) {
+    if (auto const *CxxDecl = dyn_cast<CXXRecordDecl>(DC)) {
       if (ClassTemplateDecl *ClassTempl =
               CxxDecl->getDescribedClassTemplate()) {
         // We are in the case of a type(def) that was declared in a
@@ -293,9 +291,9 @@
 
     if (OuterNS) {
       return createNestedNameSpecifier(Ctx, OuterNS, WithGlobalNsPrefix);
-    } else if (const auto *TD = dyn_cast<TagDecl>(Outer)) {
-      return createNestedNameSpecifier(
-          Ctx, TD, FullyQualified, WithGlobalNsPrefix);
+    } else if (auto const *TD = dyn_cast<TagDecl>(Outer)) {
+      return createNestedNameSpecifier(Ctx, TD, FullyQualified,
+                                       WithGlobalNsPrefix);
     } else if (dyn_cast<TranslationUnitDecl>(Outer)) {
       // Context is the TU. Nothing needs to be done.
       return nullptr;
@@ -313,50 +311,53 @@
 
 /// Create a nested name specifier for the declaring context of
 /// the type.
-static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
-    const ASTContext &Ctx, const Type *TypePtr,
-    bool FullyQualified, bool WithGlobalNsPrefix) {
-  if (!TypePtr) return nullptr;
+static NestedNameSpecifier *
+createNestedNameSpecifierForScopeOf(ASTContext const &Ctx, Type const *TypePtr,
+                                    bool FullyQualified,
+                                    bool WithGlobalNsPrefix) {
+  if (!TypePtr)
+    return nullptr;
 
   Decl *Decl = nullptr;
   // There are probably other cases ...
-  if (const auto *TDT = dyn_cast<TypedefType>(TypePtr)) {
+  if (auto const *TDT = dyn_cast<TypedefType>(TypePtr)) {
     Decl = TDT->getDecl();
-  } else if (const auto *TagDeclType = dyn_cast<TagType>(TypePtr)) {
+  } else if (auto const *TagDeclType = dyn_cast<TagType>(TypePtr)) {
     Decl = TagDeclType->getDecl();
-  } else if (const auto *TST = dyn_cast<TemplateSpecializationType>(TypePtr)) {
+  } else if (auto const *TST = dyn_cast<TemplateSpecializationType>(TypePtr)) {
     Decl = TST->getTemplateName().getAsTemplateDecl();
   } else {
     Decl = TypePtr->getAsCXXRecordDecl();
   }
 
-  if (!Decl) return nullptr;
+  if (!Decl)
+    return nullptr;
 
-  return createNestedNameSpecifierForScopeOf(
-      Ctx, Decl, FullyQualified, WithGlobalNsPrefix);
+  return createNestedNameSpecifierForScopeOf(Ctx, Decl, FullyQualified,
+                                             WithGlobalNsPrefix);
 }
 
-NestedNameSpecifier *createNestedNameSpecifier(const ASTContext &Ctx,
-                                               const NamespaceDecl *Namespace,
+NestedNameSpecifier *createNestedNameSpecifier(ASTContext const &Ctx,
+                                               NamespaceDecl const *Namespace,
                                                bool WithGlobalNsPrefix) {
   while (Namespace && Namespace->isInline()) {
     // Ignore inline namespace;
     Namespace = dyn_cast<NamespaceDecl>(Namespace->getDeclContext());
   }
-  if (!Namespace) return nullptr;
+  if (!Namespace)
+    return nullptr;
 
-  bool FullyQualified = true;  // doesn't matter, DeclContexts are namespaces
+  bool FullyQualified = true; // doesn't matter, DeclContexts are namespaces
   return NestedNameSpecifier::Create(
-      Ctx,
-      createOuterNNS(Ctx, Namespace, FullyQualified, WithGlobalNsPrefix),
+      Ctx, createOuterNNS(Ctx, Namespace, FullyQualified, WithGlobalNsPrefix),
       Namespace);
 }
 
-NestedNameSpecifier *createNestedNameSpecifier(const ASTContext &Ctx,
-                                               const TypeDecl *TD,
+NestedNameSpecifier *createNestedNameSpecifier(ASTContext const &Ctx,
+                                               TypeDecl const *TD,
                                                bool FullyQualify,
                                                bool WithGlobalNsPrefix) {
-  const Type *TypePtr = TD->getTypeForDecl();
+  Type const *TypePtr = TD->getTypeForDecl();
   if (isa<const TemplateSpecializationType>(TypePtr) ||
       isa<const RecordType>(TypePtr)) {
     // We are asked to fully qualify and we have a Record Type (which
@@ -373,7 +374,7 @@
 
 /// Return the fully qualified type, including fully-qualified
 /// versions of any template parameters.
-QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx,
+QualType getFullyQualifiedType(QualType QT, ASTContext const &Ctx,
                                bool WithGlobalNsPrefix) {
   // In case of myType* we need to strip the pointer first, fully
   // qualify and attach the pointer once again.
@@ -439,15 +440,14 @@
   Qualifiers PrefixQualifiers = QT.getLocalQualifiers();
   QT = QualType(QT.getTypePtr(), 0);
   ElaboratedTypeKeyword Keyword = ETK_None;
-  if (const auto *ETypeInput = dyn_cast<ElaboratedType>(QT.getTypePtr())) {
+  if (auto const *ETypeInput = dyn_cast<ElaboratedType>(QT.getTypePtr())) {
     QT = ETypeInput->getNamedType();
     assert(!QT.hasLocalQualifiers());
     Keyword = ETypeInput->getKeyword();
   }
   // Create a nested name specifier if needed.
-  Prefix = createNestedNameSpecifierForScopeOf(Ctx, QT.getTypePtr(),
-                                               true /*FullyQualified*/,
-                                               WithGlobalNsPrefix);
+  Prefix = createNestedNameSpecifierForScopeOf(
+      Ctx, QT.getTypePtr(), true /*FullyQualified*/, WithGlobalNsPrefix);
 
   // In case of template specializations iterate over the arguments and
   // fully qualify them as well.
@@ -457,8 +457,8 @@
     // may point to a template specialization) or Template
     // Specialization Type. We need to fully qualify their arguments.
 
-    const Type *TypePtr = getFullyQualifiedTemplateType(
-        Ctx, QT.getTypePtr(), WithGlobalNsPrefix);
+    Type const *TypePtr =
+        getFullyQualifiedTemplateType(Ctx, QT.getTypePtr(), WithGlobalNsPrefix);
     QT = QualType(TypePtr, 0);
   }
   if (Prefix || Keyword != ETK_None) {
@@ -468,13 +468,12 @@
   return QT;
 }
 
-std::string getFullyQualifiedName(QualType QT,
-                                  const ASTContext &Ctx,
-                                  const PrintingPolicy &Policy,
+std::string getFullyQualifiedName(QualType QT, ASTContext const &Ctx,
+                                  PrintingPolicy const &Policy,
                                   bool WithGlobalNsPrefix) {
   QualType FQQT = getFullyQualifiedType(QT, Ctx, WithGlobalNsPrefix);
   return FQQT.getAsString(Policy);
 }
 
-}  // end namespace TypeName
-}  // end namespace clang
+} // end namespace TypeName
+} // end namespace clang
Index: clang/lib/AST/RawCommentList.cpp
===================================================================
--- clang/lib/AST/RawCommentList.cpp
+++ clang/lib/AST/RawCommentList.cpp
@@ -44,8 +44,7 @@
 
     // Comment lexer does not understand escapes in comment markers, so pretend
     // that this is not a comment.
-    if (Comment[1] != '*' ||
-        Comment[Comment.size() - 2] != '*' ||
+    if (Comment[1] != '*' || Comment[Comment.size() - 2] != '*' ||
         Comment[Comment.size() - 1] != '/')
       return std::make_pair(RawComment::RCK_Invalid, false);
 
@@ -56,7 +55,7 @@
     else
       return std::make_pair(RawComment::RCK_OrdinaryC, false);
   }
-  const bool TrailingComment = (Comment.size() > 3) && (Comment[3] == '<');
+  bool const TrailingComment = (Comment.size() > 3) && (Comment[3] == '<');
   return std::make_pair(K, TrailingComment);
 }
 
@@ -66,8 +65,8 @@
 
 /// Returns true if R1 and R2 both have valid locations that start on the same
 /// column.
-bool commentsStartOnSameColumn(const SourceManager &SM, const RawComment &R1,
-                               const RawComment &R2) {
+bool commentsStartOnSameColumn(SourceManager const &SM, RawComment const &R1,
+                               RawComment const &R2) {
   SourceLocation L1 = R1.getBeginLoc();
   SourceLocation L2 = R2.getBeginLoc();
   bool Invalid = false;
@@ -87,7 +86,7 @@
 /// \return true if all of the characters in `Buffer` ranging from the closest
 /// line-ending character before `P` (or the beginning of `Buffer`) to `P - 1`
 /// are whitespace.
-static bool onlyWhitespaceOnLineBefore(const char *Buffer, unsigned P) {
+static bool onlyWhitespaceOnLineBefore(char const *Buffer, unsigned P) {
   // Search backwards until we see linefeed or carriage return.
   for (unsigned I = P; I != 0; --I) {
     char C = Buffer[I - 1];
@@ -106,11 +105,10 @@
          (K == RawComment::RCK_OrdinaryC);
 }
 
-RawComment::RawComment(const SourceManager &SourceMgr, SourceRange SR,
-                       const CommentOptions &CommentOpts, bool Merged) :
-    Range(SR), RawTextValid(false), BriefTextValid(false),
-    IsAttached(false), IsTrailingComment(false),
-    IsAlmostTrailingComment(false) {
+RawComment::RawComment(SourceManager const &SourceMgr, SourceRange SR,
+                       CommentOptions const &CommentOpts, bool Merged)
+    : Range(SR), RawTextValid(false), BriefTextValid(false), IsAttached(false),
+      IsTrailingComment(false), IsAlmostTrailingComment(false) {
   // Extract raw comment text, if possible.
   if (SR.getBegin() == SR.getEnd() || getRawText(SourceMgr).empty()) {
     Kind = RCK_Invalid;
@@ -129,7 +127,7 @@
         SourceMgr.getDecomposedLoc(Range.getBegin());
     if (BeginOffset != 0) {
       bool Invalid = false;
-      const char *Buffer =
+      char const *Buffer =
           SourceMgr.getBufferData(BeginFileID, &Invalid).data();
       IsTrailingComment |=
           (!Invalid && !onlyWhitespaceOnLineBefore(Buffer, BeginOffset));
@@ -140,8 +138,8 @@
     Kind = K.first;
     IsTrailingComment |= K.second;
 
-    IsAlmostTrailingComment = RawText.startswith("//<") ||
-                                 RawText.startswith("/*<");
+    IsAlmostTrailingComment =
+        RawText.startswith("//<") || RawText.startswith("/*<");
   } else {
     Kind = RCK_Merged;
     IsTrailingComment =
@@ -149,7 +147,7 @@
   }
 }
 
-StringRef RawComment::getRawTextSlow(const SourceManager &SourceMgr) const {
+StringRef RawComment::getRawTextSlow(SourceManager const &SourceMgr) const {
   FileID BeginFileID;
   FileID EndFileID;
   unsigned BeginOffset;
@@ -159,7 +157,7 @@
       SourceMgr.getDecomposedLoc(Range.getBegin());
   std::tie(EndFileID, EndOffset) = SourceMgr.getDecomposedLoc(Range.getEnd());
 
-  const unsigned Length = EndOffset - BeginOffset;
+  unsigned const Length = EndOffset - BeginOffset;
   if (Length < 2)
     return StringRef();
 
@@ -167,15 +165,15 @@
   assert(BeginFileID == EndFileID);
 
   bool Invalid = false;
-  const char *BufferStart = SourceMgr.getBufferData(BeginFileID,
-                                                    &Invalid).data();
+  char const *BufferStart =
+      SourceMgr.getBufferData(BeginFileID, &Invalid).data();
   if (Invalid)
     return StringRef();
 
   return StringRef(BufferStart + BeginOffset, Length);
 }
 
-const char *RawComment::extractBriefText(const ASTContext &Context) const {
+char const *RawComment::extractBriefText(ASTContext const &Context) const {
   // Lazily initialize RawText using the accessor before using it.
   (void)getRawText(Context.getSourceManager());
 
@@ -185,13 +183,12 @@
   llvm::BumpPtrAllocator Allocator;
 
   comments::Lexer L(Allocator, Context.getDiagnostics(),
-                    Context.getCommentCommandTraits(),
-                    Range.getBegin(),
+                    Context.getCommentCommandTraits(), Range.getBegin(),
                     RawText.begin(), RawText.end());
   comments::BriefParser P(L, Context.getCommentCommandTraits());
 
   const std::string Result = P.Parse();
-  const unsigned BriefTextLength = Result.size();
+  unsigned const BriefTextLength = Result.size();
   char *BriefTextPtr = new (Context) char[BriefTextLength + 1];
   memcpy(BriefTextPtr, Result.c_str(), BriefTextLength + 1);
   BriefText = BriefTextPtr;
@@ -200,19 +197,18 @@
   return BriefTextPtr;
 }
 
-comments::FullComment *RawComment::parse(const ASTContext &Context,
-                                         const Preprocessor *PP,
-                                         const Decl *D) const {
+comments::FullComment *RawComment::parse(ASTContext const &Context,
+                                         Preprocessor const *PP,
+                                         Decl const *D) const {
   // Lazily initialize RawText using the accessor before using it.
   (void)getRawText(Context.getSourceManager());
 
   comments::Lexer L(Context.getAllocator(), Context.getDiagnostics(),
                     Context.getCommentCommandTraits(),
-                    getSourceRange().getBegin(),
-                    RawText.begin(), RawText.end());
+                    getSourceRange().getBegin(), RawText.begin(),
+                    RawText.end());
   comments::Sema S(Context.getAllocator(), Context.getSourceManager(),
-                   Context.getDiagnostics(),
-                   Context.getCommentCommandTraits(),
+                   Context.getDiagnostics(), Context.getCommentCommandTraits(),
                    PP);
   S.setDecl(D);
   comments::Parser P(L, S, Context.getAllocator(), Context.getSourceManager(),
@@ -222,8 +218,8 @@
   return P.parseFullComment();
 }
 
-static bool onlyWhitespaceBetween(SourceManager &SM,
-                                  SourceLocation Loc1, SourceLocation Loc2,
+static bool onlyWhitespaceBetween(SourceManager &SM, SourceLocation Loc1,
+                                  SourceLocation Loc2,
                                   unsigned MaxNewlinesAllowed) {
   std::pair<FileID, unsigned> Loc1Info = SM.getDecomposedLoc(Loc1);
   std::pair<FileID, unsigned> Loc2Info = SM.getDecomposedLoc(Loc2);
@@ -233,7 +229,7 @@
     return false;
 
   bool Invalid = false;
-  const char *Buffer = SM.getBufferData(Loc1Info.first, &Invalid).data();
+  char const *Buffer = SM.getBufferData(Loc1Info.first, &Invalid).data();
   if (Invalid)
     return false;
 
@@ -270,8 +266,8 @@
   return true;
 }
 
-void RawCommentList::addComment(const RawComment &RC,
-                                const CommentOptions &CommentOpts,
+void RawCommentList::addComment(RawComment const &RC,
+                                CommentOptions const &CommentOpts,
                                 llvm::BumpPtrAllocator &Allocator) {
   if (RC.isInvalid())
     return;
@@ -284,7 +280,7 @@
       SourceMgr.getDecomposedLoc(RC.getBeginLoc());
 
   const FileID CommentFile = Loc.first;
-  const unsigned CommentOffset = Loc.second;
+  unsigned const CommentOffset = Loc.second;
 
   // If this is the first Doxygen comment, save it (because there isn't
   // anything to merge it with).
@@ -294,8 +290,8 @@
     return;
   }
 
-  const RawComment &C1 = *OrderedComments[CommentFile].rbegin()->second;
-  const RawComment &C2 = RC;
+  RawComment const &C1 = *OrderedComments[CommentFile].rbegin()->second;
+  RawComment const &C2 = RC;
 
   // Merge comments only if there is only whitespace between them.
   // Can't merge trailing and non-trailing comments unless the second is
@@ -325,7 +321,7 @@
   }
 }
 
-const std::map<unsigned, RawComment *> *
+std::map<unsigned, RawComment *> const *
 RawCommentList::getCommentsInFile(FileID File) const {
   auto CommentsInFile = OrderedComments.find(File);
   if (CommentsInFile == OrderedComments.end())
@@ -341,7 +337,7 @@
   auto Cached = CommentBeginLine.find(C);
   if (Cached != CommentBeginLine.end())
     return Cached->second;
-  const unsigned Line = SourceMgr.getLineNumber(File, Offset);
+  unsigned const Line = SourceMgr.getLineNumber(File, Offset);
   CommentBeginLine[C] = Line;
   return Line;
 }
@@ -350,13 +346,13 @@
   auto Cached = CommentEndOffset.find(C);
   if (Cached != CommentEndOffset.end())
     return Cached->second;
-  const unsigned Offset =
+  unsigned const Offset =
       SourceMgr.getDecomposedLoc(C->getSourceRange().getEnd()).second;
   CommentEndOffset[C] = Offset;
   return Offset;
 }
 
-std::string RawComment::getFormattedText(const SourceManager &SourceMgr,
+std::string RawComment::getFormattedText(SourceManager const &SourceMgr,
                                          DiagnosticsEngine &Diags) const {
   llvm::StringRef CommentText = getRawText(SourceMgr);
   if (CommentText.empty())
Index: clang/lib/AST/RecordLayout.cpp
===================================================================
--- clang/lib/AST/RecordLayout.cpp
+++ clang/lib/AST/RecordLayout.cpp
@@ -27,7 +27,7 @@
   Ctx.Deallocate(this);
 }
 
-ASTRecordLayout::ASTRecordLayout(const ASTContext &Ctx, CharUnits size,
+ASTRecordLayout::ASTRecordLayout(ASTContext const &Ctx, CharUnits size,
                                  CharUnits alignment,
                                  CharUnits preferredAlignment,
                                  CharUnits unadjustedAlignment,
@@ -43,16 +43,16 @@
 
 // Constructor for C++ records.
 ASTRecordLayout::ASTRecordLayout(
-    const ASTContext &Ctx, CharUnits size, CharUnits alignment,
+    ASTContext const &Ctx, CharUnits size, CharUnits alignment,
     CharUnits preferredAlignment, CharUnits unadjustedAlignment,
     CharUnits requiredAlignment, bool hasOwnVFPtr, bool hasExtendableVFPtr,
     CharUnits vbptroffset, CharUnits datasize, ArrayRef<uint64_t> fieldoffsets,
     CharUnits nonvirtualsize, CharUnits nonvirtualalignment,
     CharUnits preferrednvalignment, CharUnits SizeOfLargestEmptySubobject,
-    const CXXRecordDecl *PrimaryBase, bool IsPrimaryBaseVirtual,
-    const CXXRecordDecl *BaseSharingVBPtr, bool EndsWithZeroSizedObject,
-    bool LeadsWithZeroSizedBase, const BaseOffsetsMapTy &BaseOffsets,
-    const VBaseOffsetsMapTy &VBaseOffsets)
+    CXXRecordDecl const *PrimaryBase, bool IsPrimaryBaseVirtual,
+    CXXRecordDecl const *BaseSharingVBPtr, bool EndsWithZeroSizedObject,
+    bool LeadsWithZeroSizedBase, BaseOffsetsMapTy const &BaseOffsets,
+    VBaseOffsetsMapTy const &VBaseOffsets)
     : Size(size), DataSize(datasize), Alignment(alignment),
       PreferredAlignment(preferredAlignment),
       UnadjustedAlignment(unadjustedAlignment),
@@ -76,16 +76,16 @@
   CXXInfo->LeadsWithZeroSizedBase = LeadsWithZeroSizedBase;
 
 #ifndef NDEBUG
-    if (const CXXRecordDecl *PrimaryBase = getPrimaryBase()) {
-      if (isPrimaryBaseVirtual()) {
-        if (Ctx.getTargetInfo().getCXXABI().hasPrimaryVBases()) {
-          assert(getVBaseClassOffset(PrimaryBase).isZero() &&
-                 "Primary virtual base must be at offset 0!");
-        }
-      } else {
-        assert(getBaseClassOffset(PrimaryBase).isZero() &&
-               "Primary base must be at offset 0!");
+  if (CXXRecordDecl const *PrimaryBase = getPrimaryBase()) {
+    if (isPrimaryBaseVirtual()) {
+      if (Ctx.getTargetInfo().getCXXABI().hasPrimaryVBases()) {
+        assert(getVBaseClassOffset(PrimaryBase).isZero() &&
+               "Primary virtual base must be at offset 0!");
       }
+    } else {
+      assert(getBaseClassOffset(PrimaryBase).isZero() &&
+             "Primary base must be at offset 0!");
     }
+  }
 #endif
 }
Index: clang/lib/AST/RecordLayoutBuilder.cpp
===================================================================
--- clang/lib/AST/RecordLayoutBuilder.cpp
+++ clang/lib/AST/RecordLayoutBuilder.cpp
@@ -14,8 +14,8 @@
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
-#include "clang/AST/VTableBuilder.h"
 #include "clang/AST/RecordLayout.h"
+#include "clang/AST/VTableBuilder.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Support/Format.h"
@@ -38,20 +38,20 @@
 /// If a base is virtual, it will only have one BaseSubobjectInfo allocated.
 struct BaseSubobjectInfo {
   /// Class - The class for this base info.
-  const CXXRecordDecl *Class;
+  CXXRecordDecl const *Class;
 
   /// IsVirtual - Whether the BaseInfo represents a virtual base or not.
   bool IsVirtual;
 
   /// Bases - Information about the base subobjects.
-  SmallVector<BaseSubobjectInfo*, 4> Bases;
+  SmallVector<BaseSubobjectInfo *, 4> Bases;
 
   /// PrimaryVirtualBaseInfo - Holds the base info for the primary virtual base
   /// of this base info (if one exists).
   BaseSubobjectInfo *PrimaryVirtualBaseInfo;
 
   // FIXME: Document.
-  const BaseSubobjectInfo *Derived;
+  BaseSubobjectInfo const *Derived;
 };
 
 /// Externally provided layout. Typically used when the AST source, such
@@ -67,23 +67,22 @@
   uint64_t Align;
 
   /// Record field offsets in bits.
-  llvm::DenseMap<const FieldDecl *, uint64_t> FieldOffsets;
+  llvm::DenseMap<FieldDecl const *, uint64_t> FieldOffsets;
 
   /// Direct, non-virtual base offsets.
-  llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsets;
+  llvm::DenseMap<CXXRecordDecl const *, CharUnits> BaseOffsets;
 
   /// Virtual base offsets.
-  llvm::DenseMap<const CXXRecordDecl *, CharUnits> VirtualBaseOffsets;
+  llvm::DenseMap<CXXRecordDecl const *, CharUnits> VirtualBaseOffsets;
 
   /// Get the offset of the given field. The external source must provide
   /// entries for all fields in the record.
-  uint64_t getExternalFieldOffset(const FieldDecl *FD) {
-    assert(FieldOffsets.count(FD) &&
-           "Field does not have an external offset");
+  uint64_t getExternalFieldOffset(FieldDecl const *FD) {
+    assert(FieldOffsets.count(FD) && "Field does not have an external offset");
     return FieldOffsets[FD];
   }
 
-  bool getExternalNVBaseOffset(const CXXRecordDecl *RD, CharUnits &BaseOffset) {
+  bool getExternalNVBaseOffset(CXXRecordDecl const *RD, CharUnits &BaseOffset) {
     auto Known = BaseOffsets.find(RD);
     if (Known == BaseOffsets.end())
       return false;
@@ -91,7 +90,7 @@
     return true;
   }
 
-  bool getExternalVBaseOffset(const CXXRecordDecl *RD, CharUnits &BaseOffset) {
+  bool getExternalVBaseOffset(CXXRecordDecl const *RD, CharUnits &BaseOffset) {
     auto Known = VirtualBaseOffsets.find(RD);
     if (Known == VirtualBaseOffsets.end())
       return false;
@@ -103,14 +102,14 @@
 /// EmptySubobjectMap - Keeps track of which empty subobjects exist at different
 /// offsets while laying out a C++ class.
 class EmptySubobjectMap {
-  const ASTContext &Context;
+  ASTContext const &Context;
   uint64_t CharWidth;
 
   /// Class - The class whose empty entries we're keeping track of.
-  const CXXRecordDecl *Class;
+  CXXRecordDecl const *Class;
 
   /// EmptyClassOffsets - A map from offsets to empty record decls.
-  typedef llvm::TinyPtrVector<const CXXRecordDecl *> ClassVectorTy;
+  typedef llvm::TinyPtrVector<CXXRecordDecl const *> ClassVectorTy;
   typedef llvm::DenseMap<CharUnits, ClassVectorTy> EmptyClassOffsetsMapTy;
   EmptyClassOffsetsMapTy EmptyClassOffsets;
 
@@ -122,15 +121,15 @@
   /// member subobject that is empty.
   void ComputeEmptySubobjectSizes();
 
-  void AddSubobjectAtOffset(const CXXRecordDecl *RD, CharUnits Offset);
+  void AddSubobjectAtOffset(CXXRecordDecl const *RD, CharUnits Offset);
 
-  void UpdateEmptyBaseSubobjects(const BaseSubobjectInfo *Info,
+  void UpdateEmptyBaseSubobjects(BaseSubobjectInfo const *Info,
                                  CharUnits Offset, bool PlacingEmptyBase);
 
-  void UpdateEmptyFieldSubobjects(const CXXRecordDecl *RD,
-                                  const CXXRecordDecl *Class, CharUnits Offset,
+  void UpdateEmptyFieldSubobjects(CXXRecordDecl const *RD,
+                                  CXXRecordDecl const *Class, CharUnits Offset,
                                   bool PlacingOverlappingField);
-  void UpdateEmptyFieldSubobjects(const FieldDecl *FD, CharUnits Offset,
+  void UpdateEmptyFieldSubobjects(FieldDecl const *FD, CharUnits Offset,
                                   bool PlacingOverlappingField);
 
   /// AnyEmptySubobjectsBeyondOffset - Returns whether there are any empty
@@ -139,8 +138,8 @@
     return Offset <= MaxEmptyClassOffset;
   }
 
-  CharUnits
-  getFieldOffset(const ASTRecordLayout &Layout, unsigned FieldNo) const {
+  CharUnits getFieldOffset(ASTRecordLayout const &Layout,
+                           unsigned FieldNo) const {
     uint64_t FieldOffset = Layout.getFieldOffset(FieldNo);
     assert(FieldOffset % CharWidth == 0 &&
            "Field offset not at char boundary!");
@@ -149,16 +148,16 @@
   }
 
 protected:
-  bool CanPlaceSubobjectAtOffset(const CXXRecordDecl *RD,
+  bool CanPlaceSubobjectAtOffset(CXXRecordDecl const *RD,
                                  CharUnits Offset) const;
 
-  bool CanPlaceBaseSubobjectAtOffset(const BaseSubobjectInfo *Info,
+  bool CanPlaceBaseSubobjectAtOffset(BaseSubobjectInfo const *Info,
                                      CharUnits Offset);
 
-  bool CanPlaceFieldSubobjectAtOffset(const CXXRecordDecl *RD,
-                                      const CXXRecordDecl *Class,
+  bool CanPlaceFieldSubobjectAtOffset(CXXRecordDecl const *RD,
+                                      CXXRecordDecl const *Class,
                                       CharUnits Offset) const;
-  bool CanPlaceFieldSubobjectAtOffset(const FieldDecl *FD,
+  bool CanPlaceFieldSubobjectAtOffset(FieldDecl const *FD,
                                       CharUnits Offset) const;
 
 public:
@@ -167,30 +166,29 @@
   /// any empty classes.
   CharUnits SizeOfLargestEmptySubobject;
 
-  EmptySubobjectMap(const ASTContext &Context, const CXXRecordDecl *Class)
-  : Context(Context), CharWidth(Context.getCharWidth()), Class(Class) {
-      ComputeEmptySubobjectSizes();
+  EmptySubobjectMap(ASTContext const &Context, CXXRecordDecl const *Class)
+      : Context(Context), CharWidth(Context.getCharWidth()), Class(Class) {
+    ComputeEmptySubobjectSizes();
   }
 
   /// CanPlaceBaseAtOffset - Return whether the given base class can be placed
   /// at the given offset.
   /// Returns false if placing the record will result in two components
   /// (direct or indirect) of the same type having the same offset.
-  bool CanPlaceBaseAtOffset(const BaseSubobjectInfo *Info,
-                            CharUnits Offset);
+  bool CanPlaceBaseAtOffset(BaseSubobjectInfo const *Info, CharUnits Offset);
 
   /// CanPlaceFieldAtOffset - Return whether a field can be placed at the given
   /// offset.
-  bool CanPlaceFieldAtOffset(const FieldDecl *FD, CharUnits Offset);
+  bool CanPlaceFieldAtOffset(FieldDecl const *FD, CharUnits Offset);
 };
 
 void EmptySubobjectMap::ComputeEmptySubobjectSizes() {
   // Check the bases.
-  for (const CXXBaseSpecifier &Base : Class->bases()) {
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+  for (CXXBaseSpecifier const &Base : Class->bases()) {
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
 
     CharUnits EmptySize;
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(BaseDecl);
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(BaseDecl);
     if (BaseDecl->isEmpty()) {
       // If the class decl is empty, get its size.
       EmptySize = Layout.getSize();
@@ -204,8 +202,8 @@
   }
 
   // Check the fields.
-  for (const FieldDecl *FD : Class->fields()) {
-    const RecordType *RT =
+  for (FieldDecl const *FD : Class->fields()) {
+    RecordType const *RT =
         Context.getBaseElementType(FD->getType())->getAs<RecordType>();
 
     // We only care about record types.
@@ -213,8 +211,8 @@
       continue;
 
     CharUnits EmptySize;
-    const CXXRecordDecl *MemberDecl = RT->getAsCXXRecordDecl();
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(MemberDecl);
+    CXXRecordDecl const *MemberDecl = RT->getAsCXXRecordDecl();
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(MemberDecl);
     if (MemberDecl->isEmpty()) {
       // If the class decl is empty, get its size.
       EmptySize = Layout.getSize();
@@ -228,9 +226,8 @@
   }
 }
 
-bool
-EmptySubobjectMap::CanPlaceSubobjectAtOffset(const CXXRecordDecl *RD,
-                                             CharUnits Offset) const {
+bool EmptySubobjectMap::CanPlaceSubobjectAtOffset(CXXRecordDecl const *RD,
+                                                  CharUnits Offset) const {
   // We only need to check empty bases.
   if (!RD->isEmpty())
     return true;
@@ -239,7 +236,7 @@
   if (I == EmptyClassOffsets.end())
     return true;
 
-  const ClassVectorTy &Classes = I->second;
+  ClassVectorTy const &Classes = I->second;
   if (llvm::find(Classes, RD) == Classes.end())
     return true;
 
@@ -247,7 +244,7 @@
   return false;
 }
 
-void EmptySubobjectMap::AddSubobjectAtOffset(const CXXRecordDecl *RD,
+void EmptySubobjectMap::AddSubobjectAtOffset(CXXRecordDecl const *RD,
                                              CharUnits Offset) {
   // We only care about empty bases.
   if (!RD->isEmpty())
@@ -266,9 +263,8 @@
     MaxEmptyClassOffset = Offset;
 }
 
-bool
-EmptySubobjectMap::CanPlaceBaseSubobjectAtOffset(const BaseSubobjectInfo *Info,
-                                                 CharUnits Offset) {
+bool EmptySubobjectMap::CanPlaceBaseSubobjectAtOffset(
+    BaseSubobjectInfo const *Info, CharUnits Offset) {
   // We don't have to keep looking past the maximum offset that's known to
   // contain an empty class.
   if (!AnyEmptySubobjectsBeyondOffset(Offset))
@@ -278,8 +274,8 @@
     return false;
 
   // Traverse all non-virtual bases.
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class);
-  for (const BaseSubobjectInfo *Base : Info->Bases) {
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(Info->Class);
+  for (BaseSubobjectInfo const *Base : Info->Bases) {
     if (Base->IsVirtual)
       continue;
 
@@ -301,7 +297,8 @@
   // Traverse all member variables.
   unsigned FieldNo = 0;
   for (CXXRecordDecl::field_iterator I = Info->Class->field_begin(),
-       E = Info->Class->field_end(); I != E; ++I, ++FieldNo) {
+                                     E = Info->Class->field_end();
+       I != E; ++I, ++FieldNo) {
     if (I->isBitField())
       continue;
 
@@ -313,7 +310,7 @@
   return true;
 }
 
-void EmptySubobjectMap::UpdateEmptyBaseSubobjects(const BaseSubobjectInfo *Info,
+void EmptySubobjectMap::UpdateEmptyBaseSubobjects(BaseSubobjectInfo const *Info,
                                                   CharUnits Offset,
                                                   bool PlacingEmptyBase) {
   if (!PlacingEmptyBase && Offset >= SizeOfLargestEmptySubobject) {
@@ -328,8 +325,8 @@
   AddSubobjectAtOffset(Info->Class, Offset);
 
   // Traverse all non-virtual bases.
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class);
-  for (const BaseSubobjectInfo *Base : Info->Bases) {
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(Info->Class);
+  for (BaseSubobjectInfo const *Base : Info->Bases) {
     if (Base->IsVirtual)
       continue;
 
@@ -348,7 +345,8 @@
   // Traverse all member variables.
   unsigned FieldNo = 0;
   for (CXXRecordDecl::field_iterator I = Info->Class->field_begin(),
-       E = Info->Class->field_end(); I != E; ++I, ++FieldNo) {
+                                     E = Info->Class->field_end();
+       I != E; ++I, ++FieldNo) {
     if (I->isBitField())
       continue;
 
@@ -357,7 +355,7 @@
   }
 }
 
-bool EmptySubobjectMap::CanPlaceBaseAtOffset(const BaseSubobjectInfo *Info,
+bool EmptySubobjectMap::CanPlaceBaseAtOffset(BaseSubobjectInfo const *Info,
                                              CharUnits Offset) {
   // If we know this class doesn't have any empty subobjects we don't need to
   // bother checking.
@@ -373,10 +371,9 @@
   return true;
 }
 
-bool
-EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(const CXXRecordDecl *RD,
-                                                  const CXXRecordDecl *Class,
-                                                  CharUnits Offset) const {
+bool EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(
+    CXXRecordDecl const *RD, CXXRecordDecl const *Class,
+    CharUnits Offset) const {
   // We don't have to keep looking past the maximum offset that's known to
   // contain an empty class.
   if (!AnyEmptySubobjectsBeyondOffset(Offset))
@@ -385,14 +382,14 @@
   if (!CanPlaceSubobjectAtOffset(RD, Offset))
     return false;
 
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
   // Traverse all non-virtual bases.
-  for (const CXXBaseSpecifier &Base : RD->bases()) {
+  for (CXXBaseSpecifier const &Base : RD->bases()) {
     if (Base.isVirtual())
       continue;
 
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
 
     CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl);
     if (!CanPlaceFieldSubobjectAtOffset(BaseDecl, Class, BaseOffset))
@@ -401,8 +398,8 @@
 
   if (RD == Class) {
     // This is the most derived class, traverse virtual bases as well.
-    for (const CXXBaseSpecifier &Base : RD->vbases()) {
-      const CXXRecordDecl *VBaseDecl = Base.getType()->getAsCXXRecordDecl();
+    for (CXXBaseSpecifier const &Base : RD->vbases()) {
+      CXXRecordDecl const *VBaseDecl = Base.getType()->getAsCXXRecordDecl();
 
       CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl);
       if (!CanPlaceFieldSubobjectAtOffset(VBaseDecl, Class, VBaseOffset))
@@ -426,27 +423,26 @@
   return true;
 }
 
-bool
-EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(const FieldDecl *FD,
-                                                  CharUnits Offset) const {
+bool EmptySubobjectMap::CanPlaceFieldSubobjectAtOffset(FieldDecl const *FD,
+                                                       CharUnits Offset) const {
   // We don't have to keep looking past the maximum offset that's known to
   // contain an empty class.
   if (!AnyEmptySubobjectsBeyondOffset(Offset))
     return true;
 
   QualType T = FD->getType();
-  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
+  if (CXXRecordDecl const *RD = T->getAsCXXRecordDecl())
     return CanPlaceFieldSubobjectAtOffset(RD, RD, Offset);
 
   // If we have an array type we need to look at every element.
-  if (const ConstantArrayType *AT = Context.getAsConstantArrayType(T)) {
+  if (ConstantArrayType const *AT = Context.getAsConstantArrayType(T)) {
     QualType ElemTy = Context.getBaseElementType(AT);
-    const RecordType *RT = ElemTy->getAs<RecordType>();
+    RecordType const *RT = ElemTy->getAs<RecordType>();
     if (!RT)
       return true;
 
-    const CXXRecordDecl *RD = RT->getAsCXXRecordDecl();
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+    CXXRecordDecl const *RD = RT->getAsCXXRecordDecl();
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
     uint64_t NumElements = Context.getConstantArrayElementCount(AT);
     CharUnits ElementOffset = Offset;
@@ -466,9 +462,8 @@
   return true;
 }
 
-bool
-EmptySubobjectMap::CanPlaceFieldAtOffset(const FieldDecl *FD,
-                                         CharUnits Offset) {
+bool EmptySubobjectMap::CanPlaceFieldAtOffset(FieldDecl const *FD,
+                                              CharUnits Offset) {
   if (!CanPlaceFieldSubobjectAtOffset(FD, Offset))
     return false;
 
@@ -479,7 +474,7 @@
 }
 
 void EmptySubobjectMap::UpdateEmptyFieldSubobjects(
-    const CXXRecordDecl *RD, const CXXRecordDecl *Class, CharUnits Offset,
+    CXXRecordDecl const *RD, CXXRecordDecl const *Class, CharUnits Offset,
     bool PlacingOverlappingField) {
   // We know that the only empty subobjects that can conflict with empty
   // field subobjects are subobjects of empty bases and potentially-overlapping
@@ -496,14 +491,14 @@
 
   AddSubobjectAtOffset(RD, Offset);
 
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
   // Traverse all non-virtual bases.
-  for (const CXXBaseSpecifier &Base : RD->bases()) {
+  for (CXXBaseSpecifier const &Base : RD->bases()) {
     if (Base.isVirtual())
       continue;
 
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
 
     CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl);
     UpdateEmptyFieldSubobjects(BaseDecl, Class, BaseOffset,
@@ -512,8 +507,8 @@
 
   if (RD == Class) {
     // This is the most derived class, traverse virtual bases as well.
-    for (const CXXBaseSpecifier &Base : RD->vbases()) {
-      const CXXRecordDecl *VBaseDecl = Base.getType()->getAsCXXRecordDecl();
+    for (CXXBaseSpecifier const &Base : RD->vbases()) {
+      CXXRecordDecl const *VBaseDecl = Base.getType()->getAsCXXRecordDecl();
 
       CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl);
       UpdateEmptyFieldSubobjects(VBaseDecl, Class, VBaseOffset,
@@ -535,22 +530,22 @@
 }
 
 void EmptySubobjectMap::UpdateEmptyFieldSubobjects(
-    const FieldDecl *FD, CharUnits Offset, bool PlacingOverlappingField) {
+    FieldDecl const *FD, CharUnits Offset, bool PlacingOverlappingField) {
   QualType T = FD->getType();
-  if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {
+  if (CXXRecordDecl const *RD = T->getAsCXXRecordDecl()) {
     UpdateEmptyFieldSubobjects(RD, RD, Offset, PlacingOverlappingField);
     return;
   }
 
   // If we have an array type we need to update every element.
-  if (const ConstantArrayType *AT = Context.getAsConstantArrayType(T)) {
+  if (ConstantArrayType const *AT = Context.getAsConstantArrayType(T)) {
     QualType ElemTy = Context.getBaseElementType(AT);
-    const RecordType *RT = ElemTy->getAs<RecordType>();
+    RecordType const *RT = ElemTy->getAs<RecordType>();
     if (!RT)
       return;
 
-    const CXXRecordDecl *RD = RT->getAsCXXRecordDecl();
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+    CXXRecordDecl const *RD = RT->getAsCXXRecordDecl();
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
     uint64_t NumElements = Context.getConstantArrayElementCount(AT);
     CharUnits ElementOffset = Offset;
@@ -572,14 +567,14 @@
   }
 }
 
-typedef llvm::SmallPtrSet<const CXXRecordDecl*, 4> ClassSetTy;
+typedef llvm::SmallPtrSet<CXXRecordDecl const *, 4> ClassSetTy;
 
 class ItaniumRecordLayoutBuilder {
 protected:
   // FIXME: Remove this and make the appropriate fields public.
   friend class clang::ASTContext;
 
-  const ASTContext &Context;
+  ASTContext const &Context;
 
   EmptySubobjectMap *EmptySubobjects;
 
@@ -646,7 +641,7 @@
 
   /// PrimaryBase - the primary base class (if one exists) of the class
   /// we're laying out.
-  const CXXRecordDecl *PrimaryBase;
+  CXXRecordDecl const *PrimaryBase;
 
   /// PrimaryBaseIsVirtual - Whether the primary base of the class we're laying
   /// out is virtual.
@@ -665,7 +660,7 @@
   /// field has been handled, if any.
   bool HandledFirstNonOverlappingEmptyField;
 
-  typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;
+  typedef llvm::DenseMap<CXXRecordDecl const *, CharUnits> BaseOffsetsMapTy;
 
   /// Bases - base classes and their offsets in the record.
   BaseOffsetsMapTy Bases;
@@ -679,16 +674,16 @@
 
   /// FirstNearlyEmptyVBase - The first nearly empty virtual base class in
   /// inheritance graph order. Used for determining the primary base class.
-  const CXXRecordDecl *FirstNearlyEmptyVBase;
+  CXXRecordDecl const *FirstNearlyEmptyVBase;
 
   /// VisitedVirtualBases - A set of all the visited virtual bases, used to
   /// avoid visiting virtual bases more than once.
-  llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
+  llvm::SmallPtrSet<CXXRecordDecl const *, 4> VisitedVirtualBases;
 
   /// Valid if UseExternalLayout is true.
   ExternalLayout External;
 
-  ItaniumRecordLayoutBuilder(const ASTContext &Context,
+  ItaniumRecordLayoutBuilder(ASTContext const &Context,
                              EmptySubobjectMap *EmptySubobjects)
       : Context(Context), EmptySubobjects(EmptySubobjects), Size(0),
         Alignment(CharUnits::One()), PreferredAlignment(CharUnits::One()),
@@ -707,25 +702,23 @@
         HandledFirstNonOverlappingEmptyField(false),
         FirstNearlyEmptyVBase(nullptr) {}
 
-  void Layout(const RecordDecl *D);
-  void Layout(const CXXRecordDecl *D);
-  void Layout(const ObjCInterfaceDecl *D);
+  void Layout(RecordDecl const *D);
+  void Layout(CXXRecordDecl const *D);
+  void Layout(ObjCInterfaceDecl const *D);
 
-  void LayoutFields(const RecordDecl *D);
-  void LayoutField(const FieldDecl *D, bool InsertExtraPadding);
+  void LayoutFields(RecordDecl const *D);
+  void LayoutField(FieldDecl const *D, bool InsertExtraPadding);
   void LayoutWideBitField(uint64_t FieldSize, uint64_t StorageUnitSize,
-                          bool FieldPacked, const FieldDecl *D);
-  void LayoutBitField(const FieldDecl *D);
+                          bool FieldPacked, FieldDecl const *D);
+  void LayoutBitField(FieldDecl const *D);
 
-  TargetCXXABI getCXXABI() const {
-    return Context.getTargetInfo().getCXXABI();
-  }
+  TargetCXXABI getCXXABI() const { return Context.getTargetInfo().getCXXABI(); }
 
   /// BaseSubobjectInfoAllocator - Allocator for BaseSubobjectInfo objects.
   llvm::SpecificBumpPtrAllocator<BaseSubobjectInfo> BaseSubobjectInfoAllocator;
 
-  typedef llvm::DenseMap<const CXXRecordDecl *, BaseSubobjectInfo *>
-    BaseSubobjectInfoMapTy;
+  typedef llvm::DenseMap<CXXRecordDecl const *, BaseSubobjectInfo *>
+      BaseSubobjectInfoMapTy;
 
   /// VirtualBaseInfo - Map from all the (direct or indirect) virtual bases
   /// of the class we're laying out to their base subobject info.
@@ -737,48 +730,48 @@
 
   /// ComputeBaseSubobjectInfo - Compute the base subobject information for the
   /// bases of the given class.
-  void ComputeBaseSubobjectInfo(const CXXRecordDecl *RD);
+  void ComputeBaseSubobjectInfo(CXXRecordDecl const *RD);
 
   /// ComputeBaseSubobjectInfo - Compute the base subobject information for a
   /// single class and all of its base classes.
-  BaseSubobjectInfo *ComputeBaseSubobjectInfo(const CXXRecordDecl *RD,
+  BaseSubobjectInfo *ComputeBaseSubobjectInfo(CXXRecordDecl const *RD,
                                               bool IsVirtual,
                                               BaseSubobjectInfo *Derived);
 
   /// DeterminePrimaryBase - Determine the primary base of the given class.
-  void DeterminePrimaryBase(const CXXRecordDecl *RD);
+  void DeterminePrimaryBase(CXXRecordDecl const *RD);
 
-  void SelectPrimaryVBase(const CXXRecordDecl *RD);
+  void SelectPrimaryVBase(CXXRecordDecl const *RD);
 
   void EnsureVTablePointerAlignment(CharUnits UnpackedBaseAlign);
 
   /// LayoutNonVirtualBases - Determines the primary base class (if any) and
   /// lays it out. Will then proceed to lay out all non-virtual base clasess.
-  void LayoutNonVirtualBases(const CXXRecordDecl *RD);
+  void LayoutNonVirtualBases(CXXRecordDecl const *RD);
 
   /// LayoutNonVirtualBase - Lays out a single non-virtual base.
-  void LayoutNonVirtualBase(const BaseSubobjectInfo *Base);
+  void LayoutNonVirtualBase(BaseSubobjectInfo const *Base);
 
-  void AddPrimaryVirtualBaseOffsets(const BaseSubobjectInfo *Info,
+  void AddPrimaryVirtualBaseOffsets(BaseSubobjectInfo const *Info,
                                     CharUnits Offset);
 
   /// LayoutVirtualBases - Lays out all the virtual bases.
-  void LayoutVirtualBases(const CXXRecordDecl *RD,
-                          const CXXRecordDecl *MostDerivedClass);
+  void LayoutVirtualBases(CXXRecordDecl const *RD,
+                          CXXRecordDecl const *MostDerivedClass);
 
   /// LayoutVirtualBase - Lays out a single virtual base.
-  void LayoutVirtualBase(const BaseSubobjectInfo *Base);
+  void LayoutVirtualBase(BaseSubobjectInfo const *Base);
 
   /// LayoutBase - Will lay out a base and return the offset where it was
   /// placed, in chars.
-  CharUnits LayoutBase(const BaseSubobjectInfo *Base);
+  CharUnits LayoutBase(BaseSubobjectInfo const *Base);
 
   /// InitializeLayout - Initialize record layout for the given record decl.
-  void InitializeLayout(const Decl *D);
+  void InitializeLayout(Decl const *D);
 
   /// FinishLayout - Finalize record layout. Adjust record size based on the
   /// alignment.
-  void FinishLayout(const NamedDecl *D);
+  void FinishLayout(NamedDecl const *D);
 
   void UpdateAlignment(CharUnits NewAlignment, CharUnits UnpackedNewAlignment,
                        CharUnits PreferredAlignment);
@@ -794,12 +787,12 @@
   ///
   /// \param Field The field whose offset is being queried.
   /// \param ComputedOffset The offset that we've computed for this field.
-  uint64_t updateExternalFieldOffset(const FieldDecl *Field,
+  uint64_t updateExternalFieldOffset(FieldDecl const *Field,
                                      uint64_t ComputedOffset);
 
   void CheckFieldPadding(uint64_t Offset, uint64_t UnpaddedOffset,
-                          uint64_t UnpackedOffset, unsigned UnpackedAlign,
-                          bool isPacked, const FieldDecl *D);
+                         uint64_t UnpackedOffset, unsigned UnpackedAlign,
+                         bool isPacked, FieldDecl const *D);
 
   DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID);
 
@@ -823,17 +816,17 @@
   void setDataSize(CharUnits NewSize) { DataSize = Context.toBits(NewSize); }
   void setDataSize(uint64_t NewSize) { DataSize = NewSize; }
 
-  ItaniumRecordLayoutBuilder(const ItaniumRecordLayoutBuilder &) = delete;
-  void operator=(const ItaniumRecordLayoutBuilder &) = delete;
+  ItaniumRecordLayoutBuilder(ItaniumRecordLayoutBuilder const &) = delete;
+  void operator=(ItaniumRecordLayoutBuilder const &) = delete;
 };
 } // end anonymous namespace
 
-void ItaniumRecordLayoutBuilder::SelectPrimaryVBase(const CXXRecordDecl *RD) {
-  for (const auto &I : RD->bases()) {
+void ItaniumRecordLayoutBuilder::SelectPrimaryVBase(CXXRecordDecl const *RD) {
+  for (auto const &I : RD->bases()) {
     assert(!I.getType()->isDependentType() &&
            "Cannot layout class with dependent bases.");
 
-    const CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *Base = I.getType()->getAsCXXRecordDecl();
 
     // Check if this is a nearly empty virtual base.
     if (I.isVirtual() && Context.isNearlyEmpty(Base)) {
@@ -857,7 +850,7 @@
 }
 
 /// DeterminePrimaryBase - Determine the primary base of the given class.
-void ItaniumRecordLayoutBuilder::DeterminePrimaryBase(const CXXRecordDecl *RD) {
+void ItaniumRecordLayoutBuilder::DeterminePrimaryBase(CXXRecordDecl const *RD) {
   // If the class isn't dynamic, it won't have a primary base.
   if (!RD->isDynamicClass())
     return;
@@ -869,12 +862,12 @@
   // If the record has a dynamic base class, attempt to choose a primary base
   // class. It is the first (in direct base class order) non-virtual dynamic
   // base class, if one exists.
-  for (const auto &I : RD->bases()) {
+  for (auto const &I : RD->bases()) {
     // Ignore virtual bases.
     if (I.isVirtual())
       continue;
 
-    const CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *Base = I.getType()->getAsCXXRecordDecl();
 
     if (Base->isDynamicClass()) {
       // We found it.
@@ -905,7 +898,7 @@
 }
 
 BaseSubobjectInfo *ItaniumRecordLayoutBuilder::ComputeBaseSubobjectInfo(
-    const CXXRecordDecl *RD, bool IsVirtual, BaseSubobjectInfo *Derived) {
+    CXXRecordDecl const *RD, bool IsVirtual, BaseSubobjectInfo *Derived) {
   BaseSubobjectInfo *Info;
 
   if (IsVirtual) {
@@ -928,12 +921,12 @@
   Info->Derived = nullptr;
   Info->PrimaryVirtualBaseInfo = nullptr;
 
-  const CXXRecordDecl *PrimaryVirtualBase = nullptr;
+  CXXRecordDecl const *PrimaryVirtualBase = nullptr;
   BaseSubobjectInfo *PrimaryVirtualBaseInfo = nullptr;
 
   // Check if this base has a primary virtual base.
   if (RD->getNumVBases()) {
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
     if (Layout.isPrimaryBaseVirtual()) {
       // This base does have a primary virtual base.
       PrimaryVirtualBase = Layout.getPrimaryBase();
@@ -958,10 +951,10 @@
   }
 
   // Now go through all direct bases.
-  for (const auto &I : RD->bases()) {
+  for (auto const &I : RD->bases()) {
     bool IsVirtual = I.isVirtual();
 
-    const CXXRecordDecl *BaseDecl = I.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *BaseDecl = I.getType()->getAsCXXRecordDecl();
 
     Info->Bases.push_back(ComputeBaseSubobjectInfo(BaseDecl, IsVirtual, Info));
   }
@@ -970,8 +963,7 @@
     // Traversing the bases must have created the base info for our primary
     // virtual base.
     PrimaryVirtualBaseInfo = VirtualBaseInfo.lookup(PrimaryVirtualBase);
-    assert(PrimaryVirtualBaseInfo &&
-           "Did not create a primary virtual base!");
+    assert(PrimaryVirtualBaseInfo && "Did not create a primary virtual base!");
 
     // Claim the primary virtual base as our primary virtual base.
     Info->PrimaryVirtualBaseInfo = PrimaryVirtualBaseInfo;
@@ -982,20 +974,19 @@
 }
 
 void ItaniumRecordLayoutBuilder::ComputeBaseSubobjectInfo(
-    const CXXRecordDecl *RD) {
-  for (const auto &I : RD->bases()) {
+    CXXRecordDecl const *RD) {
+  for (auto const &I : RD->bases()) {
     bool IsVirtual = I.isVirtual();
 
-    const CXXRecordDecl *BaseDecl = I.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *BaseDecl = I.getType()->getAsCXXRecordDecl();
 
     // Compute the base subobject info for this base.
-    BaseSubobjectInfo *Info = ComputeBaseSubobjectInfo(BaseDecl, IsVirtual,
-                                                       nullptr);
+    BaseSubobjectInfo *Info =
+        ComputeBaseSubobjectInfo(BaseDecl, IsVirtual, nullptr);
 
     if (IsVirtual) {
       // ComputeBaseInfo has already added this base for us.
-      assert(VirtualBaseInfo.count(BaseDecl) &&
-             "Did not add virtual base!");
+      assert(VirtualBaseInfo.count(BaseDecl) && "Did not add virtual base!");
     } else {
       // Add the base info to the map of non-virtual bases.
       assert(!NonVirtualBaseInfo.count(BaseDecl) &&
@@ -1023,7 +1014,7 @@
 }
 
 void ItaniumRecordLayoutBuilder::LayoutNonVirtualBases(
-    const CXXRecordDecl *RD) {
+    CXXRecordDecl const *RD) {
   // Then, determine the primary base class.
   DeterminePrimaryBase(RD);
 
@@ -1048,21 +1039,21 @@
       LayoutVirtualBase(PrimaryBaseInfo);
     } else {
       BaseSubobjectInfo *PrimaryBaseInfo =
-        NonVirtualBaseInfo.lookup(PrimaryBase);
+          NonVirtualBaseInfo.lookup(PrimaryBase);
       assert(PrimaryBaseInfo &&
              "Did not find base info for non-virtual primary base!");
 
       LayoutNonVirtualBase(PrimaryBaseInfo);
     }
 
-  // If this class needs a vtable/vf-table and didn't get one from a
-  // primary base, add it in now.
+    // If this class needs a vtable/vf-table and didn't get one from a
+    // primary base, add it in now.
   } else if (RD->isDynamicClass()) {
     assert(DataSize == 0 && "Vtable pointer must be at offset zero!");
     CharUnits PtrWidth =
-      Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
+        Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerWidth(0));
     CharUnits PtrAlign =
-      Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerAlign(0));
+        Context.toCharUnitsFromBits(Context.getTargetInfo().getPointerAlign(0));
     EnsureVTablePointerAlignment(PtrAlign);
     HasOwnVFPtr = true;
 
@@ -1074,13 +1065,13 @@
   }
 
   // Now lay out the non-virtual bases.
-  for (const auto &I : RD->bases()) {
+  for (auto const &I : RD->bases()) {
 
     // Ignore virtual bases.
     if (I.isVirtual())
       continue;
 
-    const CXXRecordDecl *BaseDecl = I.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *BaseDecl = I.getType()->getAsCXXRecordDecl();
 
     // Skip the primary base, because we've already laid it out.  The
     // !PrimaryBaseIsVirtual check is required because we might have a
@@ -1097,7 +1088,7 @@
 }
 
 void ItaniumRecordLayoutBuilder::LayoutNonVirtualBase(
-    const BaseSubobjectInfo *Base) {
+    BaseSubobjectInfo const *Base) {
   // Layout the base.
   CharUnits Offset = LayoutBase(Base);
 
@@ -1109,7 +1100,7 @@
 }
 
 void ItaniumRecordLayoutBuilder::AddPrimaryVirtualBaseOffsets(
-    const BaseSubobjectInfo *Info, CharUnits Offset) {
+    BaseSubobjectInfo const *Info, CharUnits Offset) {
   // This base isn't interesting, it has no virtual bases.
   if (!Info->Class->getNumVBases())
     return;
@@ -1131,8 +1122,8 @@
   }
 
   // Now go through all direct non-virtual bases.
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(Info->Class);
-  for (const BaseSubobjectInfo *Base : Info->Bases) {
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(Info->Class);
+  for (BaseSubobjectInfo const *Base : Info->Bases) {
     if (Base->IsVirtual)
       continue;
 
@@ -1142,24 +1133,24 @@
 }
 
 void ItaniumRecordLayoutBuilder::LayoutVirtualBases(
-    const CXXRecordDecl *RD, const CXXRecordDecl *MostDerivedClass) {
-  const CXXRecordDecl *PrimaryBase;
+    CXXRecordDecl const *RD, CXXRecordDecl const *MostDerivedClass) {
+  CXXRecordDecl const *PrimaryBase;
   bool PrimaryBaseIsVirtual;
 
   if (MostDerivedClass == RD) {
     PrimaryBase = this->PrimaryBase;
     PrimaryBaseIsVirtual = this->PrimaryBaseIsVirtual;
   } else {
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
     PrimaryBase = Layout.getPrimaryBase();
     PrimaryBaseIsVirtual = Layout.isPrimaryBaseVirtual();
   }
 
-  for (const CXXBaseSpecifier &Base : RD->bases()) {
+  for (CXXBaseSpecifier const &Base : RD->bases()) {
     assert(!Base.getType()->isDependentType() &&
            "Cannot layout class with dependent bases.");
 
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
 
     if (Base.isVirtual()) {
       if (PrimaryBase != BaseDecl || !PrimaryBaseIsVirtual) {
@@ -1171,7 +1162,7 @@
           if (!VisitedVirtualBases.insert(BaseDecl).second)
             continue;
 
-          const BaseSubobjectInfo *BaseInfo = VirtualBaseInfo.lookup(BaseDecl);
+          BaseSubobjectInfo const *BaseInfo = VirtualBaseInfo.lookup(BaseDecl);
           assert(BaseInfo && "Did not find virtual base info!");
           LayoutVirtualBase(BaseInfo);
         }
@@ -1188,7 +1179,7 @@
 }
 
 void ItaniumRecordLayoutBuilder::LayoutVirtualBase(
-    const BaseSubobjectInfo *Base) {
+    BaseSubobjectInfo const *Base) {
   assert(!Base->Derived && "Trying to lay out a primary virtual base!");
 
   // Layout the base.
@@ -1196,17 +1187,17 @@
 
   // Add its base class offset.
   assert(!VBases.count(Base->Class) && "vbase offset already exists!");
-  VBases.insert(std::make_pair(Base->Class,
-                       ASTRecordLayout::VBaseInfo(Offset, false)));
+  VBases.insert(
+      std::make_pair(Base->Class, ASTRecordLayout::VBaseInfo(Offset, false)));
 
   AddPrimaryVirtualBaseOffsets(Base, Offset);
 }
 
 CharUnits
-ItaniumRecordLayoutBuilder::LayoutBase(const BaseSubobjectInfo *Base) {
+ItaniumRecordLayoutBuilder::LayoutBase(BaseSubobjectInfo const *Base) {
   assert(!IsUnion && "Unions cannot have base classes.");
 
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base->Class);
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(Base->Class);
   CharUnits Offset;
 
   // Query the external layout to see if it provides an offset.
@@ -1236,7 +1227,7 @@
   CharUnits PreferredBaseAlign =
       getBaseOrPreferredBaseAlignFromUnpacked(UnpackedPreferredBaseAlign);
 
-  const bool DefaultsToAIXPowerAlignment =
+  bool const DefaultsToAIXPowerAlignment =
       Context.getTargetInfo().defaultsToAIXPowerAlignment();
   if (DefaultsToAIXPowerAlignment) {
     // AIX `power` alignment does not apply the preferred alignment for
@@ -1310,8 +1301,8 @@
   return Offset;
 }
 
-void ItaniumRecordLayoutBuilder::InitializeLayout(const Decl *D) {
-  if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) {
+void ItaniumRecordLayoutBuilder::InitializeLayout(Decl const *D) {
+  if (RecordDecl const *RD = dyn_cast<RecordDecl>(D)) {
     IsUnion = RD->isUnion();
     IsMsStruct = RD->isMsStruct(Context);
   }
@@ -1339,7 +1330,7 @@
     if (D->hasAttr<AlignNaturalAttr>())
       IsNaturalAlign = true;
 
-    if (const MaxFieldAlignmentAttr *MFAA = D->getAttr<MaxFieldAlignmentAttr>())
+    if (MaxFieldAlignmentAttr const *MFAA = D->getAttr<MaxFieldAlignmentAttr>())
       MaxFieldAlignment = Context.toCharUnitsFromBits(MFAA->getAlignment());
 
     if (unsigned MaxAlign = D->getMaxAlignment())
@@ -1350,7 +1341,7 @@
       !Context.getTargetInfo().defaultsToAIXPowerAlignment() || IsNaturalAlign;
 
   // If there is an external AST source, ask it for the various offsets.
-  if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))
+  if (RecordDecl const *RD = dyn_cast<RecordDecl>(D))
     if (ExternalASTSource *Source = Context.getExternalSource()) {
       UseExternalLayout = Source->layoutRecordType(
           RD, External.Size, External.Align, External.FieldOffsets,
@@ -1369,7 +1360,7 @@
     }
 }
 
-void ItaniumRecordLayoutBuilder::Layout(const RecordDecl *D) {
+void ItaniumRecordLayoutBuilder::Layout(RecordDecl const *D) {
   InitializeLayout(D);
   LayoutFields(D);
 
@@ -1378,7 +1369,7 @@
   FinishLayout(D);
 }
 
-void ItaniumRecordLayoutBuilder::Layout(const CXXRecordDecl *RD) {
+void ItaniumRecordLayoutBuilder::Layout(CXXRecordDecl const *RD) {
   InitializeLayout(RD);
 
   // Lay out the vtable and the non-virtual bases.
@@ -1400,27 +1391,27 @@
 
 #ifndef NDEBUG
   // Check that we have base offsets for all bases.
-  for (const CXXBaseSpecifier &Base : RD->bases()) {
+  for (CXXBaseSpecifier const &Base : RD->bases()) {
     if (Base.isVirtual())
       continue;
 
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
 
     assert(Bases.count(BaseDecl) && "Did not find base offset!");
   }
 
   // And all virtual bases.
-  for (const CXXBaseSpecifier &Base : RD->vbases()) {
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+  for (CXXBaseSpecifier const &Base : RD->vbases()) {
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
 
     assert(VBases.count(BaseDecl) && "Did not find base offset!");
   }
 #endif
 }
 
-void ItaniumRecordLayoutBuilder::Layout(const ObjCInterfaceDecl *D) {
+void ItaniumRecordLayoutBuilder::Layout(ObjCInterfaceDecl const *D) {
   if (ObjCInterfaceDecl *SD = D->getSuperClass()) {
-    const ASTRecordLayout &SL = Context.getASTObjCInterfaceLayout(SD);
+    ASTRecordLayout const &SL = Context.getASTObjCInterfaceLayout(SD);
 
     UpdateAlignment(SL.getAlignment());
 
@@ -1432,7 +1423,7 @@
 
   InitializeLayout(D);
   // Layout each ivar sequentially.
-  for (const ObjCIvarDecl *IVD = D->all_declared_ivar_begin(); IVD;
+  for (ObjCIvarDecl const *IVD = D->all_declared_ivar_begin(); IVD;
        IVD = IVD->getNextIvar())
     LayoutField(IVD, false);
 
@@ -1441,7 +1432,7 @@
   FinishLayout(D);
 }
 
-void ItaniumRecordLayoutBuilder::LayoutFields(const RecordDecl *D) {
+void ItaniumRecordLayoutBuilder::LayoutFields(RecordDecl const *D) {
   // Layout each field, for now, just sequentially, respecting alignment.  In
   // the future, this will need to be tweakable by targets.
   bool InsertExtraPadding = D->mayInsertExtraPadding(/*EmitRemark=*/true);
@@ -1455,9 +1446,8 @@
 }
 
 // Rounds the specified size to have it a multiple of the char size.
-static uint64_t
-roundUpSizeToCharAlignment(uint64_t Size,
-                           const ASTContext &Context) {
+static uint64_t roundUpSizeToCharAlignment(uint64_t Size,
+                                           ASTContext const &Context) {
   uint64_t CharAlignment = Context.getTargetInfo().getCharAlign();
   return llvm::alignTo(Size, CharAlignment);
 }
@@ -1465,7 +1455,7 @@
 void ItaniumRecordLayoutBuilder::LayoutWideBitField(uint64_t FieldSize,
                                                     uint64_t StorageUnitSize,
                                                     bool FieldPacked,
-                                                    const FieldDecl *D) {
+                                                    FieldDecl const *D) {
   assert(Context.getLangOpts().CPlusPlus &&
          "Can only have wide bit-fields in C++!");
 
@@ -1474,12 +1464,11 @@
   //   sizeof(T')*8 <= n.
 
   QualType IntegralPODTypes[] = {
-    Context.UnsignedCharTy, Context.UnsignedShortTy, Context.UnsignedIntTy,
-    Context.UnsignedLongTy, Context.UnsignedLongLongTy
-  };
+      Context.UnsignedCharTy, Context.UnsignedShortTy, Context.UnsignedIntTy,
+      Context.UnsignedLongTy, Context.UnsignedLongLongTy};
 
   QualType Type;
-  for (const QualType &QT : IntegralPODTypes) {
+  for (QualType const &QT : IntegralPODTypes) {
     uint64_t Size = Context.getTypeSize(QT);
 
     if (Size > FieldSize)
@@ -1499,8 +1488,7 @@
   uint64_t UnpaddedFieldOffset = getDataSizeInBits() - UnfilledBitsInLastUnit;
 
   if (IsUnion) {
-    uint64_t RoundedFieldSize = roundUpSizeToCharAlignment(FieldSize,
-                                                           Context);
+    uint64_t RoundedFieldSize = roundUpSizeToCharAlignment(FieldSize, Context);
     setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize));
     FieldOffset = 0;
   } else {
@@ -1528,11 +1516,11 @@
   UpdateAlignment(TypeAlign);
 }
 
-static bool isAIXLayout(const ASTContext &Context) {
+static bool isAIXLayout(ASTContext const &Context) {
   return Context.getTargetInfo().getTriple().getOS() == llvm::Triple::AIX;
 }
 
-void ItaniumRecordLayoutBuilder::LayoutBitField(const FieldDecl *D) {
+void ItaniumRecordLayoutBuilder::LayoutBitField(FieldDecl const *D) {
   bool FieldPacked = Packed || D->hasAttr<PackedAttr>();
   uint64_t FieldSize = D->getBitWidthValue(Context);
   TypeInfo FieldInfo = Context.getTypeInfo(D->getType());
@@ -1649,7 +1637,7 @@
 
   // Compute the next available bit offset.
   uint64_t FieldOffset =
-    IsUnion ? 0 : (getDataSizeInBits() - UnfilledBitsInLastUnit);
+      IsUnion ? 0 : (getDataSizeInBits() - UnfilledBitsInLastUnit);
 
   // Handle targets that don't honor bitfield type alignment.
   if (!IsMsStruct && !Context.getTargetInfo().useBitFieldTypeAlignment()) {
@@ -1667,7 +1655,7 @@
             Context.getTargetInfo().getZeroLengthBitfieldBoundary();
         FieldAlign = std::max(FieldAlign, ZeroLengthBitfieldBoundary);
       }
-    // If that doesn't apply, just ignore the field alignment.
+      // If that doesn't apply, just ignore the field alignment.
     } else {
       FieldAlign = 1;
     }
@@ -1811,8 +1799,8 @@
     }
     setDataSize(std::max(getDataSizeInBits(), RoundedFieldSize));
 
-  // For non-zero-width bitfields in ms_struct structs, allocate a new
-  // storage unit if necessary.
+    // For non-zero-width bitfields in ms_struct structs, allocate a new
+    // storage unit if necessary.
   } else if (IsMsStruct && FieldSize) {
     // We should have cleared UnfilledBitsInLastUnit in every case
     // where we changed storage units.
@@ -1848,7 +1836,7 @@
                   Context.toCharUnitsFromBits(UnpackedFieldAlign));
 }
 
-void ItaniumRecordLayoutBuilder::LayoutField(const FieldDecl *D,
+void ItaniumRecordLayoutBuilder::LayoutField(FieldDecl const *D,
                                              bool InsertExtraPadding) {
   auto *FieldClass = D->getType()->getAsCXXRecordDecl();
   bool PotentiallyOverlapping = D->hasAttr<NoUniqueAddressAttr>() && FieldClass;
@@ -1858,7 +1846,7 @@
   CharUnits FieldOffset =
       (IsUnion || IsOverlappingEmptyField) ? CharUnits::Zero() : getDataSize();
 
-  const bool DefaultsToAIXPowerAlignment =
+  bool const DefaultsToAIXPowerAlignment =
       Context.getTargetInfo().defaultsToAIXPowerAlignment();
   bool FoundFirstNonOverlappingEmptyFieldForAIX = false;
   if (DefaultsToAIXPowerAlignment && !HandledFirstNonOverlappingEmptyField) {
@@ -1909,7 +1897,7 @@
 
   if (D->getType()->isIncompleteArrayType()) {
     setDeclInfo(true /* IsIncompleteArrayType */);
-  } else if (const ReferenceType *RT = D->getType()->getAs<ReferenceType>()) {
+  } else if (ReferenceType const *RT = D->getType()->getAs<ReferenceType>()) {
     unsigned AS = Context.getTargetAddressSpace(RT->getPointeeType());
     EffectiveFieldSize = FieldSize = Context.toCharUnitsFromBits(
         Context.getTargetInfo().getPointerWidth(AS));
@@ -1921,7 +1909,7 @@
     // A potentially-overlapping field occupies its dsize or nvsize, whichever
     // is larger.
     if (PotentiallyOverlapping) {
-      const ASTRecordLayout &Layout = Context.getASTRecordLayout(FieldClass);
+      ASTRecordLayout const &Layout = Context.getASTRecordLayout(FieldClass);
       EffectiveFieldSize =
           std::max(Layout.getNonVirtualSize(), Layout.getDataSize());
     }
@@ -1933,7 +1921,7 @@
       // Resolve all typedefs down to their base type and round up the field
       // alignment if necessary.
       QualType T = Context.getBaseElementType(D->getType());
-      if (const BuiltinType *BTy = T->getAs<BuiltinType>()) {
+      if (BuiltinType const *BTy = T->getAs<BuiltinType>()) {
         CharUnits TypeSize = Context.getTypeSizeInChars(BTy);
 
         if (!llvm::isPowerOf2_64(TypeSize.getQuantity())) {
@@ -1993,7 +1981,7 @@
   CharUnits PreferredAlign = FieldAlign;
   if (DefaultsToAIXPowerAlignment && !alignedAttrCanDecreaseAIXAlignment() &&
       (FoundFirstNonOverlappingEmptyFieldForAIX || IsNaturalAlign)) {
-    auto performBuiltinTypeAlignmentUpgrade = [&](const BuiltinType *BTy) {
+    auto performBuiltinTypeAlignmentUpgrade = [&](BuiltinType const *BTy) {
       if (BTy->getKind() == BuiltinType::Double ||
           BTy->getKind() == BuiltinType::LongDouble) {
         assert(PreferredAlign == CharUnits::fromQuantity(4) &&
@@ -2002,16 +1990,16 @@
       }
     };
 
-    const Type *BaseTy = D->getType()->getBaseElementTypeUnsafe();
-    if (const ComplexType *CTy = BaseTy->getAs<ComplexType>()) {
+    Type const *BaseTy = D->getType()->getBaseElementTypeUnsafe();
+    if (ComplexType const *CTy = BaseTy->getAs<ComplexType>()) {
       performBuiltinTypeAlignmentUpgrade(
           CTy->getElementType()->castAs<BuiltinType>());
-    } else if (const BuiltinType *BTy = BaseTy->getAs<BuiltinType>()) {
+    } else if (BuiltinType const *BTy = BaseTy->getAs<BuiltinType>()) {
       performBuiltinTypeAlignmentUpgrade(BTy);
-    } else if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
-      const RecordDecl *RD = RT->getDecl();
+    } else if (RecordType const *RT = BaseTy->getAs<RecordType>()) {
+      RecordDecl const *RD = RT->getDecl();
       assert(RD && "Expected non-null RecordDecl.");
-      const ASTRecordLayout &FieldRecord = Context.getASTRecordLayout(RD);
+      ASTRecordLayout const &FieldRecord = Context.getASTRecordLayout(RD);
       PreferredAlign = FieldRecord.getPreferredAlignment();
     }
   }
@@ -2107,17 +2095,16 @@
   UpdateAlignment(FieldAlign, UnpackedFieldAlign, PreferredAlign);
 }
 
-void ItaniumRecordLayoutBuilder::FinishLayout(const NamedDecl *D) {
+void ItaniumRecordLayoutBuilder::FinishLayout(NamedDecl const *D) {
   // In C++, records cannot be of size 0.
   if (Context.getLangOpts().CPlusPlus && getSizeInBits() == 0) {
-    if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
+    if (CXXRecordDecl const *RD = dyn_cast<CXXRecordDecl>(D)) {
       // Compatibility with gcc requires a class (pod or non-pod)
       // which is not empty but of size 0; such as having fields of
       // array of zero-length, remains of Size 0
       if (RD->isEmpty())
         setSize(CharUnits::One());
-    }
-    else
+    } else
       setSize(CharUnits::One());
   }
 
@@ -2154,7 +2141,7 @@
   setSize(RoundedSize);
 
   unsigned CharBitNum = Context.getTargetInfo().getCharWidth();
-  if (const RecordDecl *RD = dyn_cast<RecordDecl>(D)) {
+  if (RecordDecl const *RD = dyn_cast<RecordDecl>(D)) {
     // Warn if padding was introduced to the struct/class/union.
     if (getSizeInBits() > UnpaddedSize) {
       unsigned PadSize = getSizeInBits() - UnpaddedSize;
@@ -2164,8 +2151,7 @@
         InBits = false;
       }
       Diag(RD->getLocation(), diag::warn_padded_struct_size)
-          << Context.getTypeDeclType(RD)
-          << PadSize
+          << Context.getTypeDeclType(RD) << PadSize
           << (InBits ? 1 : 0); // (byte|bit)
     }
 
@@ -2207,7 +2193,7 @@
 }
 
 uint64_t
-ItaniumRecordLayoutBuilder::updateExternalFieldOffset(const FieldDecl *Field,
+ItaniumRecordLayoutBuilder::updateExternalFieldOffset(FieldDecl const *Field,
                                                       uint64_t ComputedOffset) {
   uint64_t ExternalFieldOffset = External.getExternalFieldOffset(Field);
 
@@ -2230,16 +2216,20 @@
 /// \returns diagnostic %select index.
 static unsigned getPaddingDiagFromTagKind(TagTypeKind Tag) {
   switch (Tag) {
-  case TTK_Struct: return 0;
-  case TTK_Interface: return 1;
-  case TTK_Class: return 2;
-  default: llvm_unreachable("Invalid tag kind for field padding diagnostic!");
+  case TTK_Struct:
+    return 0;
+  case TTK_Interface:
+    return 1;
+  case TTK_Class:
+    return 2;
+  default:
+    llvm_unreachable("Invalid tag kind for field padding diagnostic!");
   }
 }
 
 void ItaniumRecordLayoutBuilder::CheckFieldPadding(
     uint64_t Offset, uint64_t UnpaddedOffset, uint64_t UnpackedOffset,
-    unsigned UnpackedAlign, bool isPacked, const FieldDecl *D) {
+    unsigned UnpackedAlign, bool isPacked, FieldDecl const *D) {
   // We let objc ivars without warning, objc interfaces generally are not used
   // for padding tricks.
   if (isa<ObjCIvarDecl>(D))
@@ -2263,24 +2253,22 @@
     if (D->getIdentifier())
       Diag(D->getLocation(), diag::warn_padded_struct_field)
           << getPaddingDiagFromTagKind(D->getParent()->getTagKind())
-          << Context.getTypeDeclType(D->getParent())
-          << PadSize
+          << Context.getTypeDeclType(D->getParent()) << PadSize
           << (InBits ? 1 : 0) // (byte|bit)
           << D->getIdentifier();
     else
       Diag(D->getLocation(), diag::warn_padded_struct_anon_field)
           << getPaddingDiagFromTagKind(D->getParent()->getTagKind())
-          << Context.getTypeDeclType(D->getParent())
-          << PadSize
+          << Context.getTypeDeclType(D->getParent()) << PadSize
           << (InBits ? 1 : 0); // (byte|bit)
- }
- if (isPacked && Offset != UnpackedOffset) {
-   HasPackedField = true;
- }
+  }
+  if (isPacked && Offset != UnpackedOffset) {
+    HasPackedField = true;
+  }
 }
 
-static const CXXMethodDecl *computeKeyFunction(ASTContext &Context,
-                                               const CXXRecordDecl *RD) {
+static CXXMethodDecl const *computeKeyFunction(ASTContext &Context,
+                                               CXXRecordDecl const *RD) {
   // If a class isn't polymorphic it doesn't have a key function.
   if (!RD->isPolymorphic())
     return nullptr;
@@ -2300,9 +2288,9 @@
     return nullptr;
 
   bool allowInlineFunctions =
-    Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline();
+      Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline();
 
-  for (const CXXMethodDecl *MD : RD->methods()) {
+  for (CXXMethodDecl const *MD : RD->methods()) {
     if (!MD->isVirtual())
       continue;
 
@@ -2326,7 +2314,7 @@
 
     // In certain ABIs, ignore functions with out-of-line inline definitions.
     if (!allowInlineFunctions) {
-      const FunctionDecl *Def;
+      FunctionDecl const *Def;
       if (MD->hasBody(Def) && Def->isInlineSpecified())
         continue;
     }
@@ -2368,7 +2356,7 @@
 /// Does the target C++ ABI require us to skip over the tail-padding
 /// of the given class (considering it as a base class) when allocating
 /// objects?
-static bool mustSkipTailPadding(TargetCXXABI ABI, const CXXRecordDecl *RD) {
+static bool mustSkipTailPadding(TargetCXXABI ABI, CXXRecordDecl const *RD) {
   switch (ABI.getTailPaddingUseRules()) {
   case TargetCXXABI::AlwaysUseTailPadding:
     return false;
@@ -2407,7 +2395,7 @@
   llvm_unreachable("bad tail-padding use kind");
 }
 
-static bool isMsLayout(const ASTContext &Context) {
+static bool isMsLayout(ASTContext const &Context) {
   return Context.getTargetInfo().getCXXABI().isMicrosoft();
 }
 
@@ -2507,44 +2495,46 @@
     CharUnits Size;
     CharUnits Alignment;
   };
-  typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;
-  MicrosoftRecordLayoutBuilder(const ASTContext &Context) : Context(Context) {}
+  typedef llvm::DenseMap<CXXRecordDecl const *, CharUnits> BaseOffsetsMapTy;
+  MicrosoftRecordLayoutBuilder(ASTContext const &Context) : Context(Context) {}
+
 private:
-  MicrosoftRecordLayoutBuilder(const MicrosoftRecordLayoutBuilder &) = delete;
-  void operator=(const MicrosoftRecordLayoutBuilder &) = delete;
+  MicrosoftRecordLayoutBuilder(MicrosoftRecordLayoutBuilder const &) = delete;
+  void operator=(MicrosoftRecordLayoutBuilder const &) = delete;
+
 public:
-  void layout(const RecordDecl *RD);
-  void cxxLayout(const CXXRecordDecl *RD);
+  void layout(RecordDecl const *RD);
+  void cxxLayout(CXXRecordDecl const *RD);
   /// Initializes size and alignment and honors some flags.
-  void initializeLayout(const RecordDecl *RD);
+  void initializeLayout(RecordDecl const *RD);
   /// Initialized C++ layout, compute alignment and virtual alignment and
   /// existence of vfptrs and vbptrs.  Alignment is needed before the vfptr is
   /// laid out.
-  void initializeCXXLayout(const CXXRecordDecl *RD);
-  void layoutNonVirtualBases(const CXXRecordDecl *RD);
-  void layoutNonVirtualBase(const CXXRecordDecl *RD,
-                            const CXXRecordDecl *BaseDecl,
-                            const ASTRecordLayout &BaseLayout,
-                            const ASTRecordLayout *&PreviousBaseLayout);
-  void injectVFPtr(const CXXRecordDecl *RD);
-  void injectVBPtr(const CXXRecordDecl *RD);
+  void initializeCXXLayout(CXXRecordDecl const *RD);
+  void layoutNonVirtualBases(CXXRecordDecl const *RD);
+  void layoutNonVirtualBase(CXXRecordDecl const *RD,
+                            CXXRecordDecl const *BaseDecl,
+                            ASTRecordLayout const &BaseLayout,
+                            ASTRecordLayout const *&PreviousBaseLayout);
+  void injectVFPtr(CXXRecordDecl const *RD);
+  void injectVBPtr(CXXRecordDecl const *RD);
   /// Lays out the fields of the record.  Also rounds size up to
   /// alignment.
-  void layoutFields(const RecordDecl *RD);
-  void layoutField(const FieldDecl *FD);
-  void layoutBitField(const FieldDecl *FD);
+  void layoutFields(RecordDecl const *RD);
+  void layoutField(FieldDecl const *FD);
+  void layoutBitField(FieldDecl const *FD);
   /// Lays out a single zero-width bit-field in the record and handles
   /// special cases associated with zero-width bit-fields.
-  void layoutZeroWidthBitField(const FieldDecl *FD);
-  void layoutVirtualBases(const CXXRecordDecl *RD);
-  void finalizeLayout(const RecordDecl *RD);
+  void layoutZeroWidthBitField(FieldDecl const *FD);
+  void layoutVirtualBases(CXXRecordDecl const *RD);
+  void finalizeLayout(RecordDecl const *RD);
   /// Gets the size and alignment of a base taking pragma pack and
   /// __declspec(align) into account.
-  ElementInfo getAdjustedElementInfo(const ASTRecordLayout &Layout);
+  ElementInfo getAdjustedElementInfo(ASTRecordLayout const &Layout);
   /// Gets the size and alignment of a field taking pragma  pack and
   /// __declspec(align) into account.  It also updates RequiredAlignment as a
   /// side effect because it is most convenient to do so here.
-  ElementInfo getAdjustedElementInfo(const FieldDecl *FD);
+  ElementInfo getAdjustedElementInfo(FieldDecl const *FD);
   /// Places a field at an offset in CharUnits.
   void placeFieldAtOffset(CharUnits FieldOffset) {
     FieldOffsets.push_back(Context.toBits(FieldOffset));
@@ -2555,9 +2545,9 @@
   }
   /// Compute the set of virtual bases for which vtordisps are required.
   void computeVtorDispSet(
-      llvm::SmallPtrSetImpl<const CXXRecordDecl *> &HasVtorDispSet,
-      const CXXRecordDecl *RD) const;
-  const ASTContext &Context;
+      llvm::SmallPtrSetImpl<CXXRecordDecl const *> &HasVtorDispSet,
+      CXXRecordDecl const *RD) const;
+  ASTContext const &Context;
   /// The size of the record being laid out.
   CharUnits Size;
   /// The non-virtual size of the record layout.
@@ -2582,9 +2572,9 @@
   /// The size and alignment info of a pointer.
   ElementInfo PointerInfo;
   /// The primary base class (if one exists).
-  const CXXRecordDecl *PrimaryBase;
+  CXXRecordDecl const *PrimaryBase;
   /// The class we share our vb-pointer with.
-  const CXXRecordDecl *SharedVBPtrBase;
+  CXXRecordDecl const *SharedVBPtrBase;
   /// The collection of field offsets.
   SmallVector<uint64_t, 16> FieldOffsets;
   /// Base classes and their offsets in the record.
@@ -2622,7 +2612,7 @@
 
 MicrosoftRecordLayoutBuilder::ElementInfo
 MicrosoftRecordLayoutBuilder::getAdjustedElementInfo(
-    const ASTRecordLayout &Layout) {
+    ASTRecordLayout const &Layout) {
   ElementInfo Info;
   Info.Alignment = Layout.getAlignment();
   // Respect pragma pack.
@@ -2634,15 +2624,15 @@
   // the alignment in the case of pragam pack.  Note that the required alignment
   // doesn't actually apply to the struct alignment at this point.
   Alignment = std::max(Alignment, Info.Alignment);
-  RequiredAlignment = std::max(RequiredAlignment, Layout.getRequiredAlignment());
+  RequiredAlignment =
+      std::max(RequiredAlignment, Layout.getRequiredAlignment());
   Info.Alignment = std::max(Info.Alignment, Layout.getRequiredAlignment());
   Info.Size = Layout.getNonVirtualSize();
   return Info;
 }
 
 MicrosoftRecordLayoutBuilder::ElementInfo
-MicrosoftRecordLayoutBuilder::getAdjustedElementInfo(
-    const FieldDecl *FD) {
+MicrosoftRecordLayoutBuilder::getAdjustedElementInfo(FieldDecl const *FD) {
   // Get the alignment of the field type's natural alignment, ignore any
   // alignment attributes.
   auto TInfo =
@@ -2665,8 +2655,8 @@
             FD->getType()->getBaseElementTypeUnsafe()->getAs<RecordType>()) {
       auto const &Layout = Context.getASTRecordLayout(RT->getDecl());
       EndsWithZeroSizedObject = Layout.endsWithZeroSizedObject();
-      FieldRequiredAlignment = std::max(FieldRequiredAlignment,
-                                        Layout.getRequiredAlignment());
+      FieldRequiredAlignment =
+          std::max(FieldRequiredAlignment, Layout.getRequiredAlignment());
     }
     // Capture required alignment as a side-effect.
     RequiredAlignment = std::max(RequiredAlignment, FieldRequiredAlignment);
@@ -2680,7 +2670,7 @@
   return Info;
 }
 
-void MicrosoftRecordLayoutBuilder::layout(const RecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::layout(RecordDecl const *RD) {
   // For C record layout, zero-sized records always have size 4.
   MinEmptyStructSize = CharUnits::fromQuantity(4);
   initializeLayout(RD);
@@ -2691,7 +2681,7 @@
   finalizeLayout(RD);
 }
 
-void MicrosoftRecordLayoutBuilder::cxxLayout(const CXXRecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::cxxLayout(CXXRecordDecl const *RD) {
   // The C++ standard says that empty structs have size 1.
   MinEmptyStructSize = CharUnits::One();
   initializeLayout(RD);
@@ -2714,7 +2704,7 @@
   finalizeLayout(RD);
 }
 
-void MicrosoftRecordLayoutBuilder::initializeLayout(const RecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::initializeLayout(RecordDecl const *RD) {
   IsUnion = RD->isUnion();
   Size = CharUnits::Zero();
   Alignment = CharUnits::One();
@@ -2728,10 +2718,11 @@
   MaxFieldAlignment = CharUnits::Zero();
   // Honor the default struct packing maximum alignment flag.
   if (unsigned DefaultMaxFieldAlignment = Context.getLangOpts().PackStruct)
-      MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment);
+    MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment);
   // Honor the packing attribute.  The MS-ABI ignores pragma pack if its larger
   // than the pointer size.
-  if (const MaxFieldAlignmentAttr *MFAA = RD->getAttr<MaxFieldAlignmentAttr>()){
+  if (MaxFieldAlignmentAttr const *MFAA =
+          RD->getAttr<MaxFieldAlignmentAttr>()) {
     unsigned PackedAlignment = MFAA->getAlignment();
     if (PackedAlignment <= Context.getTargetInfo().getPointerWidth(0))
       MaxFieldAlignment = Context.toCharUnitsFromBits(PackedAlignment);
@@ -2748,8 +2739,8 @@
         External.BaseOffsets, External.VirtualBaseOffsets);
 }
 
-void
-MicrosoftRecordLayoutBuilder::initializeCXXLayout(const CXXRecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::initializeCXXLayout(
+    CXXRecordDecl const *RD) {
   EndsWithZeroSizedObject = false;
   LeadsWithZeroSizedBase = false;
   HasOwnVFPtr = false;
@@ -2767,21 +2758,21 @@
     PointerInfo.Alignment = std::min(PointerInfo.Alignment, MaxFieldAlignment);
 }
 
-void
-MicrosoftRecordLayoutBuilder::layoutNonVirtualBases(const CXXRecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::layoutNonVirtualBases(
+    CXXRecordDecl const *RD) {
   // The MS-ABI lays out all bases that contain leading vfptrs before it lays
   // out any bases that do not contain vfptrs.  We implement this as two passes
   // over the bases.  This approach guarantees that the primary base is laid out
   // first.  We use these passes to calculate some additional aggregated
   // information about the bases, such as required alignment and the presence of
   // zero sized members.
-  const ASTRecordLayout *PreviousBaseLayout = nullptr;
+  ASTRecordLayout const *PreviousBaseLayout = nullptr;
   bool HasPolymorphicBaseClass = false;
   // Iterate through the bases and lay out the non-virtual ones.
-  for (const CXXBaseSpecifier &Base : RD->bases()) {
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+  for (CXXBaseSpecifier const &Base : RD->bases()) {
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
     HasPolymorphicBaseClass |= BaseDecl->isPolymorphic();
-    const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl);
+    ASTRecordLayout const &BaseLayout = Context.getASTRecordLayout(BaseDecl);
     // Mark and skip virtual bases.
     if (Base.isVirtual()) {
       HasVBPtr = true;
@@ -2825,11 +2816,11 @@
   // itself lead with a zero-sized object, something we track.
   bool CheckLeadingLayout = !PrimaryBase;
   // Iterate through the bases and lay out the non-virtual ones.
-  for (const CXXBaseSpecifier &Base : RD->bases()) {
+  for (CXXBaseSpecifier const &Base : RD->bases()) {
     if (Base.isVirtual())
       continue;
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
-    const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl);
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+    ASTRecordLayout const &BaseLayout = Context.getASTRecordLayout(BaseDecl);
     // Only lay out bases without extendable VFPtrs on the second pass.
     if (BaseLayout.hasExtendableVFPtr()) {
       VBPtrOffset = Bases[BaseDecl] + BaseLayout.getNonVirtualSize();
@@ -2849,12 +2840,12 @@
   if (!HasVBPtr)
     VBPtrOffset = CharUnits::fromQuantity(-1);
   else if (SharedVBPtrBase) {
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(SharedVBPtrBase);
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(SharedVBPtrBase);
     VBPtrOffset = Bases[SharedVBPtrBase] + Layout.getVBPtrOffset();
   }
 }
 
-static bool recordUsesEBO(const RecordDecl *RD) {
+static bool recordUsesEBO(RecordDecl const *RD) {
   if (!isa<CXXRecordDecl>(RD))
     return false;
   if (RD->hasAttr<EmptyBasesAttr>())
@@ -2870,10 +2861,9 @@
 }
 
 void MicrosoftRecordLayoutBuilder::layoutNonVirtualBase(
-    const CXXRecordDecl *RD,
-    const CXXRecordDecl *BaseDecl,
-    const ASTRecordLayout &BaseLayout,
-    const ASTRecordLayout *&PreviousBaseLayout) {
+    CXXRecordDecl const *RD, CXXRecordDecl const *BaseDecl,
+    ASTRecordLayout const &BaseLayout,
+    ASTRecordLayout const *&PreviousBaseLayout) {
   // Insert padding between two bases if the left first one is zero sized or
   // contains a zero sized subobject and the right is zero sized or one leads
   // with a zero sized base.
@@ -2908,13 +2898,13 @@
   PreviousBaseLayout = &BaseLayout;
 }
 
-void MicrosoftRecordLayoutBuilder::layoutFields(const RecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::layoutFields(RecordDecl const *RD) {
   LastFieldIsNonZeroWidthBitfield = false;
-  for (const FieldDecl *Field : RD->fields())
+  for (FieldDecl const *Field : RD->fields())
     layoutField(Field);
 }
 
-void MicrosoftRecordLayoutBuilder::layoutField(const FieldDecl *FD) {
+void MicrosoftRecordLayoutBuilder::layoutField(FieldDecl const *FD) {
   if (FD->isBitField()) {
     layoutBitField(FD);
     return;
@@ -2934,7 +2924,7 @@
   Size = std::max(Size, FieldOffset + Info.Size);
 }
 
-void MicrosoftRecordLayoutBuilder::layoutBitField(const FieldDecl *FD) {
+void MicrosoftRecordLayoutBuilder::layoutBitField(FieldDecl const *FD) {
   unsigned Width = FD->getBitWidthValue(Context);
   if (Width == 0) {
     layoutZeroWidthBitField(FD);
@@ -2978,8 +2968,8 @@
   }
 }
 
-void
-MicrosoftRecordLayoutBuilder::layoutZeroWidthBitField(const FieldDecl *FD) {
+void MicrosoftRecordLayoutBuilder::layoutZeroWidthBitField(
+    FieldDecl const *FD) {
   // Zero-width bitfields are ignored unless they follow a non-zero-width
   // bitfield.
   if (!LastFieldIsNonZeroWidthBitfield) {
@@ -3003,7 +2993,7 @@
   }
 }
 
-void MicrosoftRecordLayoutBuilder::injectVBPtr(const CXXRecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::injectVBPtr(CXXRecordDecl const *RD) {
   if (!HasVBPtr || SharedVBPtrBase)
     return;
   // Inject the VBPointer at the injection site.
@@ -3033,7 +3023,7 @@
       Base.second += Offset;
 }
 
-void MicrosoftRecordLayoutBuilder::injectVFPtr(const CXXRecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::injectVFPtr(CXXRecordDecl const *RD) {
   if (!HasOwnVFPtr)
     return;
   // Make sure that the amount we push the struct back by is a multiple of the
@@ -3064,7 +3054,7 @@
     Base.second += Offset;
 }
 
-void MicrosoftRecordLayoutBuilder::layoutVirtualBases(const CXXRecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::layoutVirtualBases(CXXRecordDecl const *RD) {
   if (!HasVBPtr)
     return;
   // Vtordisps are always 4 bytes (even in 64-bit mode)
@@ -3076,21 +3066,21 @@
   // The alignment of the vtordisp is at least the required alignment of the
   // entire record.  This requirement may be present to support vtordisp
   // injection.
-  for (const CXXBaseSpecifier &VBase : RD->vbases()) {
-    const CXXRecordDecl *BaseDecl = VBase.getType()->getAsCXXRecordDecl();
-    const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl);
+  for (CXXBaseSpecifier const &VBase : RD->vbases()) {
+    CXXRecordDecl const *BaseDecl = VBase.getType()->getAsCXXRecordDecl();
+    ASTRecordLayout const &BaseLayout = Context.getASTRecordLayout(BaseDecl);
     RequiredAlignment =
         std::max(RequiredAlignment, BaseLayout.getRequiredAlignment());
   }
   VtorDispAlignment = std::max(VtorDispAlignment, RequiredAlignment);
   // Compute the vtordisp set.
-  llvm::SmallPtrSet<const CXXRecordDecl *, 2> HasVtorDispSet;
+  llvm::SmallPtrSet<CXXRecordDecl const *, 2> HasVtorDispSet;
   computeVtorDispSet(HasVtorDispSet, RD);
   // Iterate through the virtual bases and lay them out.
-  const ASTRecordLayout *PreviousBaseLayout = nullptr;
-  for (const CXXBaseSpecifier &VBase : RD->vbases()) {
-    const CXXRecordDecl *BaseDecl = VBase.getType()->getAsCXXRecordDecl();
-    const ASTRecordLayout &BaseLayout = Context.getASTRecordLayout(BaseDecl);
+  ASTRecordLayout const *PreviousBaseLayout = nullptr;
+  for (CXXBaseSpecifier const &VBase : RD->vbases()) {
+    CXXRecordDecl const *BaseDecl = VBase.getType()->getAsCXXRecordDecl();
+    ASTRecordLayout const &BaseLayout = Context.getASTRecordLayout(BaseDecl);
     bool HasVtordisp = HasVtorDispSet.count(BaseDecl) > 0;
     // Insert padding between two bases if the left first one is zero sized or
     // contains a zero sized subobject and the right is zero sized or one leads
@@ -3116,14 +3106,14 @@
 
     assert(BaseOffset >= Size && "base offset already allocated");
 
-    VBases.insert(std::make_pair(BaseDecl,
-        ASTRecordLayout::VBaseInfo(BaseOffset, HasVtordisp)));
+    VBases.insert(std::make_pair(
+        BaseDecl, ASTRecordLayout::VBaseInfo(BaseOffset, HasVtordisp)));
     Size = BaseOffset + BaseLayout.getNonVirtualSize();
     PreviousBaseLayout = &BaseLayout;
   }
 }
 
-void MicrosoftRecordLayoutBuilder::finalizeLayout(const RecordDecl *RD) {
+void MicrosoftRecordLayoutBuilder::finalizeLayout(RecordDecl const *RD) {
   // Respect required alignment.  Note that in 32-bit mode Required alignment
   // may be 0 and cause size not to be updated.
   DataSize = Size;
@@ -3157,15 +3147,14 @@
 
 // Recursively walks the non-virtual bases of a class and determines if any of
 // them are in the bases with overridden methods set.
-static bool
-RequiresVtordisp(const llvm::SmallPtrSetImpl<const CXXRecordDecl *> &
-                     BasesWithOverriddenMethods,
-                 const CXXRecordDecl *RD) {
+static bool RequiresVtordisp(llvm::SmallPtrSetImpl<const CXXRecordDecl *> const
+                                 &BasesWithOverriddenMethods,
+                             CXXRecordDecl const *RD) {
   if (BasesWithOverriddenMethods.count(RD))
     return true;
   // If any of a virtual bases non-virtual bases (recursively) requires a
   // vtordisp than so does this virtual base.
-  for (const CXXBaseSpecifier &Base : RD->bases())
+  for (CXXBaseSpecifier const &Base : RD->bases())
     if (!Base.isVirtual() &&
         RequiresVtordisp(BasesWithOverriddenMethods,
                          Base.getType()->getAsCXXRecordDecl()))
@@ -3174,14 +3163,14 @@
 }
 
 void MicrosoftRecordLayoutBuilder::computeVtorDispSet(
-    llvm::SmallPtrSetImpl<const CXXRecordDecl *> &HasVtordispSet,
-    const CXXRecordDecl *RD) const {
+    llvm::SmallPtrSetImpl<CXXRecordDecl const *> &HasVtordispSet,
+    CXXRecordDecl const *RD) const {
   // /vd2 or #pragma vtordisp(2): Always use vtordisps for virtual bases with
   // vftables.
   if (RD->getMSVtorDispMode() == MSVtorDispMode::ForVFTable) {
-    for (const CXXBaseSpecifier &Base : RD->vbases()) {
-      const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
-      const ASTRecordLayout &Layout = Context.getASTRecordLayout(BaseDecl);
+    for (CXXBaseSpecifier const &Base : RD->vbases()) {
+      CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+      ASTRecordLayout const &Layout = Context.getASTRecordLayout(BaseDecl);
       if (Layout.hasExtendableVFPtr())
         HasVtordispSet.insert(BaseDecl);
     }
@@ -3190,10 +3179,10 @@
 
   // If any of our bases need a vtordisp for this type, so do we.  Check our
   // direct bases for vtordisp requirements.
-  for (const CXXBaseSpecifier &Base : RD->bases()) {
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(BaseDecl);
-    for (const auto &bi : Layout.getVBaseOffsetsMap())
+  for (CXXBaseSpecifier const &Base : RD->bases()) {
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(BaseDecl);
+    for (auto const &bi : Layout.getVBaseOffsetsMap())
       if (bi.second.hasVtorDisp())
         HasVtordispSet.insert(bi.first);
   }
@@ -3211,15 +3200,15 @@
   // base in this set will require a vtordisp.  A virtual base that transitively
   // contains one of these bases as a non-virtual base will also require a
   // vtordisp.
-  llvm::SmallPtrSet<const CXXMethodDecl *, 8> Work;
-  llvm::SmallPtrSet<const CXXRecordDecl *, 2> BasesWithOverriddenMethods;
+  llvm::SmallPtrSet<CXXMethodDecl const *, 8> Work;
+  llvm::SmallPtrSet<CXXRecordDecl const *, 2> BasesWithOverriddenMethods;
   // Seed the working set with our non-destructor, non-pure virtual methods.
-  for (const CXXMethodDecl *MD : RD->methods())
+  for (CXXMethodDecl const *MD : RD->methods())
     if (MicrosoftVTableContext::hasVtableSlot(MD) &&
         !isa<CXXDestructorDecl>(MD) && !MD->isPure())
       Work.insert(MD);
   while (!Work.empty()) {
-    const CXXMethodDecl *MD = *Work.begin();
+    CXXMethodDecl const *MD = *Work.begin();
     auto MethodRange = MD->overridden_methods();
     // If a virtual method has no-overrides it lives in its parent's vtable.
     if (MethodRange.begin() == MethodRange.end())
@@ -3231,8 +3220,8 @@
   }
   // For each of our virtual bases, check if it is in the set of overridden
   // bases or if it transitively contains a non-virtual base that is.
-  for (const CXXBaseSpecifier &Base : RD->vbases()) {
-    const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
+  for (CXXBaseSpecifier const &Base : RD->vbases()) {
+    CXXRecordDecl const *BaseDecl = Base.getType()->getAsCXXRecordDecl();
     if (!HasVtordispSet.count(BaseDecl) &&
         RequiresVtordisp(BasesWithOverriddenMethods, BaseDecl))
       HasVtordispSet.insert(BaseDecl);
@@ -3242,15 +3231,15 @@
 /// getASTRecordLayout - Get or compute information about the layout of the
 /// specified record (struct/union/class), which indicates its size and field
 /// position information.
-const ASTRecordLayout &
-ASTContext::getASTRecordLayout(const RecordDecl *D) const {
+ASTRecordLayout const &
+ASTContext::getASTRecordLayout(RecordDecl const *D) const {
   // These asserts test different things.  A record has a definition
   // as soon as we begin to parse the definition.  That definition is
   // not a complete definition (which is what isDefinition() tests)
   // until we *finish* parsing the definition.
 
   if (D->hasExternalLexicalStorage() && !D->getDefinition())
-    getExternalSource()->CompleteType(const_cast<RecordDecl*>(D));
+    getExternalSource()->CompleteType(const_cast<RecordDecl *>(D));
 
   D = D->getDefinition();
   assert(D && "Cannot get layout of forward declarations!");
@@ -3260,14 +3249,15 @@
   // Look up this layout, if already laid out, return what we have.
   // Note that we can't save a reference to the entry because this function
   // is recursive.
-  const ASTRecordLayout *Entry = ASTRecordLayouts[D];
-  if (Entry) return *Entry;
+  ASTRecordLayout const *Entry = ASTRecordLayouts[D];
+  if (Entry)
+    return *Entry;
 
-  const ASTRecordLayout *NewEntry = nullptr;
+  ASTRecordLayout const *NewEntry = nullptr;
 
   if (isMsLayout(*this)) {
     MicrosoftRecordLayoutBuilder Builder(*this);
-    if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
+    if (auto const *RD = dyn_cast<CXXRecordDecl>(D)) {
       Builder.cxxLayout(RD);
       NewEntry = new (*this) ASTRecordLayout(
           *this, Builder.Size, Builder.Alignment, Builder.Alignment,
@@ -3286,7 +3276,7 @@
           Builder.FieldOffsets);
     }
   } else {
-    if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
+    if (auto const *RD = dyn_cast<CXXRecordDecl>(D)) {
       EmptySubobjectMap EmptySubobjects(*this, RD);
       ItaniumRecordLayoutBuilder Builder(*this, &EmptySubobjects);
       Builder.Layout(RD);
@@ -3335,7 +3325,8 @@
   return *NewEntry;
 }
 
-const CXXMethodDecl *ASTContext::getCurrentKeyFunction(const CXXRecordDecl *RD) {
+CXXMethodDecl const *
+ASTContext::getCurrentKeyFunction(CXXRecordDecl const *RD) {
   if (!getTargetInfo().getCXXABI().hasKeyFunctions())
     return nullptr;
 
@@ -3348,28 +3339,29 @@
   //  2) 'get' on the LazyDeclPtr might also trigger deserialization and
   //     invalidate the LazyDeclPtr within the map itself
   LazyDeclPtr Entry = KeyFunctions[RD];
-  const Decl *Result =
+  Decl const *Result =
       Entry ? Entry.get(getExternalSource()) : computeKeyFunction(*this, RD);
 
   // Store it back if it changed.
   if (Entry.isOffset() || Entry.isValid() != bool(Result))
-    KeyFunctions[RD] = const_cast<Decl*>(Result);
+    KeyFunctions[RD] = const_cast<Decl *>(Result);
 
   return cast_or_null<CXXMethodDecl>(Result);
 }
 
-void ASTContext::setNonKeyFunction(const CXXMethodDecl *Method) {
+void ASTContext::setNonKeyFunction(CXXMethodDecl const *Method) {
   assert(Method == Method->getFirstDecl() &&
          "not working with method declaration from class definition");
 
   // Look up the cache entry.  Since we're working with the first
   // declaration, its parent must be the class definition, which is
   // the correct key for the KeyFunctions hash.
-  const auto &Map = KeyFunctions;
+  auto const &Map = KeyFunctions;
   auto I = Map.find(Method->getParent());
 
   // If it's not cached, there's nothing to do.
-  if (I == Map.end()) return;
+  if (I == Map.end())
+    return;
 
   // If it is cached, check whether it's the target method, and if so,
   // remove it from the cache. Note, the call to 'get' might invalidate
@@ -3381,30 +3373,30 @@
   }
 }
 
-static uint64_t getFieldOffset(const ASTContext &C, const FieldDecl *FD) {
-  const ASTRecordLayout &Layout = C.getASTRecordLayout(FD->getParent());
+static uint64_t getFieldOffset(ASTContext const &C, FieldDecl const *FD) {
+  ASTRecordLayout const &Layout = C.getASTRecordLayout(FD->getParent());
   return Layout.getFieldOffset(FD->getFieldIndex());
 }
 
-uint64_t ASTContext::getFieldOffset(const ValueDecl *VD) const {
+uint64_t ASTContext::getFieldOffset(ValueDecl const *VD) const {
   uint64_t OffsetInBits;
-  if (const FieldDecl *FD = dyn_cast<FieldDecl>(VD)) {
+  if (FieldDecl const *FD = dyn_cast<FieldDecl>(VD)) {
     OffsetInBits = ::getFieldOffset(*this, FD);
   } else {
-    const IndirectFieldDecl *IFD = cast<IndirectFieldDecl>(VD);
+    IndirectFieldDecl const *IFD = cast<IndirectFieldDecl>(VD);
 
     OffsetInBits = 0;
-    for (const NamedDecl *ND : IFD->chain())
+    for (NamedDecl const *ND : IFD->chain())
       OffsetInBits += ::getFieldOffset(*this, cast<FieldDecl>(ND));
   }
 
   return OffsetInBits;
 }
 
-uint64_t ASTContext::lookupFieldBitOffset(const ObjCInterfaceDecl *OID,
-                                          const ObjCImplementationDecl *ID,
-                                          const ObjCIvarDecl *Ivar) const {
-  const ObjCInterfaceDecl *Container = Ivar->getContainingInterface();
+uint64_t ASTContext::lookupFieldBitOffset(ObjCInterfaceDecl const *OID,
+                                          ObjCImplementationDecl const *ID,
+                                          ObjCIvarDecl const *Ivar) const {
+  ObjCInterfaceDecl const *Container = Ivar->getContainingInterface();
 
   // FIXME: We should eliminate the need to have ObjCImplementationDecl passed
   // in here; it should never be necessary because that should be the lexical
@@ -3412,7 +3404,7 @@
 
   // If we know have an implementation (and the ivar is in it) then
   // look up in the implementation layout.
-  const ASTRecordLayout *RL;
+  ASTRecordLayout const *RL;
   if (ID && declaresSameEntity(ID->getClassInterface(), Container))
     RL = &getASTObjCImplementationLayout(ID);
   else
@@ -3425,8 +3417,8 @@
   // directly.
   unsigned Index = 0;
 
-  for (const ObjCIvarDecl *IVD = Container->all_declared_ivar_begin();
-       IVD; IVD = IVD->getNextIvar()) {
+  for (ObjCIvarDecl const *IVD = Container->all_declared_ivar_begin(); IVD;
+       IVD = IVD->getNextIvar()) {
     if (Ivar == IVD)
       break;
     ++Index;
@@ -3441,20 +3433,20 @@
 ///
 /// \param Impl - If given, also include the layout of the interface's
 /// implementation. This may differ by including synthesized ivars.
-const ASTRecordLayout &
-ASTContext::getObjCLayout(const ObjCInterfaceDecl *D,
-                          const ObjCImplementationDecl *Impl) const {
+ASTRecordLayout const &
+ASTContext::getObjCLayout(ObjCInterfaceDecl const *D,
+                          ObjCImplementationDecl const *Impl) const {
   // Retrieve the definition
   if (D->hasExternalLexicalStorage() && !D->getDefinition())
-    getExternalSource()->CompleteType(const_cast<ObjCInterfaceDecl*>(D));
+    getExternalSource()->CompleteType(const_cast<ObjCInterfaceDecl *>(D));
   D = D->getDefinition();
   assert(D && !D->isInvalidDecl() && D->isThisDeclarationADefinition() &&
          "Invalid interface decl!");
 
   // Look up this layout, if already laid out, return what we have.
-  const ObjCContainerDecl *Key =
-    Impl ? (const ObjCContainerDecl*) Impl : (const ObjCContainerDecl*) D;
-  if (const ASTRecordLayout *Entry = ObjCLayouts[Key])
+  ObjCContainerDecl const *Key =
+      Impl ? (ObjCContainerDecl const *)Impl : (ObjCContainerDecl const *)D;
+  if (ASTRecordLayout const *Entry = ObjCLayouts[Key])
     return *Entry;
 
   // Add in synthesized ivar count if laying out an implementation.
@@ -3471,7 +3463,7 @@
   ItaniumRecordLayoutBuilder Builder(*this, /*EmptySubobjects=*/nullptr);
   Builder.Layout(D);
 
-  const ASTRecordLayout *NewEntry = new (*this) ASTRecordLayout(
+  ASTRecordLayout const *NewEntry = new (*this) ASTRecordLayout(
       *this, Builder.getSize(), Builder.Alignment, Builder.PreferredAlignment,
       Builder.UnadjustedAlignment,
       /*RequiredAlignment : used by MS-ABI)*/
@@ -3482,8 +3474,8 @@
   return *NewEntry;
 }
 
-static void PrintOffset(raw_ostream &OS,
-                        CharUnits Offset, unsigned IndentLevel) {
+static void PrintOffset(raw_ostream &OS, CharUnits Offset,
+                        unsigned IndentLevel) {
   OS << llvm::format("%10" PRId64 " | ", (int64_t)Offset.getQuantity());
   OS.indent(IndentLevel * 2);
 }
@@ -3511,18 +3503,15 @@
   OS.indent(IndentLevel * 2);
 }
 
-static void DumpRecordLayout(raw_ostream &OS, const RecordDecl *RD,
-                             const ASTContext &C,
-                             CharUnits Offset,
-                             unsigned IndentLevel,
-                             const char* Description,
-                             bool PrintSizeInfo,
-                             bool IncludeVirtualBases) {
-  const ASTRecordLayout &Layout = C.getASTRecordLayout(RD);
+static void DumpRecordLayout(raw_ostream &OS, RecordDecl const *RD,
+                             ASTContext const &C, CharUnits Offset,
+                             unsigned IndentLevel, char const *Description,
+                             bool PrintSizeInfo, bool IncludeVirtualBases) {
+  ASTRecordLayout const &Layout = C.getASTRecordLayout(RD);
   auto CXXRD = dyn_cast<CXXRecordDecl>(RD);
 
   PrintOffset(OS, Offset, IndentLevel);
-  OS << C.getTypeDeclType(const_cast<RecordDecl*>(RD)).getAsString();
+  OS << C.getTypeDeclType(const_cast<RecordDecl *>(RD)).getAsString();
   if (Description)
     OS << ' ' << Description;
   if (CXXRD && CXXRD->isEmpty())
@@ -3533,7 +3522,7 @@
 
   // Dump bases.
   if (CXXRD) {
-    const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
+    CXXRecordDecl const *PrimaryBase = Layout.getPrimaryBase();
     bool HasOwnVFPtr = Layout.hasOwnVFPtr();
     bool HasOwnVBPtr = Layout.hasOwnVBPtr();
 
@@ -3548,8 +3537,8 @@
     }
 
     // Collect nvbases.
-    SmallVector<const CXXRecordDecl *, 4> Bases;
-    for (const CXXBaseSpecifier &Base : CXXRD->bases()) {
+    SmallVector<CXXRecordDecl const *, 4> Bases;
+    for (CXXBaseSpecifier const &Base : CXXRD->bases()) {
       assert(!Base.getType()->isDependentType() &&
              "Cannot layout class with dependent bases.");
       if (!Base.isVirtual())
@@ -3558,12 +3547,12 @@
 
     // Sort nvbases by offset.
     llvm::stable_sort(
-        Bases, [&](const CXXRecordDecl *L, const CXXRecordDecl *R) {
+        Bases, [&](CXXRecordDecl const *L, CXXRecordDecl const *R) {
           return Layout.getBaseClassOffset(L) < Layout.getBaseClassOffset(R);
         });
 
     // Dump (non-virtual) bases
-    for (const CXXRecordDecl *Base : Bases) {
+    for (CXXRecordDecl const *Base : Bases) {
       CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base);
       DumpRecordLayout(OS, Base, C, BaseOffset, IndentLevel,
                        Base == PrimaryBase ? "(primary base)" : "(base)",
@@ -3580,12 +3569,12 @@
 
   // Dump fields.
   uint64_t FieldNo = 0;
-  for (RecordDecl::field_iterator I = RD->field_begin(),
-         E = RD->field_end(); I != E; ++I, ++FieldNo) {
-    const FieldDecl &Field = **I;
+  for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
+       I != E; ++I, ++FieldNo) {
+    FieldDecl const &Field = **I;
     uint64_t LocalFieldOffsetInBits = Layout.getFieldOffset(FieldNo);
     CharUnits FieldOffset =
-      Offset + C.toCharUnitsFromBits(LocalFieldOffsetInBits);
+        Offset + C.toCharUnitsFromBits(LocalFieldOffsetInBits);
 
     // Recursively dump fields of record type.
     if (auto RT = Field.getType()->getAs<RecordType>()) {
@@ -3604,7 +3593,7 @@
     } else {
       PrintOffset(OS, FieldOffset, IndentLevel);
     }
-    const QualType &FieldType = C.getLangOpts().DumpRecordLayoutsCanonical
+    QualType const &FieldType = C.getLangOpts().DumpRecordLayoutsCanonical
                                     ? Field.getType().getCanonicalType()
                                     : Field.getType();
     OS << FieldType.getAsString() << ' ' << Field << '\n';
@@ -3612,12 +3601,12 @@
 
   // Dump virtual bases.
   if (CXXRD && IncludeVirtualBases) {
-    const ASTRecordLayout::VBaseOffsetsMapTy &VtorDisps =
-      Layout.getVBaseOffsetsMap();
+    ASTRecordLayout::VBaseOffsetsMapTy const &VtorDisps =
+        Layout.getVBaseOffsetsMap();
 
-    for (const CXXBaseSpecifier &Base : CXXRD->vbases()) {
+    for (CXXBaseSpecifier const &Base : CXXRD->vbases()) {
       assert(Base.isVirtual() && "Found non-virtual class!");
-      const CXXRecordDecl *VBase = Base.getType()->getAsCXXRecordDecl();
+      CXXRecordDecl const *VBase = Base.getType()->getAsCXXRecordDecl();
 
       CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBase);
 
@@ -3627,14 +3616,16 @@
       }
 
       DumpRecordLayout(OS, VBase, C, VBaseOffset, IndentLevel,
-                       VBase == Layout.getPrimaryBase() ?
-                         "(primary virtual base)" : "(virtual base)",
+                       VBase == Layout.getPrimaryBase()
+                           ? "(primary virtual base)"
+                           : "(virtual base)",
                        /*PrintSizeInfo=*/false,
                        /*IncludeVirtualBases=*/false);
     }
   }
 
-  if (!PrintSizeInfo) return;
+  if (!PrintSizeInfo)
+    return;
 
   PrintIndentNoOffset(OS, IndentLevel - 1);
   OS << "[sizeof=" << Layout.getSize().getQuantity();
@@ -3656,7 +3647,7 @@
   OS << "]\n";
 }
 
-void ASTContext::DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS,
+void ASTContext::DumpRecordLayout(RecordDecl const *RD, raw_ostream &OS,
                                   bool Simple) const {
   if (!Simple) {
     ::DumpRecordLayout(OS, RD, *this, CharUnits(), 0, nullptr,
@@ -3672,7 +3663,7 @@
   // you like as long as you also update the rudimentary parser for it
   // in libFrontend.
 
-  const ASTRecordLayout &Info = getASTRecordLayout(RD);
+  ASTRecordLayout const &Info = getASTRecordLayout(RD);
   OS << "Type: " << getTypeDeclType(RD).getAsString() << "\n";
   OS << "\nLayout: ";
   OS << "<ASTRecordLayout\n";
Index: clang/lib/AST/ScanfFormatString.cpp
===================================================================
--- clang/lib/AST/ScanfFormatString.cpp
+++ clang/lib/AST/ScanfFormatString.cpp
@@ -11,29 +11,28 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/FormatString.h"
 #include "FormatStringParsing.h"
+#include "clang/AST/FormatString.h"
 #include "clang/Basic/TargetInfo.h"
 
+using clang::UpdateOnReturn;
 using clang::analyze_format_string::ArgType;
+using clang::analyze_format_string::ConversionSpecifier;
 using clang::analyze_format_string::FormatStringHandler;
 using clang::analyze_format_string::LengthModifier;
 using clang::analyze_format_string::OptionalAmount;
-using clang::analyze_format_string::ConversionSpecifier;
 using clang::analyze_scanf::ScanfConversionSpecifier;
 using clang::analyze_scanf::ScanfSpecifier;
-using clang::UpdateOnReturn;
 using namespace clang;
 
 typedef clang::analyze_format_string::SpecifierResult<ScanfSpecifier>
-        ScanfSpecifierResult;
+    ScanfSpecifierResult;
 
-static bool ParseScanList(FormatStringHandler &H,
-                          ScanfConversionSpecifier &CS,
-                          const char *&Beg, const char *E) {
-  const char *I = Beg;
-  const char *start = I - 1;
-  UpdateOnReturn <const char*> UpdateBeg(Beg, I);
+static bool ParseScanList(FormatStringHandler &H, ScanfConversionSpecifier &CS,
+                          char const *&Beg, char const *E) {
+  char const *I = Beg;
+  char const *start = I - 1;
+  UpdateOnReturn<char const *> UpdateBeg(Beg, I);
 
   // No more characters?
   if (I == E) {
@@ -73,37 +72,36 @@
 // FIXME: Much of this is copy-paste from ParsePrintfSpecifier.
 // We can possibly refactor.
 static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
-                                                const char *&Beg,
-                                                const char *E,
+                                                char const *&Beg, char const *E,
                                                 unsigned &argIndex,
-                                                const LangOptions &LO,
-                                                const TargetInfo &Target) {
+                                                LangOptions const &LO,
+                                                TargetInfo const &Target) {
   using namespace clang::analyze_format_string;
   using namespace clang::analyze_scanf;
-  const char *I = Beg;
-  const char *Start = nullptr;
-  UpdateOnReturn <const char*> UpdateBeg(Beg, I);
+  char const *I = Beg;
+  char const *Start = nullptr;
+  UpdateOnReturn<char const *> UpdateBeg(Beg, I);
 
-    // Look for a '%' character that indicates the start of a format specifier.
-  for ( ; I != E ; ++I) {
+  // Look for a '%' character that indicates the start of a format specifier.
+  for (; I != E; ++I) {
     char c = *I;
     if (c == '\0') {
-        // Detect spurious null characters, which are likely errors.
+      // Detect spurious null characters, which are likely errors.
       H.HandleNullChar(I);
       return true;
     }
     if (c == '%') {
-      Start = I++;  // Record the start of the format specifier.
+      Start = I++; // Record the start of the format specifier.
       break;
     }
   }
 
-    // No format specifier found?
+  // No format specifier found?
   if (!Start)
     return false;
 
   if (I == E) {
-      // No more characters left?
+    // No more characters left?
     H.HandleIncompleteSpecifier(Start, E - Start);
     return true;
   }
@@ -113,7 +111,7 @@
     return true;
 
   if (I == E) {
-      // No more characters left?
+    // No more characters left?
     H.HandleIncompleteSpecifier(Start, E - Start);
     return true;
   }
@@ -129,7 +127,7 @@
 
   // Look for the field width (if any).  Unlike printf, this is either
   // a fixed integer or isn't present.
-  const OptionalAmount &Amt = clang::analyze_format_string::ParseAmount(I, E);
+  OptionalAmount const &Amt = clang::analyze_format_string::ParseAmount(I, E);
   if (Amt.getHowSpecified() != OptionalAmount::NotSpecified) {
     assert(Amt.getHowSpecified() == OptionalAmount::Constant);
     FS.setFieldWidth(Amt);
@@ -143,7 +141,7 @@
 
   // Look for the length modifier.
   if (ParseLengthModifier(FS, I, E, LO, /*IsScanf=*/true) && I == E) {
-      // No more characters left?
+    // No more characters left?
     H.HandleIncompleteSpecifier(Start, E - Start);
     return true;
   }
@@ -155,47 +153,91 @@
   }
 
   // Finally, look for the conversion specifier.
-  const char *conversionPosition = I++;
+  char const *conversionPosition = I++;
   ScanfConversionSpecifier::Kind k = ScanfConversionSpecifier::InvalidSpecifier;
   switch (*conversionPosition) {
-    default:
-      break;
-    case '%': k = ConversionSpecifier::PercentArg;   break;
-    case 'A': k = ConversionSpecifier::AArg; break;
-    case 'E': k = ConversionSpecifier::EArg; break;
-    case 'F': k = ConversionSpecifier::FArg; break;
-    case 'G': k = ConversionSpecifier::GArg; break;
-    case 'X': k = ConversionSpecifier::XArg; break;
-    case 'a': k = ConversionSpecifier::aArg; break;
-    case 'd': k = ConversionSpecifier::dArg; break;
-    case 'e': k = ConversionSpecifier::eArg; break;
-    case 'f': k = ConversionSpecifier::fArg; break;
-    case 'g': k = ConversionSpecifier::gArg; break;
-    case 'i': k = ConversionSpecifier::iArg; break;
-    case 'n': k = ConversionSpecifier::nArg; break;
-    case 'c': k = ConversionSpecifier::cArg; break;
-    case 'C': k = ConversionSpecifier::CArg; break;
-    case 'S': k = ConversionSpecifier::SArg; break;
-    case '[': k = ConversionSpecifier::ScanListArg; break;
-    case 'u': k = ConversionSpecifier::uArg; break;
-    case 'x': k = ConversionSpecifier::xArg; break;
-    case 'o': k = ConversionSpecifier::oArg; break;
-    case 's': k = ConversionSpecifier::sArg; break;
-    case 'p': k = ConversionSpecifier::pArg; break;
-    // Apple extensions
-      // Apple-specific
-    case 'D':
-      if (Target.getTriple().isOSDarwin())
-        k = ConversionSpecifier::DArg;
-      break;
-    case 'O':
-      if (Target.getTriple().isOSDarwin())
-        k = ConversionSpecifier::OArg;
-      break;
-    case 'U':
-      if (Target.getTriple().isOSDarwin())
-        k = ConversionSpecifier::UArg;
-      break;
+  default:
+    break;
+  case '%':
+    k = ConversionSpecifier::PercentArg;
+    break;
+  case 'A':
+    k = ConversionSpecifier::AArg;
+    break;
+  case 'E':
+    k = ConversionSpecifier::EArg;
+    break;
+  case 'F':
+    k = ConversionSpecifier::FArg;
+    break;
+  case 'G':
+    k = ConversionSpecifier::GArg;
+    break;
+  case 'X':
+    k = ConversionSpecifier::XArg;
+    break;
+  case 'a':
+    k = ConversionSpecifier::aArg;
+    break;
+  case 'd':
+    k = ConversionSpecifier::dArg;
+    break;
+  case 'e':
+    k = ConversionSpecifier::eArg;
+    break;
+  case 'f':
+    k = ConversionSpecifier::fArg;
+    break;
+  case 'g':
+    k = ConversionSpecifier::gArg;
+    break;
+  case 'i':
+    k = ConversionSpecifier::iArg;
+    break;
+  case 'n':
+    k = ConversionSpecifier::nArg;
+    break;
+  case 'c':
+    k = ConversionSpecifier::cArg;
+    break;
+  case 'C':
+    k = ConversionSpecifier::CArg;
+    break;
+  case 'S':
+    k = ConversionSpecifier::SArg;
+    break;
+  case '[':
+    k = ConversionSpecifier::ScanListArg;
+    break;
+  case 'u':
+    k = ConversionSpecifier::uArg;
+    break;
+  case 'x':
+    k = ConversionSpecifier::xArg;
+    break;
+  case 'o':
+    k = ConversionSpecifier::oArg;
+    break;
+  case 's':
+    k = ConversionSpecifier::sArg;
+    break;
+  case 'p':
+    k = ConversionSpecifier::pArg;
+    break;
+  // Apple extensions
+  // Apple-specific
+  case 'D':
+    if (Target.getTriple().isOSDarwin())
+      k = ConversionSpecifier::DArg;
+    break;
+  case 'O':
+    if (Target.getTriple().isOSDarwin())
+      k = ConversionSpecifier::OArg;
+    break;
+  case 'U':
+    if (Target.getTriple().isOSDarwin())
+      k = ConversionSpecifier::UArg;
+    break;
   }
   ScanfConversionSpecifier CS(conversionPosition, k);
   if (k == ScanfConversionSpecifier::ScanListArg) {
@@ -203,8 +245,8 @@
       return true;
   }
   FS.setConversionSpecifier(CS);
-  if (CS.consumesDataArgument() && !FS.getSuppressAssignment()
-      && !FS.usesPositionalArg())
+  if (CS.consumesDataArgument() && !FS.getSuppressAssignment() &&
+      !FS.usesPositionalArg())
     FS.setArgIndex(argIndex++);
 
   // FIXME: '%' and '*' doesn't make sense.  Issue a warning.
@@ -223,195 +265,195 @@
 }
 
 ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const {
-  const ScanfConversionSpecifier &CS = getConversionSpecifier();
+  ScanfConversionSpecifier const &CS = getConversionSpecifier();
 
   if (!CS.consumesDataArgument())
     return ArgType::Invalid();
 
-  switch(CS.getKind()) {
-    // Signed int.
-    case ConversionSpecifier::dArg:
-    case ConversionSpecifier::DArg:
-    case ConversionSpecifier::iArg:
-      switch (LM.getKind()) {
-        case LengthModifier::None:
-          return ArgType::PtrTo(Ctx.IntTy);
-        case LengthModifier::AsChar:
-          return ArgType::PtrTo(ArgType::AnyCharTy);
-        case LengthModifier::AsShort:
-          return ArgType::PtrTo(Ctx.ShortTy);
-        case LengthModifier::AsLong:
-          return ArgType::PtrTo(Ctx.LongTy);
-        case LengthModifier::AsLongLong:
-        case LengthModifier::AsQuad:
-          return ArgType::PtrTo(Ctx.LongLongTy);
-        case LengthModifier::AsInt64:
-          return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
-        case LengthModifier::AsIntMax:
-          return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
-        case LengthModifier::AsSizeT:
-          return ArgType::PtrTo(ArgType(Ctx.getSignedSizeType(), "ssize_t"));
-        case LengthModifier::AsPtrDiff:
-          return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
-        case LengthModifier::AsLongDouble:
-          // GNU extension.
-          return ArgType::PtrTo(Ctx.LongLongTy);
-        case LengthModifier::AsAllocate:
-        case LengthModifier::AsMAllocate:
-        case LengthModifier::AsInt32:
-        case LengthModifier::AsInt3264:
-        case LengthModifier::AsWide:
-        case LengthModifier::AsShortLong:
-          return ArgType::Invalid();
-      }
-      llvm_unreachable("Unsupported LengthModifier Type");
-
-    // Unsigned int.
-    case ConversionSpecifier::oArg:
-    case ConversionSpecifier::OArg:
-    case ConversionSpecifier::uArg:
-    case ConversionSpecifier::UArg:
-    case ConversionSpecifier::xArg:
-    case ConversionSpecifier::XArg:
-      switch (LM.getKind()) {
-        case LengthModifier::None:
-          return ArgType::PtrTo(Ctx.UnsignedIntTy);
-        case LengthModifier::AsChar:
-          return ArgType::PtrTo(Ctx.UnsignedCharTy);
-        case LengthModifier::AsShort:
-          return ArgType::PtrTo(Ctx.UnsignedShortTy);
-        case LengthModifier::AsLong:
-          return ArgType::PtrTo(Ctx.UnsignedLongTy);
-        case LengthModifier::AsLongLong:
-        case LengthModifier::AsQuad:
-          return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
-        case LengthModifier::AsInt64:
-          return ArgType::PtrTo(ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64"));
-        case LengthModifier::AsIntMax:
-          return ArgType::PtrTo(ArgType(Ctx.getUIntMaxType(), "uintmax_t"));
-        case LengthModifier::AsSizeT:
-          return ArgType::PtrTo(ArgType(Ctx.getSizeType(), "size_t"));
-        case LengthModifier::AsPtrDiff:
-          return ArgType::PtrTo(
-              ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptrdiff_t"));
-        case LengthModifier::AsLongDouble:
-          // GNU extension.
-          return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
-        case LengthModifier::AsAllocate:
-        case LengthModifier::AsMAllocate:
-        case LengthModifier::AsInt32:
-        case LengthModifier::AsInt3264:
-        case LengthModifier::AsWide:
-        case LengthModifier::AsShortLong:
-          return ArgType::Invalid();
-      }
-      llvm_unreachable("Unsupported LengthModifier Type");
-
-    // Float.
-    case ConversionSpecifier::aArg:
-    case ConversionSpecifier::AArg:
-    case ConversionSpecifier::eArg:
-    case ConversionSpecifier::EArg:
-    case ConversionSpecifier::fArg:
-    case ConversionSpecifier::FArg:
-    case ConversionSpecifier::gArg:
-    case ConversionSpecifier::GArg:
-      switch (LM.getKind()) {
-        case LengthModifier::None:
-          return ArgType::PtrTo(Ctx.FloatTy);
-        case LengthModifier::AsLong:
-          return ArgType::PtrTo(Ctx.DoubleTy);
-        case LengthModifier::AsLongDouble:
-          return ArgType::PtrTo(Ctx.LongDoubleTy);
-        default:
-          return ArgType::Invalid();
-      }
-
-    // Char, string and scanlist.
-    case ConversionSpecifier::cArg:
-    case ConversionSpecifier::sArg:
-    case ConversionSpecifier::ScanListArg:
-      switch (LM.getKind()) {
-        case LengthModifier::None:
-          return ArgType::PtrTo(ArgType::AnyCharTy);
-        case LengthModifier::AsLong:
-        case LengthModifier::AsWide:
-          return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
-        case LengthModifier::AsAllocate:
-        case LengthModifier::AsMAllocate:
-          return ArgType::PtrTo(ArgType::CStrTy);
-        case LengthModifier::AsShort:
-          if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
-            return ArgType::PtrTo(ArgType::AnyCharTy);
-          LLVM_FALLTHROUGH;
-        default:
-          return ArgType::Invalid();
-      }
-    case ConversionSpecifier::CArg:
-    case ConversionSpecifier::SArg:
-      // FIXME: Mac OS X specific?
-      switch (LM.getKind()) {
-        case LengthModifier::None:
-        case LengthModifier::AsWide:
-          return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
-        case LengthModifier::AsAllocate:
-        case LengthModifier::AsMAllocate:
-          return ArgType::PtrTo(ArgType(ArgType::WCStrTy, "wchar_t *"));
-        case LengthModifier::AsShort:
-          if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
-            return ArgType::PtrTo(ArgType::AnyCharTy);
-          LLVM_FALLTHROUGH;
-        default:
-          return ArgType::Invalid();
-      }
-
-    // Pointer.
-    case ConversionSpecifier::pArg:
-      return ArgType::PtrTo(ArgType::CPointerTy);
-
-    // Write-back.
-    case ConversionSpecifier::nArg:
-      switch (LM.getKind()) {
-        case LengthModifier::None:
-          return ArgType::PtrTo(Ctx.IntTy);
-        case LengthModifier::AsChar:
-          return ArgType::PtrTo(Ctx.SignedCharTy);
-        case LengthModifier::AsShort:
-          return ArgType::PtrTo(Ctx.ShortTy);
-        case LengthModifier::AsLong:
-          return ArgType::PtrTo(Ctx.LongTy);
-        case LengthModifier::AsLongLong:
-        case LengthModifier::AsQuad:
-          return ArgType::PtrTo(Ctx.LongLongTy);
-        case LengthModifier::AsInt64:
-          return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
-        case LengthModifier::AsIntMax:
-          return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
-        case LengthModifier::AsSizeT:
-          return ArgType::PtrTo(ArgType(Ctx.getSignedSizeType(), "ssize_t"));
-        case LengthModifier::AsPtrDiff:
-          return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
-        case LengthModifier::AsLongDouble:
-          return ArgType(); // FIXME: Is this a known extension?
-        case LengthModifier::AsAllocate:
-        case LengthModifier::AsMAllocate:
-        case LengthModifier::AsInt32:
-        case LengthModifier::AsInt3264:
-        case LengthModifier::AsWide:
-        case LengthModifier::AsShortLong:
-          return ArgType::Invalid();
-        }
+  switch (CS.getKind()) {
+  // Signed int.
+  case ConversionSpecifier::dArg:
+  case ConversionSpecifier::DArg:
+  case ConversionSpecifier::iArg:
+    switch (LM.getKind()) {
+    case LengthModifier::None:
+      return ArgType::PtrTo(Ctx.IntTy);
+    case LengthModifier::AsChar:
+      return ArgType::PtrTo(ArgType::AnyCharTy);
+    case LengthModifier::AsShort:
+      return ArgType::PtrTo(Ctx.ShortTy);
+    case LengthModifier::AsLong:
+      return ArgType::PtrTo(Ctx.LongTy);
+    case LengthModifier::AsLongLong:
+    case LengthModifier::AsQuad:
+      return ArgType::PtrTo(Ctx.LongLongTy);
+    case LengthModifier::AsInt64:
+      return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
+    case LengthModifier::AsIntMax:
+      return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
+    case LengthModifier::AsSizeT:
+      return ArgType::PtrTo(ArgType(Ctx.getSignedSizeType(), "ssize_t"));
+    case LengthModifier::AsPtrDiff:
+      return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
+    case LengthModifier::AsLongDouble:
+      // GNU extension.
+      return ArgType::PtrTo(Ctx.LongLongTy);
+    case LengthModifier::AsAllocate:
+    case LengthModifier::AsMAllocate:
+    case LengthModifier::AsInt32:
+    case LengthModifier::AsInt3264:
+    case LengthModifier::AsWide:
+    case LengthModifier::AsShortLong:
+      return ArgType::Invalid();
+    }
+    llvm_unreachable("Unsupported LengthModifier Type");
+
+  // Unsigned int.
+  case ConversionSpecifier::oArg:
+  case ConversionSpecifier::OArg:
+  case ConversionSpecifier::uArg:
+  case ConversionSpecifier::UArg:
+  case ConversionSpecifier::xArg:
+  case ConversionSpecifier::XArg:
+    switch (LM.getKind()) {
+    case LengthModifier::None:
+      return ArgType::PtrTo(Ctx.UnsignedIntTy);
+    case LengthModifier::AsChar:
+      return ArgType::PtrTo(Ctx.UnsignedCharTy);
+    case LengthModifier::AsShort:
+      return ArgType::PtrTo(Ctx.UnsignedShortTy);
+    case LengthModifier::AsLong:
+      return ArgType::PtrTo(Ctx.UnsignedLongTy);
+    case LengthModifier::AsLongLong:
+    case LengthModifier::AsQuad:
+      return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
+    case LengthModifier::AsInt64:
+      return ArgType::PtrTo(
+          ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64"));
+    case LengthModifier::AsIntMax:
+      return ArgType::PtrTo(ArgType(Ctx.getUIntMaxType(), "uintmax_t"));
+    case LengthModifier::AsSizeT:
+      return ArgType::PtrTo(ArgType(Ctx.getSizeType(), "size_t"));
+    case LengthModifier::AsPtrDiff:
+      return ArgType::PtrTo(
+          ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptrdiff_t"));
+    case LengthModifier::AsLongDouble:
+      // GNU extension.
+      return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
+    case LengthModifier::AsAllocate:
+    case LengthModifier::AsMAllocate:
+    case LengthModifier::AsInt32:
+    case LengthModifier::AsInt3264:
+    case LengthModifier::AsWide:
+    case LengthModifier::AsShortLong:
+      return ArgType::Invalid();
+    }
+    llvm_unreachable("Unsupported LengthModifier Type");
+
+  // Float.
+  case ConversionSpecifier::aArg:
+  case ConversionSpecifier::AArg:
+  case ConversionSpecifier::eArg:
+  case ConversionSpecifier::EArg:
+  case ConversionSpecifier::fArg:
+  case ConversionSpecifier::FArg:
+  case ConversionSpecifier::gArg:
+  case ConversionSpecifier::GArg:
+    switch (LM.getKind()) {
+    case LengthModifier::None:
+      return ArgType::PtrTo(Ctx.FloatTy);
+    case LengthModifier::AsLong:
+      return ArgType::PtrTo(Ctx.DoubleTy);
+    case LengthModifier::AsLongDouble:
+      return ArgType::PtrTo(Ctx.LongDoubleTy);
+    default:
+      return ArgType::Invalid();
+    }
 
+  // Char, string and scanlist.
+  case ConversionSpecifier::cArg:
+  case ConversionSpecifier::sArg:
+  case ConversionSpecifier::ScanListArg:
+    switch (LM.getKind()) {
+    case LengthModifier::None:
+      return ArgType::PtrTo(ArgType::AnyCharTy);
+    case LengthModifier::AsLong:
+    case LengthModifier::AsWide:
+      return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
+    case LengthModifier::AsAllocate:
+    case LengthModifier::AsMAllocate:
+      return ArgType::PtrTo(ArgType::CStrTy);
+    case LengthModifier::AsShort:
+      if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
+        return ArgType::PtrTo(ArgType::AnyCharTy);
+      LLVM_FALLTHROUGH;
     default:
-      break;
+      return ArgType::Invalid();
+    }
+  case ConversionSpecifier::CArg:
+  case ConversionSpecifier::SArg:
+    // FIXME: Mac OS X specific?
+    switch (LM.getKind()) {
+    case LengthModifier::None:
+    case LengthModifier::AsWide:
+      return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
+    case LengthModifier::AsAllocate:
+    case LengthModifier::AsMAllocate:
+      return ArgType::PtrTo(ArgType(ArgType::WCStrTy, "wchar_t *"));
+    case LengthModifier::AsShort:
+      if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
+        return ArgType::PtrTo(ArgType::AnyCharTy);
+      LLVM_FALLTHROUGH;
+    default:
+      return ArgType::Invalid();
+    }
+
+  // Pointer.
+  case ConversionSpecifier::pArg:
+    return ArgType::PtrTo(ArgType::CPointerTy);
+
+  // Write-back.
+  case ConversionSpecifier::nArg:
+    switch (LM.getKind()) {
+    case LengthModifier::None:
+      return ArgType::PtrTo(Ctx.IntTy);
+    case LengthModifier::AsChar:
+      return ArgType::PtrTo(Ctx.SignedCharTy);
+    case LengthModifier::AsShort:
+      return ArgType::PtrTo(Ctx.ShortTy);
+    case LengthModifier::AsLong:
+      return ArgType::PtrTo(Ctx.LongTy);
+    case LengthModifier::AsLongLong:
+    case LengthModifier::AsQuad:
+      return ArgType::PtrTo(Ctx.LongLongTy);
+    case LengthModifier::AsInt64:
+      return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
+    case LengthModifier::AsIntMax:
+      return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
+    case LengthModifier::AsSizeT:
+      return ArgType::PtrTo(ArgType(Ctx.getSignedSizeType(), "ssize_t"));
+    case LengthModifier::AsPtrDiff:
+      return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
+    case LengthModifier::AsLongDouble:
+      return ArgType(); // FIXME: Is this a known extension?
+    case LengthModifier::AsAllocate:
+    case LengthModifier::AsMAllocate:
+    case LengthModifier::AsInt32:
+    case LengthModifier::AsInt3264:
+    case LengthModifier::AsWide:
+    case LengthModifier::AsShortLong:
+      return ArgType::Invalid();
+    }
+
+  default:
+    break;
   }
 
   return ArgType();
 }
 
 bool ScanfSpecifier::fixType(QualType QT, QualType RawQT,
-                             const LangOptions &LangOpt,
-                             ASTContext &Ctx) {
+                             LangOptions const &LangOpt, ASTContext &Ctx) {
 
   // %n is different from other conversion specifiers; don't try to fix it.
   if (CS.getKind() == ConversionSpecifier::nArg)
@@ -423,14 +465,14 @@
   QualType PT = QT->getPointeeType();
 
   // If it's an enum, get its underlying type.
-  if (const EnumType *ETy = PT->getAs<EnumType>()) {
+  if (EnumType const *ETy = PT->getAs<EnumType>()) {
     // Don't try to fix incomplete enums.
     if (!ETy->getDecl()->isComplete())
       return false;
     PT = ETy->getDecl()->getIntegerType();
   }
 
-  const BuiltinType *BT = PT->getAs<BuiltinType>();
+  BuiltinType const *BT = PT->getAs<BuiltinType>();
   if (!BT)
     return false;
 
@@ -443,60 +485,59 @@
       LM.setKind(LengthModifier::None);
 
     // If we know the target array length, we can use it as a field width.
-    if (const ConstantArrayType *CAT = Ctx.getAsConstantArrayType(RawQT)) {
+    if (ConstantArrayType const *CAT = Ctx.getAsConstantArrayType(RawQT)) {
       if (CAT->getSizeModifier() == ArrayType::Normal)
-        FieldWidth = OptionalAmount(OptionalAmount::Constant,
-                                    CAT->getSize().getZExtValue() - 1,
-                                    "", 0, false);
-
+        FieldWidth =
+            OptionalAmount(OptionalAmount::Constant,
+                           CAT->getSize().getZExtValue() - 1, "", 0, false);
     }
     return true;
   }
 
   // Figure out the length modifier.
   switch (BT->getKind()) {
-    // no modifier
-    case BuiltinType::UInt:
-    case BuiltinType::Int:
-    case BuiltinType::Float:
-      LM.setKind(LengthModifier::None);
-      break;
-
-    // hh
-    case BuiltinType::Char_U:
-    case BuiltinType::UChar:
-    case BuiltinType::Char_S:
-    case BuiltinType::SChar:
-      LM.setKind(LengthModifier::AsChar);
-      break;
-
-    // h
-    case BuiltinType::Short:
-    case BuiltinType::UShort:
-      LM.setKind(LengthModifier::AsShort);
-      break;
-
-    // l
-    case BuiltinType::Long:
-    case BuiltinType::ULong:
-    case BuiltinType::Double:
-      LM.setKind(LengthModifier::AsLong);
-      break;
-
-    // ll
-    case BuiltinType::LongLong:
-    case BuiltinType::ULongLong:
-      LM.setKind(LengthModifier::AsLongLong);
-      break;
-
-    // L
-    case BuiltinType::LongDouble:
-      LM.setKind(LengthModifier::AsLongDouble);
-      break;
-
-    // Don't know.
-    default:
-      return false;
+  // no modifier
+  case BuiltinType::UInt:
+  case BuiltinType::Int:
+  case BuiltinType::Float:
+    LM.setKind(LengthModifier::None);
+    break;
+
+  // hh
+  case BuiltinType::Char_U:
+  case BuiltinType::UChar:
+  case BuiltinType::Char_S:
+  case BuiltinType::SChar:
+    LM.setKind(LengthModifier::AsChar);
+    break;
+
+  // h
+  case BuiltinType::Short:
+  case BuiltinType::UShort:
+    LM.setKind(LengthModifier::AsShort);
+    break;
+
+  // l
+  case BuiltinType::Long:
+  case BuiltinType::ULong:
+  case BuiltinType::Double:
+    LM.setKind(LengthModifier::AsLong);
+    break;
+
+  // ll
+  case BuiltinType::LongLong:
+  case BuiltinType::ULongLong:
+    LM.setKind(LengthModifier::AsLongLong);
+    break;
+
+  // L
+  case BuiltinType::LongDouble:
+    LM.setKind(LengthModifier::AsLongDouble);
+    break;
+
+  // Don't know.
+  default:
+    return false;
   }
 
   // Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
@@ -505,7 +546,7 @@
 
   // If fixing the length modifier was enough, we are done.
   if (hasValidLengthModifier(Ctx.getTargetInfo(), LangOpt)) {
-    const analyze_scanf::ArgType &AT = getArgType(Ctx);
+    analyze_scanf::ArgType const &AT = getArgType(Ctx);
     if (AT.isValid() && AT.matchesType(Ctx, QT))
       return true;
   }
@@ -537,26 +578,26 @@
 }
 
 bool clang::analyze_format_string::ParseScanfString(FormatStringHandler &H,
-                                                    const char *I,
-                                                    const char *E,
-                                                    const LangOptions &LO,
-                                                    const TargetInfo &Target) {
+                                                    char const *I,
+                                                    char const *E,
+                                                    LangOptions const &LO,
+                                                    TargetInfo const &Target) {
 
   unsigned argIndex = 0;
 
   // Keep looking for a format specifier until we have exhausted the string.
   while (I != E) {
-    const ScanfSpecifierResult &FSR = ParseScanfSpecifier(H, I, E, argIndex,
-                                                          LO, Target);
+    ScanfSpecifierResult const &FSR =
+        ParseScanfSpecifier(H, I, E, argIndex, LO, Target);
     // Did a fail-stop error of any kind occur when parsing the specifier?
     // If so, don't do any more processing.
     if (FSR.shouldStop())
       return true;
-      // Did we exhaust the string or encounter an error that
-      // we can recover from?
+    // Did we exhaust the string or encounter an error that
+    // we can recover from?
     if (!FSR.hasValue())
       continue;
-      // We have a format specifier.  Pass it to the callback.
+    // We have a format specifier.  Pass it to the callback.
     if (!H.HandleScanfSpecifier(FSR.getValue(), FSR.getStart(),
                                 I - FSR.getStart())) {
       return true;
Index: clang/lib/AST/SelectorLocationsKind.cpp
===================================================================
--- clang/lib/AST/SelectorLocationsKind.cpp
+++ clang/lib/AST/SelectorLocationsKind.cpp
@@ -16,8 +16,7 @@
 
 using namespace clang;
 
-static SourceLocation getStandardSelLoc(unsigned Index,
-                                        Selector Sel,
+static SourceLocation getStandardSelLoc(unsigned Index, Selector Sel,
                                         bool WithArgSpace,
                                         SourceLocation ArgLoc,
                                         SourceLocation EndLoc) {
@@ -43,16 +42,13 @@
 
 namespace {
 
-template <typename T>
-SourceLocation getArgLoc(T* Arg);
+template <typename T> SourceLocation getArgLoc(T *Arg);
 
-template <>
-SourceLocation getArgLoc<Expr>(Expr *Arg) {
+template <> SourceLocation getArgLoc<Expr>(Expr *Arg) {
   return Arg->getBeginLoc();
 }
 
-template <>
-SourceLocation getArgLoc<ParmVarDecl>(ParmVarDecl *Arg) {
+template <> SourceLocation getArgLoc<ParmVarDecl>(ParmVarDecl *Arg) {
   SourceLocation Loc = Arg->getBeginLoc();
   if (Loc.isInvalid())
     return Loc;
@@ -61,20 +57,19 @@
 }
 
 template <typename T>
-SourceLocation getArgLoc(unsigned Index, ArrayRef<T*> Args) {
+SourceLocation getArgLoc(unsigned Index, ArrayRef<T *> Args) {
   return Index < Args.size() ? getArgLoc(Args[Index]) : SourceLocation();
 }
 
 template <typename T>
-SelectorLocationsKind hasStandardSelLocs(Selector Sel,
-                                         ArrayRef<SourceLocation> SelLocs,
-                                         ArrayRef<T *> Args,
-                                         SourceLocation EndLoc) {
+SelectorLocationsKind
+hasStandardSelLocs(Selector Sel, ArrayRef<SourceLocation> SelLocs,
+                   ArrayRef<T *> Args, SourceLocation EndLoc) {
   // Are selector locations in standard position with no space between args ?
   unsigned i;
   for (i = 0; i != SelLocs.size(); ++i) {
-    if (SelLocs[i] != getStandardSelectorLoc(i, Sel, /*WithArgSpace=*/false,
-                                             Args, EndLoc))
+    if (SelLocs[i] !=
+        getStandardSelectorLoc(i, Sel, /*WithArgSpace=*/false, Args, EndLoc))
       break;
   }
   if (i == SelLocs.size())
@@ -82,8 +77,8 @@
 
   // Are selector locations in standard position with space between args ?
   for (i = 0; i != SelLocs.size(); ++i) {
-    if (SelLocs[i] != getStandardSelectorLoc(i, Sel, /*WithArgSpace=*/true,
-                                             Args, EndLoc))
+    if (SelLocs[i] !=
+        getStandardSelectorLoc(i, Sel, /*WithArgSpace=*/true, Args, EndLoc))
       return SelLoc_NonStandard;
   }
 
@@ -93,35 +88,30 @@
 } // anonymous namespace
 
 SelectorLocationsKind
-clang::hasStandardSelectorLocs(Selector Sel,
-                               ArrayRef<SourceLocation> SelLocs,
-                               ArrayRef<Expr *> Args,
-                               SourceLocation EndLoc) {
+clang::hasStandardSelectorLocs(Selector Sel, ArrayRef<SourceLocation> SelLocs,
+                               ArrayRef<Expr *> Args, SourceLocation EndLoc) {
   return hasStandardSelLocs(Sel, SelLocs, Args, EndLoc);
 }
 
-SourceLocation clang::getStandardSelectorLoc(unsigned Index,
-                                             Selector Sel,
+SourceLocation clang::getStandardSelectorLoc(unsigned Index, Selector Sel,
                                              bool WithArgSpace,
                                              ArrayRef<Expr *> Args,
                                              SourceLocation EndLoc) {
-  return getStandardSelLoc(Index, Sel, WithArgSpace,
-                           getArgLoc(Index, Args), EndLoc);
+  return getStandardSelLoc(Index, Sel, WithArgSpace, getArgLoc(Index, Args),
+                           EndLoc);
 }
 
 SelectorLocationsKind
-clang::hasStandardSelectorLocs(Selector Sel,
-                               ArrayRef<SourceLocation> SelLocs,
+clang::hasStandardSelectorLocs(Selector Sel, ArrayRef<SourceLocation> SelLocs,
                                ArrayRef<ParmVarDecl *> Args,
                                SourceLocation EndLoc) {
   return hasStandardSelLocs(Sel, SelLocs, Args, EndLoc);
 }
 
-SourceLocation clang::getStandardSelectorLoc(unsigned Index,
-                                             Selector Sel,
+SourceLocation clang::getStandardSelectorLoc(unsigned Index, Selector Sel,
                                              bool WithArgSpace,
                                              ArrayRef<ParmVarDecl *> Args,
                                              SourceLocation EndLoc) {
-  return getStandardSelLoc(Index, Sel, WithArgSpace,
-                           getArgLoc(Index, Args), EndLoc);
+  return getStandardSelLoc(Index, Sel, WithArgSpace, getArgLoc(Index, Args),
+                           EndLoc);
 }
Index: clang/lib/AST/Stmt.cpp
===================================================================
--- clang/lib/AST/Stmt.cpp
+++ clang/lib/AST/Stmt.cpp
@@ -48,10 +48,10 @@
 using namespace clang;
 
 static struct StmtClassNameTable {
-  const char *Name;
+  char const *Name;
   unsigned Counter;
   unsigned Size;
-} StmtClassInfo[Stmt::lastStmtConstant+1];
+} StmtClassInfo[Stmt::lastStmtConstant + 1];
 
 static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
   static bool Initialized = false;
@@ -61,28 +61,28 @@
   // Initialize the table on the first use.
   Initialized = true;
 #define ABSTRACT_STMT(STMT)
-#define STMT(CLASS, PARENT) \
-  StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS;    \
+#define STMT(CLASS, PARENT)                                                    \
+  StmtClassInfo[(unsigned)Stmt::CLASS##Class].Name = #CLASS;                   \
   StmtClassInfo[(unsigned)Stmt::CLASS##Class].Size = sizeof(CLASS);
 #include "clang/AST/StmtNodes.inc"
 
   return StmtClassInfo[E];
 }
 
-void *Stmt::operator new(size_t bytes, const ASTContext& C,
+void *Stmt::operator new(size_t bytes, ASTContext const &C,
                          unsigned alignment) {
   return ::operator new(bytes, C, alignment);
 }
 
-const char *Stmt::getStmtClassName() const {
-  return getStmtInfoTableEntry((StmtClass) StmtBits.sClass).Name;
+char const *Stmt::getStmtClassName() const {
+  return getStmtInfoTableEntry((StmtClass)StmtBits.sClass).Name;
 }
 
 // Check that no statement / expression class is polymorphic. LLVM style RTTI
 // should be used instead. If absolutely needed an exception can still be added
 // here by defining the appropriate macro (but please don't do this).
-#define STMT(CLASS, PARENT) \
-  static_assert(!std::is_polymorphic<CLASS>::value, \
+#define STMT(CLASS, PARENT)                                                    \
+  static_assert(!std::is_polymorphic<CLASS>::value,                            \
                 #CLASS " should not be polymorphic!");
 #include "clang/AST/StmtNodes.inc"
 
@@ -102,37 +102,37 @@
 
   unsigned sum = 0;
   llvm::errs() << "\n*** Stmt/Expr Stats:\n";
-  for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
-    if (StmtClassInfo[i].Name == nullptr) continue;
+  for (int i = 0; i != Stmt::lastStmtConstant + 1; i++) {
+    if (StmtClassInfo[i].Name == nullptr)
+      continue;
     sum += StmtClassInfo[i].Counter;
   }
   llvm::errs() << "  " << sum << " stmts/exprs total.\n";
   sum = 0;
-  for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
-    if (StmtClassInfo[i].Name == nullptr) continue;
-    if (StmtClassInfo[i].Counter == 0) continue;
+  for (int i = 0; i != Stmt::lastStmtConstant + 1; i++) {
+    if (StmtClassInfo[i].Name == nullptr)
+      continue;
+    if (StmtClassInfo[i].Counter == 0)
+      continue;
     llvm::errs() << "    " << StmtClassInfo[i].Counter << " "
                  << StmtClassInfo[i].Name << ", " << StmtClassInfo[i].Size
-                 << " each (" << StmtClassInfo[i].Counter*StmtClassInfo[i].Size
+                 << " each ("
+                 << StmtClassInfo[i].Counter * StmtClassInfo[i].Size
                  << " bytes)\n";
-    sum += StmtClassInfo[i].Counter*StmtClassInfo[i].Size;
+    sum += StmtClassInfo[i].Counter * StmtClassInfo[i].Size;
   }
 
   llvm::errs() << "Total bytes = " << sum << "\n";
 }
 
-void Stmt::addStmtClass(StmtClass s) {
-  ++getStmtInfoTableEntry(s).Counter;
-}
+void Stmt::addStmtClass(StmtClass s) { ++getStmtInfoTableEntry(s).Counter; }
 
 bool Stmt::StatisticsEnabled = false;
-void Stmt::EnableStatistics() {
-  StatisticsEnabled = true;
-}
+void Stmt::EnableStatistics() { StatisticsEnabled = true; }
 
-static std::pair<Stmt::Likelihood, const Attr *>
-getLikelihood(ArrayRef<const Attr *> Attrs) {
-  for (const auto *A : Attrs) {
+static std::pair<Stmt::Likelihood, Attr const *>
+getLikelihood(ArrayRef<Attr const *> Attrs) {
+  for (auto const *A : Attrs) {
     if (isa<LikelyAttr>(A))
       return std::make_pair(Stmt::LH_Likely, A);
 
@@ -143,26 +143,26 @@
   return std::make_pair(Stmt::LH_None, nullptr);
 }
 
-static std::pair<Stmt::Likelihood, const Attr *> getLikelihood(const Stmt *S) {
-  if (const auto *AS = dyn_cast_or_null<AttributedStmt>(S))
+static std::pair<Stmt::Likelihood, Attr const *> getLikelihood(Stmt const *S) {
+  if (auto const *AS = dyn_cast_or_null<AttributedStmt>(S))
     return getLikelihood(AS->getAttrs());
 
   return std::make_pair(Stmt::LH_None, nullptr);
 }
 
-Stmt::Likelihood Stmt::getLikelihood(ArrayRef<const Attr *> Attrs) {
+Stmt::Likelihood Stmt::getLikelihood(ArrayRef<Attr const *> Attrs) {
   return ::getLikelihood(Attrs).first;
 }
 
-Stmt::Likelihood Stmt::getLikelihood(const Stmt *S) {
+Stmt::Likelihood Stmt::getLikelihood(Stmt const *S) {
   return ::getLikelihood(S).first;
 }
 
-const Attr *Stmt::getLikelihoodAttr(const Stmt *S) {
+Attr const *Stmt::getLikelihoodAttr(Stmt const *S) {
   return ::getLikelihood(S).second;
 }
 
-Stmt::Likelihood Stmt::getLikelihood(const Stmt *Then, const Stmt *Else) {
+Stmt::Likelihood Stmt::getLikelihood(Stmt const *Then, Stmt const *Else) {
   Likelihood LHT = ::getLikelihood(Then).first;
   Likelihood LHE = ::getLikelihood(Else).first;
   if (LHE == LH_None)
@@ -179,10 +179,10 @@
   return LHE == LH_Likely ? LH_Unlikely : LH_Likely;
 }
 
-std::tuple<bool, const Attr *, const Attr *>
-Stmt::determineLikelihoodConflict(const Stmt *Then, const Stmt *Else) {
-  std::pair<Likelihood, const Attr *> LHT = ::getLikelihood(Then);
-  std::pair<Likelihood, const Attr *> LHE = ::getLikelihood(Else);
+std::tuple<bool, Attr const *, Attr const *>
+Stmt::determineLikelihoodConflict(Stmt const *Then, Stmt const *Else) {
+  std::pair<Likelihood, Attr const *> LHT = ::getLikelihood(Then);
+  std::pair<Likelihood, Attr const *> LHE = ::getLikelihood(Else);
   // If the same attribute is used on both branches there's a conflict.
   if (LHT.first != LH_None && LHT.first == LHE.first)
     return std::make_tuple(true, LHT.second, LHE.second);
@@ -214,14 +214,14 @@
 ///
 /// This will strip off label statements, case statements, attributed
 /// statements and default statements recursively.
-const Stmt *Stmt::stripLabelLikeStatements() const {
-  const Stmt *S = this;
+Stmt const *Stmt::stripLabelLikeStatements() const {
+  Stmt const *S = this;
   while (true) {
-    if (const auto *LS = dyn_cast<LabelStmt>(S))
+    if (auto const *LS = dyn_cast<LabelStmt>(S))
       S = LS->getSubStmt();
-    else if (const auto *SC = dyn_cast<SwitchCase>(S))
+    else if (auto const *SC = dyn_cast<SwitchCase>(S))
       S = SC->getSubStmt();
-    else if (const auto *AS = dyn_cast<AttributedStmt>(S))
+    else if (auto const *AS = dyn_cast<AttributedStmt>(S))
       S = AS->getSubStmt();
     else
       return S;
@@ -230,39 +230,35 @@
 
 namespace {
 
-  struct good {};
-  struct bad {};
+struct good {};
+struct bad {};
 
-  // These silly little functions have to be static inline to suppress
-  // unused warnings, and they have to be defined to suppress other
-  // warnings.
-  static good is_good(good) { return good(); }
+// These silly little functions have to be static inline to suppress
+// unused warnings, and they have to be defined to suppress other
+// warnings.
+static good is_good(good) { return good(); }
 
-  typedef Stmt::child_range children_t();
-  template <class T> good implements_children(children_t T::*) {
-    return good();
-  }
-  LLVM_ATTRIBUTE_UNUSED
-  static bad implements_children(children_t Stmt::*) {
-    return bad();
-  }
+typedef Stmt::child_range children_t();
+template <class T> good implements_children(children_t T::*) { return good(); }
+LLVM_ATTRIBUTE_UNUSED
+static bad implements_children(children_t Stmt::*) { return bad(); }
 
-  typedef SourceLocation getBeginLoc_t() const;
-  template <class T> good implements_getBeginLoc(getBeginLoc_t T::*) {
-    return good();
-  }
-  LLVM_ATTRIBUTE_UNUSED
-  static bad implements_getBeginLoc(getBeginLoc_t Stmt::*) { return bad(); }
+typedef SourceLocation getBeginLoc_t() const;
+template <class T> good implements_getBeginLoc(getBeginLoc_t T::*) {
+  return good();
+}
+LLVM_ATTRIBUTE_UNUSED
+static bad implements_getBeginLoc(getBeginLoc_t Stmt::*) { return bad(); }
 
-  typedef SourceLocation getLocEnd_t() const;
-  template <class T> good implements_getEndLoc(getLocEnd_t T::*) {
-    return good();
-  }
-  LLVM_ATTRIBUTE_UNUSED
-  static bad implements_getEndLoc(getLocEnd_t Stmt::*) { return bad(); }
+typedef SourceLocation getLocEnd_t() const;
+template <class T> good implements_getEndLoc(getLocEnd_t T::*) {
+  return good();
+}
+LLVM_ATTRIBUTE_UNUSED
+static bad implements_getEndLoc(getLocEnd_t Stmt::*) { return bad(); }
 
-#define ASSERT_IMPLEMENTS_children(type) \
-  (void) is_good(implements_children(&type::children))
+#define ASSERT_IMPLEMENTS_children(type)                                       \
+  (void)is_good(implements_children(&type::children))
 #define ASSERT_IMPLEMENTS_getBeginLoc(type)                                    \
   (void)is_good(implements_getBeginLoc(&type::getBeginLoc))
 #define ASSERT_IMPLEMENTS_getEndLoc(type)                                      \
@@ -273,7 +269,7 @@
 /// Check whether the various Stmt classes implement their member
 /// functions.
 LLVM_ATTRIBUTE_UNUSED
-static inline void check_implementations() {
+inline static void check_implementations() {
 #define ABSTRACT_STMT(type)
 #define STMT(type, base)                                                       \
   ASSERT_IMPLEMENTS_children(type);                                            \
@@ -284,11 +280,12 @@
 
 Stmt::child_range Stmt::children() {
   switch (getStmtClass()) {
-  case Stmt::NoStmtClass: llvm_unreachable("statement without class");
+  case Stmt::NoStmtClass:
+    llvm_unreachable("statement without class");
 #define ABSTRACT_STMT(type)
-#define STMT(type, base) \
-  case Stmt::type##Class: \
-    return static_cast<type*>(this)->children();
+#define STMT(type, base)                                                       \
+  case Stmt::type##Class:                                                      \
+    return static_cast<type *>(this)->children();
 #include "clang/AST/StmtNodes.inc"
   }
   llvm_unreachable("unknown statement kind!");
@@ -300,33 +297,33 @@
 // See also Expr.cpp:getExprLoc().
 namespace {
 
-  /// This implementation is used when a class provides a custom
-  /// implementation of getSourceRange.
-  template <class S, class T>
-  SourceRange getSourceRangeImpl(const Stmt *stmt,
-                                 SourceRange (T::*v)() const) {
-    return static_cast<const S*>(stmt)->getSourceRange();
-  }
+/// This implementation is used when a class provides a custom
+/// implementation of getSourceRange.
+template <class S, class T>
+SourceRange getSourceRangeImpl(Stmt const *stmt, SourceRange (T::*v)() const) {
+  return static_cast<const S *>(stmt)->getSourceRange();
+}
 
-  /// This implementation is used when a class doesn't provide a custom
-  /// implementation of getSourceRange.  Overload resolution should pick it over
-  /// the implementation above because it's more specialized according to
-  /// function template partial ordering.
-  template <class S>
-  SourceRange getSourceRangeImpl(const Stmt *stmt,
-                                 SourceRange (Stmt::*v)() const) {
-    return SourceRange(static_cast<const S *>(stmt)->getBeginLoc(),
-                       static_cast<const S *>(stmt)->getEndLoc());
-  }
+/// This implementation is used when a class doesn't provide a custom
+/// implementation of getSourceRange.  Overload resolution should pick it over
+/// the implementation above because it's more specialized according to
+/// function template partial ordering.
+template <class S>
+SourceRange getSourceRangeImpl(Stmt const *stmt,
+                               SourceRange (Stmt::*v)() const) {
+  return SourceRange(static_cast<const S *>(stmt)->getBeginLoc(),
+                     static_cast<const S *>(stmt)->getEndLoc());
+}
 
 } // namespace
 
 SourceRange Stmt::getSourceRange() const {
   switch (getStmtClass()) {
-  case Stmt::NoStmtClass: llvm_unreachable("statement without class");
+  case Stmt::NoStmtClass:
+    llvm_unreachable("statement without class");
 #define ABSTRACT_STMT(type)
-#define STMT(type, base) \
-  case Stmt::type##Class: \
+#define STMT(type, base)                                                       \
+  case Stmt::type##Class:                                                      \
     return getSourceRangeImpl<type>(this, &type::getSourceRange);
 #include "clang/AST/StmtNodes.inc"
   }
@@ -335,11 +332,12 @@
 
 SourceLocation Stmt::getBeginLoc() const {
   switch (getStmtClass()) {
-  case Stmt::NoStmtClass: llvm_unreachable("statement without class");
+  case Stmt::NoStmtClass:
+    llvm_unreachable("statement without class");
 #define ABSTRACT_STMT(type)
 #define STMT(type, base)                                                       \
   case Stmt::type##Class:                                                      \
-    return static_cast<const type *>(this)->getBeginLoc();
+    return static_cast<type const *>(this)->getBeginLoc();
 #include "clang/AST/StmtNodes.inc"
   }
   llvm_unreachable("unknown statement kind");
@@ -347,17 +345,18 @@
 
 SourceLocation Stmt::getEndLoc() const {
   switch (getStmtClass()) {
-  case Stmt::NoStmtClass: llvm_unreachable("statement without class");
+  case Stmt::NoStmtClass:
+    llvm_unreachable("statement without class");
 #define ABSTRACT_STMT(type)
 #define STMT(type, base)                                                       \
   case Stmt::type##Class:                                                      \
-    return static_cast<const type *>(this)->getEndLoc();
+    return static_cast<type const *>(this)->getEndLoc();
 #include "clang/AST/StmtNodes.inc"
   }
   llvm_unreachable("unknown statement kind");
 }
 
-int64_t Stmt::getID(const ASTContext &Context) const {
+int64_t Stmt::getID(ASTContext const &Context) const {
   return Context.getAllocator().identifyKnownAlignedObject<Stmt>(this);
 }
 
@@ -376,14 +375,14 @@
   std::copy(Stmts.begin(), Stmts.end(), body_begin());
 }
 
-CompoundStmt *CompoundStmt::Create(const ASTContext &C, ArrayRef<Stmt *> Stmts,
+CompoundStmt *CompoundStmt::Create(ASTContext const &C, ArrayRef<Stmt *> Stmts,
                                    SourceLocation LB, SourceLocation RB) {
   void *Mem =
       C.Allocate(totalSizeToAlloc<Stmt *>(Stmts.size()), alignof(CompoundStmt));
   return new (Mem) CompoundStmt(Stmts, LB, RB);
 }
 
-CompoundStmt *CompoundStmt::CreateEmpty(const ASTContext &C,
+CompoundStmt *CompoundStmt::CreateEmpty(ASTContext const &C,
                                         unsigned NumStmts) {
   void *Mem =
       C.Allocate(totalSizeToAlloc<Stmt *>(NumStmts), alignof(CompoundStmt));
@@ -392,15 +391,15 @@
   return New;
 }
 
-const Expr *ValueStmt::getExprStmt() const {
-  const Stmt *S = this;
+Expr const *ValueStmt::getExprStmt() const {
+  Stmt const *S = this;
   do {
-    if (const auto *E = dyn_cast<Expr>(S))
+    if (auto const *E = dyn_cast<Expr>(S))
       return E;
 
-    if (const auto *LS = dyn_cast<LabelStmt>(S))
+    if (auto const *LS = dyn_cast<LabelStmt>(S))
       S = LS->getSubStmt();
-    else if (const auto *AS = dyn_cast<AttributedStmt>(S))
+    else if (auto const *AS = dyn_cast<AttributedStmt>(S))
       S = AS->getSubStmt();
     else
       llvm_unreachable("unknown kind of ValueStmt");
@@ -409,71 +408,71 @@
   return nullptr;
 }
 
-const char *LabelStmt::getName() const {
+char const *LabelStmt::getName() const {
   return getDecl()->getIdentifier()->getNameStart();
 }
 
-AttributedStmt *AttributedStmt::Create(const ASTContext &C, SourceLocation Loc,
-                                       ArrayRef<const Attr*> Attrs,
+AttributedStmt *AttributedStmt::Create(ASTContext const &C, SourceLocation Loc,
+                                       ArrayRef<Attr const *> Attrs,
                                        Stmt *SubStmt) {
   assert(!Attrs.empty() && "Attrs should not be empty");
-  void *Mem = C.Allocate(totalSizeToAlloc<const Attr *>(Attrs.size()),
+  void *Mem = C.Allocate(totalSizeToAlloc<Attr const *>(Attrs.size()),
                          alignof(AttributedStmt));
   return new (Mem) AttributedStmt(Loc, Attrs, SubStmt);
 }
 
-AttributedStmt *AttributedStmt::CreateEmpty(const ASTContext &C,
+AttributedStmt *AttributedStmt::CreateEmpty(ASTContext const &C,
                                             unsigned NumAttrs) {
   assert(NumAttrs > 0 && "NumAttrs should be greater than zero");
-  void *Mem = C.Allocate(totalSizeToAlloc<const Attr *>(NumAttrs),
+  void *Mem = C.Allocate(totalSizeToAlloc<Attr const *>(NumAttrs),
                          alignof(AttributedStmt));
   return new (Mem) AttributedStmt(EmptyShell(), NumAttrs);
 }
 
-std::string AsmStmt::generateAsmString(const ASTContext &C) const {
-  if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
+std::string AsmStmt::generateAsmString(ASTContext const &C) const {
+  if (auto const *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
     return gccAsmStmt->generateAsmString(C);
-  if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
+  if (auto const *msAsmStmt = dyn_cast<MSAsmStmt>(this))
     return msAsmStmt->generateAsmString(C);
   llvm_unreachable("unknown asm statement kind!");
 }
 
 StringRef AsmStmt::getOutputConstraint(unsigned i) const {
-  if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
+  if (auto const *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
     return gccAsmStmt->getOutputConstraint(i);
-  if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
+  if (auto const *msAsmStmt = dyn_cast<MSAsmStmt>(this))
     return msAsmStmt->getOutputConstraint(i);
   llvm_unreachable("unknown asm statement kind!");
 }
 
-const Expr *AsmStmt::getOutputExpr(unsigned i) const {
-  if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
+Expr const *AsmStmt::getOutputExpr(unsigned i) const {
+  if (auto const *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
     return gccAsmStmt->getOutputExpr(i);
-  if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
+  if (auto const *msAsmStmt = dyn_cast<MSAsmStmt>(this))
     return msAsmStmt->getOutputExpr(i);
   llvm_unreachable("unknown asm statement kind!");
 }
 
 StringRef AsmStmt::getInputConstraint(unsigned i) const {
-  if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
+  if (auto const *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
     return gccAsmStmt->getInputConstraint(i);
-  if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
+  if (auto const *msAsmStmt = dyn_cast<MSAsmStmt>(this))
     return msAsmStmt->getInputConstraint(i);
   llvm_unreachable("unknown asm statement kind!");
 }
 
-const Expr *AsmStmt::getInputExpr(unsigned i) const {
-  if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
+Expr const *AsmStmt::getInputExpr(unsigned i) const {
+  if (auto const *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
     return gccAsmStmt->getInputExpr(i);
-  if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
+  if (auto const *msAsmStmt = dyn_cast<MSAsmStmt>(this))
     return msAsmStmt->getInputExpr(i);
   llvm_unreachable("unknown asm statement kind!");
 }
 
 StringRef AsmStmt::getClobber(unsigned i) const {
-  if (const auto *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
+  if (auto const *gccAsmStmt = dyn_cast<GCCAsmStmt>(this))
     return gccAsmStmt->getClobber(i);
-  if (const auto *msAsmStmt = dyn_cast<MSAsmStmt>(this))
+  if (auto const *msAsmStmt = dyn_cast<MSAsmStmt>(this))
     return msAsmStmt->getClobber(i);
   llvm_unreachable("unknown asm statement kind!");
 }
@@ -497,9 +496,7 @@
   return getClobberStringLiteral(i)->getString();
 }
 
-Expr *GCCAsmStmt::getOutputExpr(unsigned i) {
-  return cast<Expr>(Exprs[i]);
-}
+Expr *GCCAsmStmt::getOutputExpr(unsigned i) { return cast<Expr>(Exprs[i]); }
 
 /// getOutputConstraint - Return the constraint string for the specified
 /// output operand.  All output constraints are known to be non-empty (either
@@ -530,15 +527,10 @@
   return getInputConstraintLiteral(i)->getString();
 }
 
-void GCCAsmStmt::setOutputsAndInputsAndClobbers(const ASTContext &C,
-                                                IdentifierInfo **Names,
-                                                StringLiteral **Constraints,
-                                                Stmt **Exprs,
-                                                unsigned NumOutputs,
-                                                unsigned NumInputs,
-                                                unsigned NumLabels,
-                                                StringLiteral **Clobbers,
-                                                unsigned NumClobbers) {
+void GCCAsmStmt::setOutputsAndInputsAndClobbers(
+    ASTContext const &C, IdentifierInfo **Names, StringLiteral **Constraints,
+    Stmt **Exprs, unsigned NumOutputs, unsigned NumInputs, unsigned NumLabels,
+    StringLiteral **Clobbers, unsigned NumClobbers) {
   this->NumOutputs = NumOutputs;
   this->NumInputs = NumInputs;
   this->NumClobbers = NumClobbers;
@@ -547,20 +539,20 @@
   unsigned NumExprs = NumOutputs + NumInputs + NumLabels;
 
   C.Deallocate(this->Names);
-  this->Names = new (C) IdentifierInfo*[NumExprs];
+  this->Names = new (C) IdentifierInfo *[NumExprs];
   std::copy(Names, Names + NumExprs, this->Names);
 
   C.Deallocate(this->Exprs);
-  this->Exprs = new (C) Stmt*[NumExprs];
+  this->Exprs = new (C) Stmt *[NumExprs];
   std::copy(Exprs, Exprs + NumExprs, this->Exprs);
 
   unsigned NumConstraints = NumOutputs + NumInputs;
   C.Deallocate(this->Constraints);
-  this->Constraints = new (C) StringLiteral*[NumConstraints];
+  this->Constraints = new (C) StringLiteral *[NumConstraints];
   std::copy(Constraints, Constraints + NumConstraints, this->Constraints);
 
   C.Deallocate(this->Clobbers);
-  this->Clobbers = new (C) StringLiteral*[NumClobbers];
+  this->Clobbers = new (C) StringLiteral *[NumClobbers];
   std::copy(Clobbers, Clobbers + NumClobbers, this->Clobbers);
 }
 
@@ -591,12 +583,13 @@
 /// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing
 /// it into pieces.  If the asm string is erroneous, emit errors and return
 /// true, otherwise return false.
-unsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece>&Pieces,
-                                const ASTContext &C, unsigned &DiagOffs) const {
+unsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece> &Pieces,
+                                      ASTContext const &C,
+                                      unsigned &DiagOffs) const {
   StringRef Str = getAsmString()->getString();
-  const char *StrStart = Str.begin();
-  const char *StrEnd = Str.end();
-  const char *CurPtr = StrStart;
+  char const *StrStart = Str.begin();
+  char const *StrEnd = Str.end();
+  char const *CurPtr = StrStart;
 
   // "Simple" inline asms have no constraints or operands, just convert the asm
   // string to escape $'s.
@@ -635,10 +628,18 @@
 
     char CurChar = *CurPtr++;
     switch (CurChar) {
-    case '$': CurStringPiece += "$$"; continue;
-    case '{': CurStringPiece += (HasVariants ? "$(" : "{"); continue;
-    case '|': CurStringPiece += (HasVariants ? "$|" : "|"); continue;
-    case '}': CurStringPiece += (HasVariants ? "$)" : "}"); continue;
+    case '$':
+      CurStringPiece += "$$";
+      continue;
+    case '{':
+      CurStringPiece += (HasVariants ? "$(" : "{");
+      continue;
+    case '|':
+      CurStringPiece += (HasVariants ? "$|" : "|");
+      continue;
+    case '}':
+      CurStringPiece += (HasVariants ? "$)" : "}");
+      continue;
     case '%':
       break;
     default:
@@ -646,12 +647,12 @@
       continue;
     }
 
-    const TargetInfo &TI = C.getTargetInfo();
+    TargetInfo const &TI = C.getTargetInfo();
 
     // Escaped "%" character in asm string.
     if (CurPtr == StrEnd) {
       // % at end of string is invalid (no escape).
-      DiagOffs = CurPtr-StrStart-1;
+      DiagOffs = CurPtr - StrStart - 1;
       return diag::err_asm_invalid_escape;
     }
     // Handle escaped char and continue looping over the asm string.
@@ -684,19 +685,19 @@
     // Handle operands that have asmSymbolicName (e.g., %x[foo]) and those that
     // don't (e.g., %x4). 'x' following the '%' is the constraint modifier.
 
-    const char *Begin = CurPtr - 1; // Points to the character following '%'.
-    const char *Percent = Begin - 1; // Points to '%'.
+    char const *Begin = CurPtr - 1;  // Points to the character following '%'.
+    char const *Percent = Begin - 1; // Points to '%'.
 
     if (isLetter(EscapedChar)) {
       if (CurPtr == StrEnd) { // Premature end.
-        DiagOffs = CurPtr-StrStart-1;
+        DiagOffs = CurPtr - StrStart - 1;
         return diag::err_asm_invalid_escape;
       }
       EscapedChar = *CurPtr++;
     }
 
-    const SourceManager &SM = C.getSourceManager();
-    const LangOptions &LO = C.getLangOpts();
+    SourceManager const &SM = C.getSourceManager();
+    LangOptions const &LO = C.getLangOpts();
 
     // Handle operands that don't have asmSymbolicName (e.g., %x4).
     if (isDigit(EscapedChar)) {
@@ -705,12 +706,12 @@
 
       --CurPtr;
       while (CurPtr != StrEnd && isDigit(*CurPtr))
-        N = N*10 + ((*CurPtr++)-'0');
+        N = N * 10 + ((*CurPtr++) - '0');
 
       unsigned NumOperands = getNumOutputs() + getNumPlusOperands() +
                              getNumInputs() + getNumLabels();
       if (N >= NumOperands) {
-        DiagOffs = CurPtr-StrStart-1;
+        DiagOffs = CurPtr - StrStart - 1;
         return diag::err_asm_invalid_operand_number;
       }
 
@@ -732,10 +733,10 @@
 
     // Handle operands that have asmSymbolicName (e.g., %x[foo]).
     if (EscapedChar == '[') {
-      DiagOffs = CurPtr-StrStart-1;
+      DiagOffs = CurPtr - StrStart - 1;
 
       // Find the ']'.
-      const char *NameEnd = (const char*)memchr(CurPtr, ']', StrEnd-CurPtr);
+      char const *NameEnd = (char const *)memchr(CurPtr, ']', StrEnd - CurPtr);
       if (NameEnd == nullptr)
         return diag::err_asm_unterminated_symbolic_operand_name;
       if (NameEnd == CurPtr)
@@ -746,7 +747,7 @@
       int N = getNamedOperand(SymbolicName);
       if (N == -1) {
         // Verify that an operand with that name exists.
-        DiagOffs = CurPtr-StrStart;
+        DiagOffs = CurPtr - StrStart;
         return diag::err_asm_unknown_symbolic_operand_name;
       }
 
@@ -764,17 +765,17 @@
 
       Pieces.emplace_back(N, std::move(Str), BeginLoc, EndLoc);
 
-      CurPtr = NameEnd+1;
+      CurPtr = NameEnd + 1;
       continue;
     }
 
-    DiagOffs = CurPtr-StrStart-1;
+    DiagOffs = CurPtr - StrStart - 1;
     return diag::err_asm_invalid_escape;
   }
 }
 
 /// Assemble final IR asm string (GCC-style).
-std::string GCCAsmStmt::generateAsmString(const ASTContext &C) const {
+std::string GCCAsmStmt::generateAsmString(ASTContext const &C) const {
   // Analyze the asm string to decompose it into its pieces.  We know that Sema
   // has already done this, so it is guaranteed to be successful.
   SmallVector<GCCAsmStmt::AsmStringPiece, 4> Pieces;
@@ -782,7 +783,7 @@
   AnalyzeAsmString(Pieces, C, DiagOffs);
 
   std::string AsmString;
-  for (const auto &Piece : Pieces) {
+  for (auto const &Piece : Pieces) {
     if (Piece.isString())
       AsmString += Piece.getString();
     else if (Piece.getModifier() == '\0')
@@ -795,7 +796,7 @@
 }
 
 /// Assemble final IR asm string (MS-style).
-std::string MSAsmStmt::generateAsmString(const ASTContext &C) const {
+std::string MSAsmStmt::generateAsmString(ASTContext const &C) const {
   // FIXME: This needs to be translated into the IR string representation.
   SmallVector<StringRef, 8> Pieces;
   AsmStr.split(Pieces, "\n\t");
@@ -820,23 +821,19 @@
   return MSAsmString;
 }
 
-Expr *MSAsmStmt::getOutputExpr(unsigned i) {
-  return cast<Expr>(Exprs[i]);
-}
+Expr *MSAsmStmt::getOutputExpr(unsigned i) { return cast<Expr>(Exprs[i]); }
 
 Expr *MSAsmStmt::getInputExpr(unsigned i) {
   return cast<Expr>(Exprs[i + NumOutputs]);
 }
 
-void MSAsmStmt::setInputExpr(unsigned i, Expr *E) {
-  Exprs[i + NumOutputs] = E;
-}
+void MSAsmStmt::setInputExpr(unsigned i, Expr *E) { Exprs[i + NumOutputs] = E; }
 
 //===----------------------------------------------------------------------===//
 // Constructors
 //===----------------------------------------------------------------------===//
 
-GCCAsmStmt::GCCAsmStmt(const ASTContext &C, SourceLocation asmloc,
+GCCAsmStmt::GCCAsmStmt(ASTContext const &C, SourceLocation asmloc,
                        bool issimple, bool isvolatile, unsigned numoutputs,
                        unsigned numinputs, IdentifierInfo **names,
                        StringLiteral **constraints, Expr **exprs,
@@ -845,44 +842,43 @@
                        SourceLocation rparenloc)
     : AsmStmt(GCCAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
               numinputs, numclobbers),
-              RParenLoc(rparenloc), AsmStr(asmstr), NumLabels(numlabels) {
+      RParenLoc(rparenloc), AsmStr(asmstr), NumLabels(numlabels) {
   unsigned NumExprs = NumOutputs + NumInputs + NumLabels;
 
-  Names = new (C) IdentifierInfo*[NumExprs];
+  Names = new (C) IdentifierInfo *[NumExprs];
   std::copy(names, names + NumExprs, Names);
 
-  Exprs = new (C) Stmt*[NumExprs];
+  Exprs = new (C) Stmt *[NumExprs];
   std::copy(exprs, exprs + NumExprs, Exprs);
 
   unsigned NumConstraints = NumOutputs + NumInputs;
-  Constraints = new (C) StringLiteral*[NumConstraints];
+  Constraints = new (C) StringLiteral *[NumConstraints];
   std::copy(constraints, constraints + NumConstraints, Constraints);
 
-  Clobbers = new (C) StringLiteral*[NumClobbers];
+  Clobbers = new (C) StringLiteral *[NumClobbers];
   std::copy(clobbers, clobbers + NumClobbers, Clobbers);
 }
 
-MSAsmStmt::MSAsmStmt(const ASTContext &C, SourceLocation asmloc,
+MSAsmStmt::MSAsmStmt(ASTContext const &C, SourceLocation asmloc,
                      SourceLocation lbraceloc, bool issimple, bool isvolatile,
                      ArrayRef<Token> asmtoks, unsigned numoutputs,
-                     unsigned numinputs,
-                     ArrayRef<StringRef> constraints, ArrayRef<Expr*> exprs,
-                     StringRef asmstr, ArrayRef<StringRef> clobbers,
-                     SourceLocation endloc)
+                     unsigned numinputs, ArrayRef<StringRef> constraints,
+                     ArrayRef<Expr *> exprs, StringRef asmstr,
+                     ArrayRef<StringRef> clobbers, SourceLocation endloc)
     : AsmStmt(MSAsmStmtClass, asmloc, issimple, isvolatile, numoutputs,
-              numinputs, clobbers.size()), LBraceLoc(lbraceloc),
-              EndLoc(endloc), NumAsmToks(asmtoks.size()) {
+              numinputs, clobbers.size()),
+      LBraceLoc(lbraceloc), EndLoc(endloc), NumAsmToks(asmtoks.size()) {
   initialize(C, asmstr, asmtoks, constraints, exprs, clobbers);
 }
 
-static StringRef copyIntoContext(const ASTContext &C, StringRef str) {
+static StringRef copyIntoContext(ASTContext const &C, StringRef str) {
   return str.copy(C);
 }
 
-void MSAsmStmt::initialize(const ASTContext &C, StringRef asmstr,
+void MSAsmStmt::initialize(ASTContext const &C, StringRef asmstr,
                            ArrayRef<Token> asmtoks,
                            ArrayRef<StringRef> constraints,
-                           ArrayRef<Expr*> exprs,
+                           ArrayRef<Expr *> exprs,
                            ArrayRef<StringRef> clobbers) {
   assert(NumAsmToks == asmtoks.size());
   assert(NumClobbers == clobbers.size());
@@ -892,27 +888,25 @@
 
   AsmStr = copyIntoContext(C, asmstr);
 
-  Exprs = new (C) Stmt*[exprs.size()];
+  Exprs = new (C) Stmt *[exprs.size()];
   std::copy(exprs.begin(), exprs.end(), Exprs);
 
   AsmToks = new (C) Token[asmtoks.size()];
   std::copy(asmtoks.begin(), asmtoks.end(), AsmToks);
 
   Constraints = new (C) StringRef[exprs.size()];
-  std::transform(constraints.begin(), constraints.end(), Constraints,
-                 [&](StringRef Constraint) {
-                   return copyIntoContext(C, Constraint);
-                 });
+  std::transform(
+      constraints.begin(), constraints.end(), Constraints,
+      [&](StringRef Constraint) { return copyIntoContext(C, Constraint); });
 
   Clobbers = new (C) StringRef[NumClobbers];
   // FIXME: Avoid the allocation/copy if at all possible.
-  std::transform(clobbers.begin(), clobbers.end(), Clobbers,
-                 [&](StringRef Clobber) {
-                   return copyIntoContext(C, Clobber);
-                 });
+  std::transform(
+      clobbers.begin(), clobbers.end(), Clobbers,
+      [&](StringRef Clobber) { return copyIntoContext(C, Clobber); });
 }
 
-IfStmt::IfStmt(const ASTContext &Ctx, SourceLocation IL, bool IsConstexpr,
+IfStmt::IfStmt(ASTContext const &Ctx, SourceLocation IL, bool IsConstexpr,
                Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LPL,
                SourceLocation RPL, Stmt *Then, SourceLocation EL, Stmt *Else)
     : Stmt(IfStmtClass), LParenLoc(LPL), RParenLoc(RPL) {
@@ -946,7 +940,7 @@
   IfStmtBits.HasInit = HasInit;
 }
 
-IfStmt *IfStmt::Create(const ASTContext &Ctx, SourceLocation IL,
+IfStmt *IfStmt::Create(ASTContext const &Ctx, SourceLocation IL,
                        bool IsConstexpr, Stmt *Init, VarDecl *Var, Expr *Cond,
                        SourceLocation LPL, SourceLocation RPL, Stmt *Then,
                        SourceLocation EL, Stmt *Else) {
@@ -961,7 +955,7 @@
       IfStmt(Ctx, IL, IsConstexpr, Init, Var, Cond, LPL, RPL, Then, EL, Else);
 }
 
-IfStmt *IfStmt::CreateEmpty(const ASTContext &Ctx, bool HasElse, bool HasVar,
+IfStmt *IfStmt::CreateEmpty(ASTContext const &Ctx, bool HasElse, bool HasVar,
                             bool HasInit) {
   void *Mem = Ctx.Allocate(
       totalSizeToAlloc<Stmt *, SourceLocation>(
@@ -977,7 +971,7 @@
   return cast<VarDecl>(DS->getSingleDecl());
 }
 
-void IfStmt::setConditionVariable(const ASTContext &Ctx, VarDecl *V) {
+void IfStmt::setConditionVariable(ASTContext const &Ctx, VarDecl *V) {
   assert(hasVarStorage() &&
          "This if statement has no storage for a condition variable!");
 
@@ -995,25 +989,24 @@
   return isa<ObjCAvailabilityCheckExpr>(getCond());
 }
 
-Optional<Stmt *> IfStmt::getNondiscardedCase(const ASTContext &Ctx) {
+Optional<Stmt *> IfStmt::getNondiscardedCase(ASTContext const &Ctx) {
   if (!isConstexpr() || getCond()->isValueDependent())
     return None;
   return !getCond()->EvaluateKnownConstInt(Ctx) ? getElse() : getThen();
 }
 
-Optional<const Stmt *>
-IfStmt::getNondiscardedCase(const ASTContext &Ctx) const {
+Optional<Stmt const *>
+IfStmt::getNondiscardedCase(ASTContext const &Ctx) const {
   if (Optional<Stmt *> Result =
           const_cast<IfStmt *>(this)->getNondiscardedCase(Ctx))
     return *Result;
   return None;
 }
 
-ForStmt::ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
+ForStmt::ForStmt(ASTContext const &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
                  Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
                  SourceLocation RP)
-  : Stmt(ForStmtClass), LParenLoc(LP), RParenLoc(RP)
-{
+    : Stmt(ForStmtClass), LParenLoc(LP), RParenLoc(RP) {
   SubExprs[INIT] = Init;
   setConditionVariable(C, condVar);
   SubExprs[COND] = Cond;
@@ -1030,18 +1023,18 @@
   return cast<VarDecl>(DS->getSingleDecl());
 }
 
-void ForStmt::setConditionVariable(const ASTContext &C, VarDecl *V) {
+void ForStmt::setConditionVariable(ASTContext const &C, VarDecl *V) {
   if (!V) {
     SubExprs[CONDVAR] = nullptr;
     return;
   }
 
   SourceRange VarRange = V->getSourceRange();
-  SubExprs[CONDVAR] = new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(),
-                                       VarRange.getEnd());
+  SubExprs[CONDVAR] =
+      new (C) DeclStmt(DeclGroupRef(V), VarRange.getBegin(), VarRange.getEnd());
 }
 
-SwitchStmt::SwitchStmt(const ASTContext &Ctx, Stmt *Init, VarDecl *Var,
+SwitchStmt::SwitchStmt(ASTContext const &Ctx, Stmt *Init, VarDecl *Var,
                        Expr *Cond, SourceLocation LParenLoc,
                        SourceLocation RParenLoc)
     : Stmt(SwitchStmtClass), FirstCase(nullptr), LParenLoc(LParenLoc),
@@ -1069,7 +1062,7 @@
   SwitchStmtBits.AllEnumCasesCovered = false;
 }
 
-SwitchStmt *SwitchStmt::Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var,
+SwitchStmt *SwitchStmt::Create(ASTContext const &Ctx, Stmt *Init, VarDecl *Var,
                                Expr *Cond, SourceLocation LParenLoc,
                                SourceLocation RParenLoc) {
   bool HasInit = Init != nullptr;
@@ -1080,7 +1073,7 @@
   return new (Mem) SwitchStmt(Ctx, Init, Var, Cond, LParenLoc, RParenLoc);
 }
 
-SwitchStmt *SwitchStmt::CreateEmpty(const ASTContext &Ctx, bool HasInit,
+SwitchStmt *SwitchStmt::CreateEmpty(ASTContext const &Ctx, bool HasInit,
                                     bool HasVar) {
   void *Mem = Ctx.Allocate(
       totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasInit + HasVar),
@@ -1095,7 +1088,7 @@
   return cast<VarDecl>(DS->getSingleDecl());
 }
 
-void SwitchStmt::setConditionVariable(const ASTContext &Ctx, VarDecl *V) {
+void SwitchStmt::setConditionVariable(ASTContext const &Ctx, VarDecl *V) {
   assert(hasVarStorage() &&
          "This switch statement has no storage for a condition variable!");
 
@@ -1109,7 +1102,7 @@
       DeclStmt(DeclGroupRef(V), VarRange.getBegin(), VarRange.getEnd());
 }
 
-WhileStmt::WhileStmt(const ASTContext &Ctx, VarDecl *Var, Expr *Cond,
+WhileStmt::WhileStmt(ASTContext const &Ctx, VarDecl *Var, Expr *Cond,
                      Stmt *Body, SourceLocation WL, SourceLocation LParenLoc,
                      SourceLocation RParenLoc)
     : Stmt(WhileStmtClass) {
@@ -1131,7 +1124,7 @@
   WhileStmtBits.HasVar = HasVar;
 }
 
-WhileStmt *WhileStmt::Create(const ASTContext &Ctx, VarDecl *Var, Expr *Cond,
+WhileStmt *WhileStmt::Create(ASTContext const &Ctx, VarDecl *Var, Expr *Cond,
                              Stmt *Body, SourceLocation WL,
                              SourceLocation LParenLoc,
                              SourceLocation RParenLoc) {
@@ -1142,7 +1135,7 @@
   return new (Mem) WhileStmt(Ctx, Var, Cond, Body, WL, LParenLoc, RParenLoc);
 }
 
-WhileStmt *WhileStmt::CreateEmpty(const ASTContext &Ctx, bool HasVar) {
+WhileStmt *WhileStmt::CreateEmpty(ASTContext const &Ctx, bool HasVar) {
   void *Mem =
       Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasVar),
                    alignof(WhileStmt));
@@ -1156,7 +1149,7 @@
   return cast<VarDecl>(DS->getSingleDecl());
 }
 
-void WhileStmt::setConditionVariable(const ASTContext &Ctx, VarDecl *V) {
+void WhileStmt::setConditionVariable(ASTContext const &Ctx, VarDecl *V) {
   assert(hasVarStorage() &&
          "This while statement has no storage for a condition variable!");
 
@@ -1178,7 +1171,7 @@
 }
 
 // ReturnStmt
-ReturnStmt::ReturnStmt(SourceLocation RL, Expr *E, const VarDecl *NRVOCandidate)
+ReturnStmt::ReturnStmt(SourceLocation RL, Expr *E, VarDecl const *NRVOCandidate)
     : Stmt(ReturnStmtClass), RetExpr(E) {
   bool HasNRVOCandidate = NRVOCandidate != nullptr;
   ReturnStmtBits.HasNRVOCandidate = HasNRVOCandidate;
@@ -1192,23 +1185,23 @@
   ReturnStmtBits.HasNRVOCandidate = HasNRVOCandidate;
 }
 
-ReturnStmt *ReturnStmt::Create(const ASTContext &Ctx, SourceLocation RL,
-                               Expr *E, const VarDecl *NRVOCandidate) {
+ReturnStmt *ReturnStmt::Create(ASTContext const &Ctx, SourceLocation RL,
+                               Expr *E, VarDecl const *NRVOCandidate) {
   bool HasNRVOCandidate = NRVOCandidate != nullptr;
-  void *Mem = Ctx.Allocate(totalSizeToAlloc<const VarDecl *>(HasNRVOCandidate),
+  void *Mem = Ctx.Allocate(totalSizeToAlloc<VarDecl const *>(HasNRVOCandidate),
                            alignof(ReturnStmt));
   return new (Mem) ReturnStmt(RL, E, NRVOCandidate);
 }
 
-ReturnStmt *ReturnStmt::CreateEmpty(const ASTContext &Ctx,
+ReturnStmt *ReturnStmt::CreateEmpty(ASTContext const &Ctx,
                                     bool HasNRVOCandidate) {
-  void *Mem = Ctx.Allocate(totalSizeToAlloc<const VarDecl *>(HasNRVOCandidate),
+  void *Mem = Ctx.Allocate(totalSizeToAlloc<VarDecl const *>(HasNRVOCandidate),
                            alignof(ReturnStmt));
   return new (Mem) ReturnStmt(EmptyShell(), HasNRVOCandidate);
 }
 
 // CaseStmt
-CaseStmt *CaseStmt::Create(const ASTContext &Ctx, Expr *lhs, Expr *rhs,
+CaseStmt *CaseStmt::Create(ASTContext const &Ctx, Expr *lhs, Expr *rhs,
                            SourceLocation caseLoc, SourceLocation ellipsisLoc,
                            SourceLocation colonLoc) {
   bool CaseStmtIsGNURange = rhs != nullptr;
@@ -1219,7 +1212,7 @@
   return new (Mem) CaseStmt(lhs, rhs, caseLoc, ellipsisLoc, colonLoc);
 }
 
-CaseStmt *CaseStmt::CreateEmpty(const ASTContext &Ctx,
+CaseStmt *CaseStmt::CreateEmpty(ASTContext const &Ctx,
                                 bool CaseStmtIsGNURange) {
   void *Mem = Ctx.Allocate(
       totalSizeToAlloc<Stmt *, SourceLocation>(
@@ -1231,41 +1224,41 @@
 SEHTryStmt::SEHTryStmt(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock,
                        Stmt *Handler)
     : Stmt(SEHTryStmtClass), IsCXXTry(IsCXXTry), TryLoc(TryLoc) {
-  Children[TRY]     = TryBlock;
+  Children[TRY] = TryBlock;
   Children[HANDLER] = Handler;
 }
 
-SEHTryStmt* SEHTryStmt::Create(const ASTContext &C, bool IsCXXTry,
+SEHTryStmt *SEHTryStmt::Create(ASTContext const &C, bool IsCXXTry,
                                SourceLocation TryLoc, Stmt *TryBlock,
                                Stmt *Handler) {
-  return new(C) SEHTryStmt(IsCXXTry,TryLoc,TryBlock,Handler);
+  return new (C) SEHTryStmt(IsCXXTry, TryLoc, TryBlock, Handler);
 }
 
-SEHExceptStmt* SEHTryStmt::getExceptHandler() const {
+SEHExceptStmt *SEHTryStmt::getExceptHandler() const {
   return dyn_cast<SEHExceptStmt>(getHandler());
 }
 
-SEHFinallyStmt* SEHTryStmt::getFinallyHandler() const {
+SEHFinallyStmt *SEHTryStmt::getFinallyHandler() const {
   return dyn_cast<SEHFinallyStmt>(getHandler());
 }
 
 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)
     : Stmt(SEHExceptStmtClass), Loc(Loc) {
   Children[FILTER_EXPR] = FilterExpr;
-  Children[BLOCK]       = Block;
+  Children[BLOCK] = Block;
 }
 
-SEHExceptStmt* SEHExceptStmt::Create(const ASTContext &C, SourceLocation Loc,
+SEHExceptStmt *SEHExceptStmt::Create(ASTContext const &C, SourceLocation Loc,
                                      Expr *FilterExpr, Stmt *Block) {
-  return new(C) SEHExceptStmt(Loc,FilterExpr,Block);
+  return new (C) SEHExceptStmt(Loc, FilterExpr, Block);
 }
 
 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc, Stmt *Block)
     : Stmt(SEHFinallyStmtClass), Loc(Loc), Block(Block) {}
 
-SEHFinallyStmt* SEHFinallyStmt::Create(const ASTContext &C, SourceLocation Loc,
+SEHFinallyStmt *SEHFinallyStmt::Create(ASTContext const &C, SourceLocation Loc,
                                        Stmt *Block) {
-  return new(C)SEHFinallyStmt(Loc,Block);
+  return new (C) SEHFinallyStmt(Loc, Block);
 }
 
 CapturedStmt::Capture::Capture(SourceLocation Loc, VariableCaptureKind Kind,
@@ -1306,18 +1299,17 @@
   unsigned FirstCaptureOffset = llvm::alignTo(Size, alignof(Capture));
 
   return reinterpret_cast<Capture *>(
-      reinterpret_cast<char *>(const_cast<CapturedStmt *>(this))
-      + FirstCaptureOffset);
+      reinterpret_cast<char *>(const_cast<CapturedStmt *>(this)) +
+      FirstCaptureOffset);
 }
 
 CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind,
                            ArrayRef<Capture> Captures,
-                           ArrayRef<Expr *> CaptureInits,
-                           CapturedDecl *CD,
+                           ArrayRef<Expr *> CaptureInits, CapturedDecl *CD,
                            RecordDecl *RD)
-  : Stmt(CapturedStmtClass), NumCaptures(Captures.size()),
-    CapDeclAndKind(CD, Kind), TheRecordDecl(RD) {
-  assert( S && "null captured statement");
+    : Stmt(CapturedStmtClass), NumCaptures(Captures.size()),
+      CapDeclAndKind(CD, Kind), TheRecordDecl(RD) {
+  assert(S && "null captured statement");
   assert(CD && "null captured declaration for captured statement");
   assert(RD && "null record declaration for captured statement");
 
@@ -1335,17 +1327,16 @@
 }
 
 CapturedStmt::CapturedStmt(EmptyShell Empty, unsigned NumCaptures)
-  : Stmt(CapturedStmtClass, Empty), NumCaptures(NumCaptures),
-    CapDeclAndKind(nullptr, CR_Default) {
+    : Stmt(CapturedStmtClass, Empty), NumCaptures(NumCaptures),
+      CapDeclAndKind(nullptr, CR_Default) {
   getStoredStmts()[NumCaptures] = nullptr;
 }
 
-CapturedStmt *CapturedStmt::Create(const ASTContext &Context, Stmt *S,
+CapturedStmt *CapturedStmt::Create(ASTContext const &Context, Stmt *S,
                                    CapturedRegionKind Kind,
                                    ArrayRef<Capture> Captures,
                                    ArrayRef<Expr *> CaptureInits,
-                                   CapturedDecl *CD,
-                                   RecordDecl *RD) {
+                                   CapturedDecl *CD, RecordDecl *RD) {
   // The layout is
   //
   // -----------------------------------------------------------
@@ -1368,7 +1359,7 @@
   return new (Mem) CapturedStmt(S, Kind, Captures, CaptureInits, CD, RD);
 }
 
-CapturedStmt *CapturedStmt::CreateDeserialized(const ASTContext &Context,
+CapturedStmt *CapturedStmt::CreateDeserialized(ASTContext const &Context,
                                                unsigned NumCaptures) {
   unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
   if (NumCaptures > 0) {
@@ -1394,7 +1385,7 @@
   return CapDeclAndKind.getPointer();
 }
 
-const CapturedDecl *CapturedStmt::getCapturedDecl() const {
+CapturedDecl const *CapturedStmt::getCapturedDecl() const {
   return CapDeclAndKind.getPointer();
 }
 
@@ -1414,8 +1405,8 @@
   CapDeclAndKind.setInt(Kind);
 }
 
-bool CapturedStmt::capturesVariable(const VarDecl *Var) const {
-  for (const auto &I : captures()) {
+bool CapturedStmt::capturesVariable(VarDecl const *Var) const {
+  for (auto const &I : captures()) {
     if (!I.capturesVariable() && !I.capturesVariableByCopy())
       continue;
     if (I.getCapturedVar()->getCanonicalDecl() == Var->getCanonicalDecl())
Index: clang/lib/AST/StmtCXX.cpp
===================================================================
--- clang/lib/AST/StmtCXX.cpp
+++ clang/lib/AST/StmtCXX.cpp
@@ -22,14 +22,14 @@
   return QualType();
 }
 
-CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, SourceLocation tryLoc,
+CXXTryStmt *CXXTryStmt::Create(ASTContext const &C, SourceLocation tryLoc,
                                Stmt *tryBlock, ArrayRef<Stmt *> handlers) {
   const size_t Size = totalSizeToAlloc<Stmt *>(handlers.size() + 1);
   void *Mem = C.Allocate(Size, alignof(CXXTryStmt));
   return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers);
 }
 
-CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, EmptyShell Empty,
+CXXTryStmt *CXXTryStmt::Create(ASTContext const &C, EmptyShell Empty,
                                unsigned numHandlers) {
   const size_t Size = totalSizeToAlloc<Stmt *>(numHandlers + 1);
   void *Mem = C.Allocate(Size, alignof(CXXTryStmt));
@@ -69,7 +69,7 @@
   return RangeDecl->getInit();
 }
 
-const Expr *CXXForRangeStmt::getRangeInit() const {
+Expr const *CXXForRangeStmt::getRangeInit() const {
   return const_cast<CXXForRangeStmt *>(this)->getRangeInit();
 }
 
@@ -79,12 +79,13 @@
   return cast<VarDecl>(LV);
 }
 
-const VarDecl *CXXForRangeStmt::getLoopVariable() const {
+VarDecl const *CXXForRangeStmt::getLoopVariable() const {
   return const_cast<CXXForRangeStmt *>(this)->getLoopVariable();
 }
 
-CoroutineBodyStmt *CoroutineBodyStmt::Create(
-    const ASTContext &C, CoroutineBodyStmt::CtorArgs const &Args) {
+CoroutineBodyStmt *
+CoroutineBodyStmt::Create(ASTContext const &C,
+                          CoroutineBodyStmt::CtorArgs const &Args) {
   std::size_t Size = totalSizeToAlloc<Stmt *>(
       CoroutineBodyStmt::FirstParamMove + Args.ParamMoves.size());
 
@@ -92,10 +93,10 @@
   return new (Mem) CoroutineBodyStmt(Args);
 }
 
-CoroutineBodyStmt *CoroutineBodyStmt::Create(const ASTContext &C, EmptyShell,
+CoroutineBodyStmt *CoroutineBodyStmt::Create(ASTContext const &C, EmptyShell,
                                              unsigned NumParams) {
-  std::size_t Size = totalSizeToAlloc<Stmt *>(
-      CoroutineBodyStmt::FirstParamMove + NumParams);
+  std::size_t Size =
+      totalSizeToAlloc<Stmt *>(CoroutineBodyStmt::FirstParamMove + NumParams);
 
   void *Mem = C.Allocate(Size, alignof(CoroutineBodyStmt));
   auto *Result = new (Mem) CoroutineBodyStmt(CtorArgs());
Index: clang/lib/AST/StmtIterator.cpp
===================================================================
--- clang/lib/AST/StmtIterator.cpp
+++ clang/lib/AST/StmtIterator.cpp
@@ -22,9 +22,9 @@
 
 // FIXME: Add support for dependent-sized array types in C++?
 // Does it even make sense to build a CFG for an uninstantiated template?
-static inline const VariableArrayType *FindVA(const Type* t) {
-  while (const ArrayType *vt = dyn_cast<ArrayType>(t)) {
-    if (const VariableArrayType *vat = dyn_cast<VariableArrayType>(vt))
+inline static VariableArrayType const *FindVA(Type const *t) {
+  while (ArrayType const *vt = dyn_cast<ArrayType>(t)) {
+    if (VariableArrayType const *vat = dyn_cast<VariableArrayType>(vt))
       if (vat->getSizeExpr())
         return vat;
 
@@ -37,7 +37,7 @@
 void StmtIteratorBase::NextVA() {
   assert(getVAPtr());
 
-  const VariableArrayType *p = getVAPtr();
+  VariableArrayType const *p = getVAPtr();
   p = FindVA(p->getElementType().getTypePtr());
   setVAPtr(p);
 
@@ -45,13 +45,12 @@
     return;
 
   if (inDeclGroup()) {
-    if (VarDecl* VD = dyn_cast<VarDecl>(*DGI))
+    if (VarDecl *VD = dyn_cast<VarDecl>(*DGI))
       if (VD->hasInit())
         return;
 
     NextDecl();
-  }
-  else {
+  } else {
     assert(inSizeOfTypeVA());
     RawVAPtr = 0;
   }
@@ -64,31 +63,29 @@
   if (ImmediateAdvance)
     ++DGI;
 
-  for ( ; DGI != DGE; ++DGI)
+  for (; DGI != DGE; ++DGI)
     if (HandleDecl(*DGI))
       return;
 
   RawVAPtr = 0;
 }
 
-bool StmtIteratorBase::HandleDecl(Decl* D) {
-  if (VarDecl* VD = dyn_cast<VarDecl>(D)) {
-    if (const VariableArrayType* VAPtr = FindVA(VD->getType().getTypePtr())) {
+bool StmtIteratorBase::HandleDecl(Decl *D) {
+  if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
+    if (VariableArrayType const *VAPtr = FindVA(VD->getType().getTypePtr())) {
       setVAPtr(VAPtr);
       return true;
     }
 
     if (VD->getInit())
       return true;
-  }
-  else if (TypedefNameDecl* TD = dyn_cast<TypedefNameDecl>(D)) {
-    if (const VariableArrayType* VAPtr =
-        FindVA(TD->getUnderlyingType().getTypePtr())) {
+  } else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
+    if (VariableArrayType const *VAPtr =
+            FindVA(TD->getUnderlyingType().getTypePtr())) {
       setVAPtr(VAPtr);
       return true;
     }
-  }
-  else if (EnumConstantDecl* ECD = dyn_cast<EnumConstantDecl>(D)) {
+  } else if (EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(D)) {
     if (ECD->getInitExpr())
       return true;
   }
@@ -96,23 +93,23 @@
   return false;
 }
 
-StmtIteratorBase::StmtIteratorBase(Decl** dgi, Decl** dge)
+StmtIteratorBase::StmtIteratorBase(Decl **dgi, Decl **dge)
     : DGI(dgi), RawVAPtr(DeclGroupMode), DGE(dge) {
   NextDecl(false);
 }
 
-StmtIteratorBase::StmtIteratorBase(const VariableArrayType* t)
+StmtIteratorBase::StmtIteratorBase(VariableArrayType const *t)
     : DGI(nullptr), RawVAPtr(SizeOfTypeVAMode) {
   RawVAPtr |= reinterpret_cast<uintptr_t>(t);
 }
 
-Stmt*& StmtIteratorBase::GetDeclExpr() const {
-  if (const VariableArrayType* VAPtr = getVAPtr()) {
+Stmt *&StmtIteratorBase::GetDeclExpr() const {
+  if (VariableArrayType const *VAPtr = getVAPtr()) {
     assert(VAPtr->SizeExpr);
-    return const_cast<Stmt*&>(VAPtr->SizeExpr);
+    return const_cast<Stmt *&>(VAPtr->SizeExpr);
   }
 
   assert(inDeclGroup());
-  VarDecl* VD = cast<VarDecl>(*DGI);
+  VarDecl *VD = cast<VarDecl>(*DGI);
   return *VD->getInitAddress();
 }
Index: clang/lib/AST/StmtObjC.cpp
===================================================================
--- clang/lib/AST/StmtObjC.cpp
+++ clang/lib/AST/StmtObjC.cpp
@@ -12,8 +12,8 @@
 
 #include "clang/AST/StmtObjC.h"
 
-#include "clang/AST/Expr.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/Expr.h"
 
 using namespace clang;
 
@@ -42,7 +42,7 @@
     Stmts[NumCatchStmts + 1] = atFinallyStmt;
 }
 
-ObjCAtTryStmt *ObjCAtTryStmt::Create(const ASTContext &Context,
+ObjCAtTryStmt *ObjCAtTryStmt::Create(ASTContext const &Context,
                                      SourceLocation atTryLoc, Stmt *atTryStmt,
                                      Stmt **CatchStmts, unsigned NumCatchStmts,
                                      Stmt *atFinallyStmt) {
@@ -54,7 +54,7 @@
                                  atFinallyStmt);
 }
 
-ObjCAtTryStmt *ObjCAtTryStmt::CreateEmpty(const ASTContext &Context,
+ObjCAtTryStmt *ObjCAtTryStmt::CreateEmpty(ASTContext const &Context,
                                           unsigned NumCatchStmts,
                                           bool HasFinally) {
   unsigned Size =
Index: clang/lib/AST/StmtOpenMP.cpp
===================================================================
--- clang/lib/AST/StmtOpenMP.cpp
+++ clang/lib/AST/StmtOpenMP.cpp
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/ASTContext.h"
 #include "clang/AST/StmtOpenMP.h"
+#include "clang/AST/ASTContext.h"
 
 using namespace clang;
 using namespace llvm::omp;
@@ -254,7 +254,7 @@
 }
 
 OMPParallelDirective *OMPParallelDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
     bool HasCancel) {
   auto *Dir = createDirective<OMPParallelDirective>(
@@ -264,7 +264,7 @@
   return Dir;
 }
 
-OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
+OMPParallelDirective *OMPParallelDirective::CreateEmpty(ASTContext const &C,
                                                         unsigned NumClauses,
                                                         EmptyShell) {
   return createEmptyDirective<OMPParallelDirective>(C, NumClauses,
@@ -273,10 +273,10 @@
 }
 
 OMPSimdDirective *
-OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPSimdDirective::Create(ASTContext const &C, SourceLocation StartLoc,
                          SourceLocation EndLoc, unsigned CollapsedNum,
                          ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-                         const HelperExprs &Exprs) {
+                         HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPSimdDirective>(
       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_simd),
       StartLoc, EndLoc, CollapsedNum);
@@ -299,7 +299,7 @@
   return Dir;
 }
 
-OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
+OMPSimdDirective *OMPSimdDirective::CreateEmpty(ASTContext const &C,
                                                 unsigned NumClauses,
                                                 unsigned CollapsedNum,
                                                 EmptyShell) {
@@ -309,9 +309,9 @@
 }
 
 OMPForDirective *OMPForDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
+    HelperExprs const &Exprs, Expr *TaskRedRef, bool HasCancel) {
   auto *Dir = createDirective<OMPForDirective>(
       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for) + 1,
       StartLoc, EndLoc, CollapsedNum);
@@ -344,7 +344,7 @@
   return Dir;
 }
 
-OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
+OMPForDirective *OMPForDirective::CreateEmpty(ASTContext const &C,
                                               unsigned NumClauses,
                                               unsigned CollapsedNum,
                                               EmptyShell) {
@@ -354,7 +354,7 @@
 }
 
 OMPTileDirective *
-OMPTileDirective::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPTileDirective::Create(ASTContext const &C, SourceLocation StartLoc,
                          SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
                          unsigned NumLoops, Stmt *AssociatedStmt,
                          Stmt *TransformedStmt, Stmt *PreInits) {
@@ -366,7 +366,7 @@
   return Dir;
 }
 
-OMPTileDirective *OMPTileDirective::CreateEmpty(const ASTContext &C,
+OMPTileDirective *OMPTileDirective::CreateEmpty(ASTContext const &C,
                                                 unsigned NumClauses,
                                                 unsigned NumLoops) {
   return createEmptyDirective<OMPTileDirective>(
@@ -375,7 +375,7 @@
 }
 
 OMPUnrollDirective *
-OMPUnrollDirective::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPUnrollDirective::Create(ASTContext const &C, SourceLocation StartLoc,
                            SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
                            Stmt *AssociatedStmt, Stmt *TransformedStmt,
                            Stmt *PreInits) {
@@ -386,7 +386,7 @@
   return Dir;
 }
 
-OMPUnrollDirective *OMPUnrollDirective::CreateEmpty(const ASTContext &C,
+OMPUnrollDirective *OMPUnrollDirective::CreateEmpty(ASTContext const &C,
                                                     unsigned NumClauses) {
   return createEmptyDirective<OMPUnrollDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1,
@@ -394,10 +394,10 @@
 }
 
 OMPForSimdDirective *
-OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPForSimdDirective::Create(ASTContext const &C, SourceLocation StartLoc,
                             SourceLocation EndLoc, unsigned CollapsedNum,
                             ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-                            const HelperExprs &Exprs) {
+                            HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPForSimdDirective>(
       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd),
       StartLoc, EndLoc, CollapsedNum);
@@ -428,7 +428,7 @@
   return Dir;
 }
 
-OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
+OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(ASTContext const &C,
                                                       unsigned NumClauses,
                                                       unsigned CollapsedNum,
                                                       EmptyShell) {
@@ -438,7 +438,7 @@
 }
 
 OMPSectionsDirective *OMPSectionsDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
     bool HasCancel) {
   auto *Dir = createDirective<OMPSectionsDirective>(C, Clauses, AssociatedStmt,
@@ -449,7 +449,7 @@
   return Dir;
 }
 
-OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
+OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(ASTContext const &C,
                                                         unsigned NumClauses,
                                                         EmptyShell) {
   return createEmptyDirective<OMPSectionsDirective>(C, NumClauses,
@@ -457,7 +457,7 @@
                                                     /*NumChildren=*/1);
 }
 
-OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
+OMPSectionDirective *OMPSectionDirective::Create(ASTContext const &C,
                                                  SourceLocation StartLoc,
                                                  SourceLocation EndLoc,
                                                  Stmt *AssociatedStmt,
@@ -469,13 +469,13 @@
   return Dir;
 }
 
-OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
+OMPSectionDirective *OMPSectionDirective::CreateEmpty(ASTContext const &C,
                                                       EmptyShell) {
   return createEmptyDirective<OMPSectionDirective>(C, /*NumClauses=*/0,
                                                    /*HasAssociatedStmt=*/true);
 }
 
-OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
+OMPSingleDirective *OMPSingleDirective::Create(ASTContext const &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                ArrayRef<OMPClause *> Clauses,
@@ -485,14 +485,14 @@
                                              EndLoc);
 }
 
-OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
+OMPSingleDirective *OMPSingleDirective::CreateEmpty(ASTContext const &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
   return createEmptyDirective<OMPSingleDirective>(C, NumClauses,
                                                   /*HasAssociatedStmt=*/true);
 }
 
-OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C,
+OMPMasterDirective *OMPMasterDirective::Create(ASTContext const &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                Stmt *AssociatedStmt) {
@@ -501,14 +501,14 @@
                                              EndLoc);
 }
 
-OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
+OMPMasterDirective *OMPMasterDirective::CreateEmpty(ASTContext const &C,
                                                     EmptyShell) {
   return createEmptyDirective<OMPMasterDirective>(C, /*NumClauses=*/0,
                                                   /*HasAssociatedStmt=*/true);
 }
 
 OMPCriticalDirective *OMPCriticalDirective::Create(
-    const ASTContext &C, const DeclarationNameInfo &Name,
+    ASTContext const &C, DeclarationNameInfo const &Name,
     SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
   return createDirective<OMPCriticalDirective>(C, Clauses, AssociatedStmt,
@@ -516,7 +516,7 @@
                                                StartLoc, EndLoc);
 }
 
-OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
+OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(ASTContext const &C,
                                                         unsigned NumClauses,
                                                         EmptyShell) {
   return createEmptyDirective<OMPCriticalDirective>(C, NumClauses,
@@ -524,9 +524,9 @@
 }
 
 OMPParallelForDirective *OMPParallelForDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
+    HelperExprs const &Exprs, Expr *TaskRedRef, bool HasCancel) {
   auto *Dir = createDirective<OMPParallelForDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc,
@@ -561,7 +561,7 @@
 }
 
 OMPParallelForDirective *
-OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
+OMPParallelForDirective::CreateEmpty(ASTContext const &C, unsigned NumClauses,
                                      unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPParallelForDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true,
@@ -569,9 +569,9 @@
 }
 
 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPParallelForSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc,
@@ -604,7 +604,7 @@
 }
 
 OMPParallelForSimdDirective *
-OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
+OMPParallelForSimdDirective::CreateEmpty(ASTContext const &C,
                                          unsigned NumClauses,
                                          unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPParallelForSimdDirective>(
@@ -613,7 +613,7 @@
 }
 
 OMPParallelMasterDirective *OMPParallelMasterDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) {
   auto *Dir = createDirective<OMPParallelMasterDirective>(
       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
@@ -622,14 +622,14 @@
 }
 
 OMPParallelMasterDirective *
-OMPParallelMasterDirective::CreateEmpty(const ASTContext &C,
+OMPParallelMasterDirective::CreateEmpty(ASTContext const &C,
                                         unsigned NumClauses, EmptyShell) {
   return createEmptyDirective<OMPParallelMasterDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
 }
 
 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
     bool HasCancel) {
   auto *Dir = createDirective<OMPParallelSectionsDirective>(
@@ -640,14 +640,14 @@
 }
 
 OMPParallelSectionsDirective *
-OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
+OMPParallelSectionsDirective::CreateEmpty(ASTContext const &C,
                                           unsigned NumClauses, EmptyShell) {
   return createEmptyDirective<OMPParallelSectionsDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
 }
 
 OMPTaskDirective *
-OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPTaskDirective::Create(ASTContext const &C, SourceLocation StartLoc,
                          SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
                          Stmt *AssociatedStmt, bool HasCancel) {
   auto *Dir = createDirective<OMPTaskDirective>(
@@ -656,48 +656,48 @@
   return Dir;
 }
 
-OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
+OMPTaskDirective *OMPTaskDirective::CreateEmpty(ASTContext const &C,
                                                 unsigned NumClauses,
                                                 EmptyShell) {
   return createEmptyDirective<OMPTaskDirective>(C, NumClauses,
                                                 /*HasAssociatedStmt=*/true);
 }
 
-OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
+OMPTaskyieldDirective *OMPTaskyieldDirective::Create(ASTContext const &C,
                                                      SourceLocation StartLoc,
                                                      SourceLocation EndLoc) {
   return new (C) OMPTaskyieldDirective(StartLoc, EndLoc);
 }
 
-OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
+OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(ASTContext const &C,
                                                           EmptyShell) {
   return new (C) OMPTaskyieldDirective();
 }
 
-OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
+OMPBarrierDirective *OMPBarrierDirective::Create(ASTContext const &C,
                                                  SourceLocation StartLoc,
                                                  SourceLocation EndLoc) {
   return new (C) OMPBarrierDirective(StartLoc, EndLoc);
 }
 
-OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
+OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(ASTContext const &C,
                                                       EmptyShell) {
   return new (C) OMPBarrierDirective();
 }
 
-OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
+OMPTaskwaitDirective *OMPTaskwaitDirective::Create(ASTContext const &C,
                                                    SourceLocation StartLoc,
                                                    SourceLocation EndLoc) {
   return new (C) OMPTaskwaitDirective(StartLoc, EndLoc);
 }
 
-OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
+OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(ASTContext const &C,
                                                         EmptyShell) {
   return new (C) OMPTaskwaitDirective();
 }
 
 OMPTaskgroupDirective *OMPTaskgroupDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {
   auto *Dir = createDirective<OMPTaskgroupDirective>(
       C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc);
@@ -705,7 +705,7 @@
   return Dir;
 }
 
-OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
+OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(ASTContext const &C,
                                                           unsigned NumClauses,
                                                           EmptyShell) {
   return createEmptyDirective<OMPTaskgroupDirective>(
@@ -713,7 +713,7 @@
 }
 
 OMPCancellationPointDirective *OMPCancellationPointDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     OpenMPDirectiveKind CancelRegion) {
   auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc);
   Dir->setCancelRegion(CancelRegion);
@@ -721,12 +721,12 @@
 }
 
 OMPCancellationPointDirective *
-OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) {
+OMPCancellationPointDirective::CreateEmpty(ASTContext const &C, EmptyShell) {
   return new (C) OMPCancellationPointDirective();
 }
 
 OMPCancelDirective *
-OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPCancelDirective::Create(ASTContext const &C, SourceLocation StartLoc,
                            SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
                            OpenMPDirectiveKind CancelRegion) {
   auto *Dir = createDirective<OMPCancelDirective>(
@@ -736,13 +736,13 @@
   return Dir;
 }
 
-OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,
+OMPCancelDirective *OMPCancelDirective::CreateEmpty(ASTContext const &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
   return createEmptyDirective<OMPCancelDirective>(C, NumClauses);
 }
 
-OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
+OMPFlushDirective *OMPFlushDirective::Create(ASTContext const &C,
                                              SourceLocation StartLoc,
                                              SourceLocation EndLoc,
                                              ArrayRef<OMPClause *> Clauses) {
@@ -751,13 +751,13 @@
       EndLoc);
 }
 
-OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
+OMPFlushDirective *OMPFlushDirective::CreateEmpty(ASTContext const &C,
                                                   unsigned NumClauses,
                                                   EmptyShell) {
   return createEmptyDirective<OMPFlushDirective>(C, NumClauses);
 }
 
-OMPDepobjDirective *OMPDepobjDirective::Create(const ASTContext &C,
+OMPDepobjDirective *OMPDepobjDirective::Create(ASTContext const &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                ArrayRef<OMPClause *> Clauses) {
@@ -766,13 +766,13 @@
       /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
-OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(const ASTContext &C,
+OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(ASTContext const &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
   return createEmptyDirective<OMPDepobjDirective>(C, NumClauses);
 }
 
-OMPScanDirective *OMPScanDirective::Create(const ASTContext &C,
+OMPScanDirective *OMPScanDirective::Create(ASTContext const &C,
                                            SourceLocation StartLoc,
                                            SourceLocation EndLoc,
                                            ArrayRef<OMPClause *> Clauses) {
@@ -781,13 +781,13 @@
                                            /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
-OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C,
+OMPScanDirective *OMPScanDirective::CreateEmpty(ASTContext const &C,
                                                 unsigned NumClauses,
                                                 EmptyShell) {
   return createEmptyDirective<OMPScanDirective>(C, NumClauses);
 }
 
-OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
+OMPOrderedDirective *OMPOrderedDirective::Create(ASTContext const &C,
                                                  SourceLocation StartLoc,
                                                  SourceLocation EndLoc,
                                                  ArrayRef<OMPClause *> Clauses,
@@ -797,7 +797,7 @@
       /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
-OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
+OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(ASTContext const &C,
                                                       unsigned NumClauses,
                                                       bool IsStandalone,
                                                       EmptyShell) {
@@ -806,7 +806,7 @@
 }
 
 OMPAtomicDirective *OMPAtomicDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
     Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
   auto *Dir = createDirective<OMPAtomicDirective>(
@@ -820,14 +820,14 @@
   return Dir;
 }
 
-OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
+OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(ASTContext const &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
   return createEmptyDirective<OMPAtomicDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/4);
 }
 
-OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
+OMPTargetDirective *OMPTargetDirective::Create(ASTContext const &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                ArrayRef<OMPClause *> Clauses,
@@ -836,7 +836,7 @@
       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
-OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
+OMPTargetDirective *OMPTargetDirective::CreateEmpty(ASTContext const &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
   return createEmptyDirective<OMPTargetDirective>(C, NumClauses,
@@ -844,7 +844,7 @@
 }
 
 OMPTargetParallelDirective *OMPTargetParallelDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef,
     bool HasCancel) {
   auto *Dir = createDirective<OMPTargetParallelDirective>(
@@ -855,16 +855,16 @@
 }
 
 OMPTargetParallelDirective *
-OMPTargetParallelDirective::CreateEmpty(const ASTContext &C,
+OMPTargetParallelDirective::CreateEmpty(ASTContext const &C,
                                         unsigned NumClauses, EmptyShell) {
   return createEmptyDirective<OMPTargetParallelDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1);
 }
 
 OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
+    HelperExprs const &Exprs, Expr *TaskRedRef, bool HasCancel) {
   auto *Dir = createDirective<OMPTargetParallelForDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc,
@@ -899,7 +899,7 @@
 }
 
 OMPTargetParallelForDirective *
-OMPTargetParallelForDirective::CreateEmpty(const ASTContext &C,
+OMPTargetParallelForDirective::CreateEmpty(ASTContext const &C,
                                            unsigned NumClauses,
                                            unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPTargetParallelForDirective>(
@@ -909,13 +909,13 @@
 }
 
 OMPTargetDataDirective *OMPTargetDataDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
   return createDirective<OMPTargetDataDirective>(
       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
-OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,
+OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(ASTContext const &C,
                                                             unsigned N,
                                                             EmptyShell) {
   return createEmptyDirective<OMPTargetDataDirective>(
@@ -923,34 +923,34 @@
 }
 
 OMPTargetEnterDataDirective *OMPTargetEnterDataDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
   return createDirective<OMPTargetEnterDataDirective>(
       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPTargetEnterDataDirective *
-OMPTargetEnterDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
+OMPTargetEnterDataDirective::CreateEmpty(ASTContext const &C, unsigned N,
                                          EmptyShell) {
   return createEmptyDirective<OMPTargetEnterDataDirective>(
       C, N, /*HasAssociatedStmt=*/true);
 }
 
 OMPTargetExitDataDirective *OMPTargetExitDataDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
   return createDirective<OMPTargetExitDataDirective>(
       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
 OMPTargetExitDataDirective *
-OMPTargetExitDataDirective::CreateEmpty(const ASTContext &C, unsigned N,
+OMPTargetExitDataDirective::CreateEmpty(ASTContext const &C, unsigned N,
                                         EmptyShell) {
   return createEmptyDirective<OMPTargetExitDataDirective>(
       C, N, /*HasAssociatedStmt=*/true);
 }
 
-OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
+OMPTeamsDirective *OMPTeamsDirective::Create(ASTContext const &C,
                                              SourceLocation StartLoc,
                                              SourceLocation EndLoc,
                                              ArrayRef<OMPClause *> Clauses,
@@ -959,7 +959,7 @@
       C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc);
 }
 
-OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
+OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(ASTContext const &C,
                                                   unsigned NumClauses,
                                                   EmptyShell) {
   return createEmptyDirective<OMPTeamsDirective>(C, NumClauses,
@@ -967,9 +967,9 @@
 }
 
 OMPTaskLoopDirective *OMPTaskLoopDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs, bool HasCancel) {
+    HelperExprs const &Exprs, bool HasCancel) {
   auto *Dir = createDirective<OMPTaskLoopDirective>(
       C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop),
       StartLoc, EndLoc, CollapsedNum);
@@ -1001,7 +1001,7 @@
   return Dir;
 }
 
-OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,
+OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(ASTContext const &C,
                                                         unsigned NumClauses,
                                                         unsigned CollapsedNum,
                                                         EmptyShell) {
@@ -1011,9 +1011,9 @@
 }
 
 OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPTaskLoopSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc,
@@ -1046,7 +1046,7 @@
 }
 
 OMPTaskLoopSimdDirective *
-OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
+OMPTaskLoopSimdDirective::CreateEmpty(ASTContext const &C, unsigned NumClauses,
                                       unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPTaskLoopSimdDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true,
@@ -1054,9 +1054,9 @@
 }
 
 OMPMasterTaskLoopDirective *OMPMasterTaskLoopDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs, bool HasCancel) {
+    HelperExprs const &Exprs, bool HasCancel) {
   auto *Dir = createDirective<OMPMasterTaskLoopDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc,
@@ -1090,7 +1090,7 @@
 }
 
 OMPMasterTaskLoopDirective *
-OMPMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
+OMPMasterTaskLoopDirective::CreateEmpty(ASTContext const &C,
                                         unsigned NumClauses,
                                         unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPMasterTaskLoopDirective>(
@@ -1099,9 +1099,9 @@
 }
 
 OMPMasterTaskLoopSimdDirective *OMPMasterTaskLoopSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc,
@@ -1134,7 +1134,7 @@
 }
 
 OMPMasterTaskLoopSimdDirective *
-OMPMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
+OMPMasterTaskLoopSimdDirective::CreateEmpty(ASTContext const &C,
                                             unsigned NumClauses,
                                             unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPMasterTaskLoopSimdDirective>(
@@ -1143,9 +1143,9 @@
 }
 
 OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs, bool HasCancel) {
+    HelperExprs const &Exprs, bool HasCancel) {
   auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc,
@@ -1179,7 +1179,7 @@
 }
 
 OMPParallelMasterTaskLoopDirective *
-OMPParallelMasterTaskLoopDirective::CreateEmpty(const ASTContext &C,
+OMPParallelMasterTaskLoopDirective::CreateEmpty(ASTContext const &C,
                                                 unsigned NumClauses,
                                                 unsigned CollapsedNum,
                                                 EmptyShell) {
@@ -1191,9 +1191,9 @@
 
 OMPParallelMasterTaskLoopSimdDirective *
 OMPParallelMasterTaskLoopSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd),
@@ -1226,7 +1226,7 @@
 }
 
 OMPParallelMasterTaskLoopSimdDirective *
-OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
+OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(ASTContext const &C,
                                                     unsigned NumClauses,
                                                     unsigned CollapsedNum,
                                                     EmptyShell) {
@@ -1236,10 +1236,11 @@
       CollapsedNum);
 }
 
-OMPDistributeDirective *OMPDistributeDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
-    unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+OMPDistributeDirective *
+OMPDistributeDirective::Create(ASTContext const &C, SourceLocation StartLoc,
+                               SourceLocation EndLoc, unsigned CollapsedNum,
+                               ArrayRef<OMPClause *> Clauses,
+                               Stmt *AssociatedStmt, HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPDistributeDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc,
@@ -1272,7 +1273,7 @@
 }
 
 OMPDistributeDirective *
-OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
+OMPDistributeDirective::CreateEmpty(ASTContext const &C, unsigned NumClauses,
                                     unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPDistributeDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true,
@@ -1280,7 +1281,7 @@
 }
 
 OMPTargetUpdateDirective *OMPTargetUpdateDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
   return createDirective<OMPTargetUpdateDirective>(C, Clauses, AssociatedStmt,
                                                    /*NumChildren=*/0, StartLoc,
@@ -1288,16 +1289,16 @@
 }
 
 OMPTargetUpdateDirective *
-OMPTargetUpdateDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
+OMPTargetUpdateDirective::CreateEmpty(ASTContext const &C, unsigned NumClauses,
                                       EmptyShell) {
   return createEmptyDirective<OMPTargetUpdateDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true);
 }
 
 OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
+    HelperExprs const &Exprs, Expr *TaskRedRef, bool HasCancel) {
   auto *Dir = createDirective<OMPDistributeParallelForDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc,
@@ -1345,7 +1346,7 @@
 }
 
 OMPDistributeParallelForDirective *
-OMPDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
+OMPDistributeParallelForDirective::CreateEmpty(ASTContext const &C,
                                                unsigned NumClauses,
                                                unsigned CollapsedNum,
                                                EmptyShell) {
@@ -1357,9 +1358,9 @@
 
 OMPDistributeParallelForSimdDirective *
 OMPDistributeParallelForSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd),
@@ -1405,7 +1406,7 @@
 }
 
 OMPDistributeParallelForSimdDirective *
-OMPDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
+OMPDistributeParallelForSimdDirective::CreateEmpty(ASTContext const &C,
                                                    unsigned NumClauses,
                                                    unsigned CollapsedNum,
                                                    EmptyShell) {
@@ -1416,9 +1417,9 @@
 }
 
 OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPDistributeSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc,
@@ -1451,7 +1452,7 @@
 }
 
 OMPDistributeSimdDirective *
-OMPDistributeSimdDirective::CreateEmpty(const ASTContext &C,
+OMPDistributeSimdDirective::CreateEmpty(ASTContext const &C,
                                         unsigned NumClauses,
                                         unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPDistributeSimdDirective>(
@@ -1460,9 +1461,9 @@
 }
 
 OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPTargetParallelForSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc,
@@ -1495,7 +1496,7 @@
 }
 
 OMPTargetParallelForSimdDirective *
-OMPTargetParallelForSimdDirective::CreateEmpty(const ASTContext &C,
+OMPTargetParallelForSimdDirective::CreateEmpty(ASTContext const &C,
                                                unsigned NumClauses,
                                                unsigned CollapsedNum,
                                                EmptyShell) {
@@ -1506,10 +1507,10 @@
 }
 
 OMPTargetSimdDirective *
-OMPTargetSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPTargetSimdDirective::Create(ASTContext const &C, SourceLocation StartLoc,
                                SourceLocation EndLoc, unsigned CollapsedNum,
                                ArrayRef<OMPClause *> Clauses,
-                               Stmt *AssociatedStmt, const HelperExprs &Exprs) {
+                               Stmt *AssociatedStmt, HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPTargetSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc,
@@ -1534,7 +1535,7 @@
 }
 
 OMPTargetSimdDirective *
-OMPTargetSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
+OMPTargetSimdDirective::CreateEmpty(ASTContext const &C, unsigned NumClauses,
                                     unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPTargetSimdDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true,
@@ -1542,9 +1543,9 @@
 }
 
 OMPTeamsDistributeDirective *OMPTeamsDistributeDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPTeamsDistributeDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc,
@@ -1577,7 +1578,7 @@
 }
 
 OMPTeamsDistributeDirective *
-OMPTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
+OMPTeamsDistributeDirective::CreateEmpty(ASTContext const &C,
                                          unsigned NumClauses,
                                          unsigned CollapsedNum, EmptyShell) {
   return createEmptyDirective<OMPTeamsDistributeDirective>(
@@ -1586,9 +1587,9 @@
 }
 
 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc,
@@ -1621,7 +1622,7 @@
 }
 
 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::CreateEmpty(
-    const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
+    ASTContext const &C, unsigned NumClauses, unsigned CollapsedNum,
     EmptyShell) {
   return createEmptyDirective<OMPTeamsDistributeSimdDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true,
@@ -1630,9 +1631,9 @@
 
 OMPTeamsDistributeParallelForSimdDirective *
 OMPTeamsDistributeParallelForSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd),
@@ -1678,7 +1679,7 @@
 }
 
 OMPTeamsDistributeParallelForSimdDirective *
-OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C,
+OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(ASTContext const &C,
                                                         unsigned NumClauses,
                                                         unsigned CollapsedNum,
                                                         EmptyShell) {
@@ -1690,9 +1691,9 @@
 
 OMPTeamsDistributeParallelForDirective *
 OMPTeamsDistributeParallelForDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
+    HelperExprs const &Exprs, Expr *TaskRedRef, bool HasCancel) {
   auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1,
@@ -1740,7 +1741,7 @@
 }
 
 OMPTeamsDistributeParallelForDirective *
-OMPTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
+OMPTeamsDistributeParallelForDirective::CreateEmpty(ASTContext const &C,
                                                     unsigned NumClauses,
                                                     unsigned CollapsedNum,
                                                     EmptyShell) {
@@ -1751,7 +1752,7 @@
 }
 
 OMPTargetTeamsDirective *OMPTargetTeamsDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
   return createDirective<OMPTargetTeamsDirective>(C, Clauses, AssociatedStmt,
                                                   /*NumChildren=*/0, StartLoc,
@@ -1759,16 +1760,16 @@
 }
 
 OMPTargetTeamsDirective *
-OMPTargetTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
+OMPTargetTeamsDirective::CreateEmpty(ASTContext const &C, unsigned NumClauses,
                                      EmptyShell) {
   return createEmptyDirective<OMPTargetTeamsDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true);
 }
 
 OMPTargetTeamsDistributeDirective *OMPTargetTeamsDistributeDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc,
@@ -1801,7 +1802,7 @@
 }
 
 OMPTargetTeamsDistributeDirective *
-OMPTargetTeamsDistributeDirective::CreateEmpty(const ASTContext &C,
+OMPTargetTeamsDistributeDirective::CreateEmpty(ASTContext const &C,
                                                unsigned NumClauses,
                                                unsigned CollapsedNum,
                                                EmptyShell) {
@@ -1813,9 +1814,9 @@
 
 OMPTargetTeamsDistributeParallelForDirective *
 OMPTargetTeamsDistributeParallelForDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) {
+    HelperExprs const &Exprs, Expr *TaskRedRef, bool HasCancel) {
   auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) +
@@ -1864,7 +1865,7 @@
 }
 
 OMPTargetTeamsDistributeParallelForDirective *
-OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C,
+OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(ASTContext const &C,
                                                           unsigned NumClauses,
                                                           unsigned CollapsedNum,
                                                           EmptyShell) {
@@ -1877,9 +1878,9 @@
 
 OMPTargetTeamsDistributeParallelForSimdDirective *
 OMPTargetTeamsDistributeParallelForSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum,
@@ -1927,7 +1928,7 @@
 
 OMPTargetTeamsDistributeParallelForSimdDirective *
 OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty(
-    const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum,
+    ASTContext const &C, unsigned NumClauses, unsigned CollapsedNum,
     EmptyShell) {
   return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>(
       C, NumClauses, /*HasAssociatedStmt=*/true,
@@ -1938,9 +1939,9 @@
 
 OMPTargetTeamsDistributeSimdDirective *
 OMPTargetTeamsDistributeSimdDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
-    const HelperExprs &Exprs) {
+    HelperExprs const &Exprs) {
   auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>(
       C, Clauses, AssociatedStmt,
       numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd),
@@ -1973,7 +1974,7 @@
 }
 
 OMPTargetTeamsDistributeSimdDirective *
-OMPTargetTeamsDistributeSimdDirective::CreateEmpty(const ASTContext &C,
+OMPTargetTeamsDistributeSimdDirective::CreateEmpty(ASTContext const &C,
                                                    unsigned NumClauses,
                                                    unsigned CollapsedNum,
                                                    EmptyShell) {
@@ -1984,7 +1985,7 @@
 }
 
 OMPInteropDirective *
-OMPInteropDirective::Create(const ASTContext &C, SourceLocation StartLoc,
+OMPInteropDirective::Create(ASTContext const &C, SourceLocation StartLoc,
                             SourceLocation EndLoc,
                             ArrayRef<OMPClause *> Clauses) {
   return createDirective<OMPInteropDirective>(
@@ -1992,14 +1993,14 @@
       EndLoc);
 }
 
-OMPInteropDirective *OMPInteropDirective::CreateEmpty(const ASTContext &C,
+OMPInteropDirective *OMPInteropDirective::CreateEmpty(ASTContext const &C,
                                                       unsigned NumClauses,
                                                       EmptyShell) {
   return createEmptyDirective<OMPInteropDirective>(C, NumClauses);
 }
 
 OMPDispatchDirective *OMPDispatchDirective::Create(
-    const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+    ASTContext const &C, SourceLocation StartLoc, SourceLocation EndLoc,
     ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
     SourceLocation TargetCallLoc) {
   auto *Dir = createDirective<OMPDispatchDirective>(
@@ -2008,7 +2009,7 @@
   return Dir;
 }
 
-OMPDispatchDirective *OMPDispatchDirective::CreateEmpty(const ASTContext &C,
+OMPDispatchDirective *OMPDispatchDirective::CreateEmpty(ASTContext const &C,
                                                         unsigned NumClauses,
                                                         EmptyShell) {
   return createEmptyDirective<OMPDispatchDirective>(C, NumClauses,
@@ -2016,7 +2017,7 @@
                                                     /*NumChildren=*/0);
 }
 
-OMPMaskedDirective *OMPMaskedDirective::Create(const ASTContext &C,
+OMPMaskedDirective *OMPMaskedDirective::Create(ASTContext const &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                ArrayRef<OMPClause *> Clauses,
@@ -2026,7 +2027,7 @@
                                              EndLoc);
 }
 
-OMPMaskedDirective *OMPMaskedDirective::CreateEmpty(const ASTContext &C,
+OMPMaskedDirective *OMPMaskedDirective::CreateEmpty(ASTContext const &C,
                                                     unsigned NumClauses,
                                                     EmptyShell) {
   return createEmptyDirective<OMPMaskedDirective>(C, NumClauses,
Index: clang/lib/AST/StmtPrinter.cpp
===================================================================
--- clang/lib/AST/StmtPrinter.cpp
+++ clang/lib/AST/StmtPrinter.cpp
@@ -64,105 +64,105 @@
 
 namespace {
 
-  class StmtPrinter : public StmtVisitor<StmtPrinter> {
-    raw_ostream &OS;
-    unsigned IndentLevel;
-    PrinterHelper* Helper;
-    PrintingPolicy Policy;
-    std::string NL;
-    const ASTContext *Context;
-
-  public:
-    StmtPrinter(raw_ostream &os, PrinterHelper *helper,
-                const PrintingPolicy &Policy, unsigned Indentation = 0,
-                StringRef NL = "\n", const ASTContext *Context = nullptr)
-        : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy),
-          NL(NL), Context(Context) {}
-
-    void PrintStmt(Stmt *S) { PrintStmt(S, Policy.Indentation); }
-
-    void PrintStmt(Stmt *S, int SubIndent) {
-      IndentLevel += SubIndent;
-      if (S && isa<Expr>(S)) {
-        // If this is an expr used in a stmt context, indent and newline it.
-        Indent();
-        Visit(S);
-        OS << ";" << NL;
-      } else if (S) {
-        Visit(S);
-      } else {
-        Indent() << "<<<NULL STATEMENT>>>" << NL;
-      }
-      IndentLevel -= SubIndent;
+class StmtPrinter : public StmtVisitor<StmtPrinter> {
+  raw_ostream &OS;
+  unsigned IndentLevel;
+  PrinterHelper *Helper;
+  PrintingPolicy Policy;
+  std::string NL;
+  ASTContext const *Context;
+
+public:
+  StmtPrinter(raw_ostream &os, PrinterHelper *helper,
+              PrintingPolicy const &Policy, unsigned Indentation = 0,
+              StringRef NL = "\n", ASTContext const *Context = nullptr)
+      : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy),
+        NL(NL), Context(Context) {}
+
+  void PrintStmt(Stmt *S) { PrintStmt(S, Policy.Indentation); }
+
+  void PrintStmt(Stmt *S, int SubIndent) {
+    IndentLevel += SubIndent;
+    if (S && isa<Expr>(S)) {
+      // If this is an expr used in a stmt context, indent and newline it.
+      Indent();
+      Visit(S);
+      OS << ";" << NL;
+    } else if (S) {
+      Visit(S);
+    } else {
+      Indent() << "<<<NULL STATEMENT>>>" << NL;
     }
+    IndentLevel -= SubIndent;
+  }
 
-    void PrintInitStmt(Stmt *S, unsigned PrefixWidth) {
-      // FIXME: Cope better with odd prefix widths.
-      IndentLevel += (PrefixWidth + 1) / 2;
-      if (auto *DS = dyn_cast<DeclStmt>(S))
-        PrintRawDeclStmt(DS);
-      else
-        PrintExpr(cast<Expr>(S));
-      OS << "; ";
-      IndentLevel -= (PrefixWidth + 1) / 2;
-    }
+  void PrintInitStmt(Stmt *S, unsigned PrefixWidth) {
+    // FIXME: Cope better with odd prefix widths.
+    IndentLevel += (PrefixWidth + 1) / 2;
+    if (auto *DS = dyn_cast<DeclStmt>(S))
+      PrintRawDeclStmt(DS);
+    else
+      PrintExpr(cast<Expr>(S));
+    OS << "; ";
+    IndentLevel -= (PrefixWidth + 1) / 2;
+  }
 
-    void PrintControlledStmt(Stmt *S) {
-      if (auto *CS = dyn_cast<CompoundStmt>(S)) {
-        OS << " ";
-        PrintRawCompoundStmt(CS);
-        OS << NL;
-      } else {
-        OS << NL;
-        PrintStmt(S);
-      }
+  void PrintControlledStmt(Stmt *S) {
+    if (auto *CS = dyn_cast<CompoundStmt>(S)) {
+      OS << " ";
+      PrintRawCompoundStmt(CS);
+      OS << NL;
+    } else {
+      OS << NL;
+      PrintStmt(S);
     }
+  }
 
-    void PrintRawCompoundStmt(CompoundStmt *S);
-    void PrintRawDecl(Decl *D);
-    void PrintRawDeclStmt(const DeclStmt *S);
-    void PrintRawIfStmt(IfStmt *If);
-    void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
-    void PrintCallArgs(CallExpr *E);
-    void PrintRawSEHExceptHandler(SEHExceptStmt *S);
-    void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
-    void PrintOMPExecutableDirective(OMPExecutableDirective *S,
-                                     bool ForceNoStmt = false);
-
-    void PrintExpr(Expr *E) {
-      if (E)
-        Visit(E);
-      else
-        OS << "<null expr>";
-    }
+  void PrintRawCompoundStmt(CompoundStmt *S);
+  void PrintRawDecl(Decl *D);
+  void PrintRawDeclStmt(DeclStmt const *S);
+  void PrintRawIfStmt(IfStmt *If);
+  void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
+  void PrintCallArgs(CallExpr *E);
+  void PrintRawSEHExceptHandler(SEHExceptStmt *S);
+  void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
+  void PrintOMPExecutableDirective(OMPExecutableDirective *S,
+                                   bool ForceNoStmt = false);
+
+  void PrintExpr(Expr *E) {
+    if (E)
+      Visit(E);
+    else
+      OS << "<null expr>";
+  }
 
-    raw_ostream &Indent(int Delta = 0) {
-      for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
-        OS << "  ";
-      return OS;
-    }
+  raw_ostream &Indent(int Delta = 0) {
+    for (int i = 0, e = IndentLevel + Delta; i < e; ++i)
+      OS << "  ";
+    return OS;
+  }
 
-    void Visit(Stmt* S) {
-      if (Helper && Helper->handledStmt(S,OS))
-          return;
-      else StmtVisitor<StmtPrinter>::Visit(S);
-    }
+  void Visit(Stmt *S) {
+    if (Helper && Helper->handledStmt(S, OS))
+      return;
+    else
+      StmtVisitor<StmtPrinter>::Visit(S);
+  }
 
-    void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
-      Indent() << "<<unknown stmt type>>" << NL;
-    }
+  void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
+    Indent() << "<<unknown stmt type>>" << NL;
+  }
 
-    void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
-      OS << "<<unknown expr type>>";
-    }
+  void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
+    OS << "<<unknown expr type>>";
+  }
 
-    void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
+  void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
 
 #define ABSTRACT_STMT(CLASS)
-#define STMT(CLASS, PARENT) \
-    void Visit##CLASS(CLASS *Node);
+#define STMT(CLASS, PARENT) void Visit##CLASS(CLASS *Node);
 #include "clang/AST/StmtNodes.inc"
-  };
+};
 
 } // namespace
 
@@ -180,18 +180,14 @@
   Indent() << "}";
 }
 
-void StmtPrinter::PrintRawDecl(Decl *D) {
-  D->print(OS, Policy, IndentLevel);
-}
+void StmtPrinter::PrintRawDecl(Decl *D) { D->print(OS, Policy, IndentLevel); }
 
-void StmtPrinter::PrintRawDeclStmt(const DeclStmt *S) {
+void StmtPrinter::PrintRawDeclStmt(DeclStmt const *S) {
   SmallVector<Decl *, 2> Decls(S->decls());
   Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel);
 }
 
-void StmtPrinter::VisitNullStmt(NullStmt *Node) {
-  Indent() << ";" << NL;
-}
+void StmtPrinter::VisitNullStmt(NullStmt *Node) { Indent() << ";" << NL; }
 
 void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
   Indent();
@@ -228,7 +224,7 @@
 }
 
 void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
-  for (const auto *Attr : Node->getAttrs()) {
+  for (auto const *Attr : Node->getAttrs()) {
     Attr->printPretty(OS, Policy);
   }
 
@@ -239,7 +235,7 @@
   OS << "if (";
   if (If->getInit())
     PrintInitStmt(If->getInit(), 4);
-  if (const DeclStmt *DS = If->getConditionVariableDeclStmt())
+  if (DeclStmt const *DS = If->getConditionVariableDeclStmt())
     PrintRawDeclStmt(DS);
   else
     PrintExpr(If->getCond());
@@ -252,7 +248,8 @@
   } else {
     OS << NL;
     PrintStmt(If->getThen());
-    if (If->getElse()) Indent();
+    if (If->getElse())
+      Indent();
   }
 
   if (Stmt *Else = If->getElse()) {
@@ -281,7 +278,7 @@
   Indent() << "switch (";
   if (Node->getInit())
     PrintInitStmt(Node->getInit(), 8);
-  if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
+  if (DeclStmt const *DS = Node->getConditionVariableDeclStmt())
     PrintRawDeclStmt(DS);
   else
     PrintExpr(Node->getCond());
@@ -291,7 +288,7 @@
 
 void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
   Indent() << "while (";
-  if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
+  if (DeclStmt const *DS = Node->getConditionVariableDeclStmt())
     PrintRawDeclStmt(DS);
   else
     PrintExpr(Node->getCond());
@@ -364,8 +361,8 @@
   else
     OS << "__if_not_exists (";
 
-  if (NestedNameSpecifier *Qualifier
-        = Node->getQualifierLoc().getNestedNameSpecifier())
+  if (NestedNameSpecifier *Qualifier =
+          Node->getQualifierLoc().getNestedNameSpecifier())
     Qualifier->print(OS, Policy);
 
   OS << Node->getNameInfo() << ") ";
@@ -375,24 +372,28 @@
 
 void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
   Indent() << "goto " << Node->getLabel()->getName() << ";";
-  if (Policy.IncludeNewlines) OS << NL;
+  if (Policy.IncludeNewlines)
+    OS << NL;
 }
 
 void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
   Indent() << "goto *";
   PrintExpr(Node->getTarget());
   OS << ";";
-  if (Policy.IncludeNewlines) OS << NL;
+  if (Policy.IncludeNewlines)
+    OS << NL;
 }
 
 void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
   Indent() << "continue;";
-  if (Policy.IncludeNewlines) OS << NL;
+  if (Policy.IncludeNewlines)
+    OS << NL;
 }
 
 void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
   Indent() << "break;";
-  if (Policy.IncludeNewlines) OS << NL;
+  if (Policy.IncludeNewlines)
+    OS << NL;
 }
 
 void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
@@ -402,7 +403,8 @@
     PrintExpr(Node->getRetValue());
   }
   OS << ";";
-  if (Policy.IncludeNewlines) OS << NL;
+  if (Policy.IncludeNewlines)
+    OS << NL;
 }
 
 void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) {
@@ -481,7 +483,8 @@
   }
 
   OS << ");";
-  if (Policy.IncludeNewlines) OS << NL;
+  if (Policy.IncludeNewlines)
+    OS << NL;
 }
 
 void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {
@@ -526,10 +529,9 @@
   }
 }
 
-void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
-}
+void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {}
 
-void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
+void StmtPrinter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *Node) {
   Indent() << "@catch (...) { /* todo */ } " << NL;
 }
 
@@ -592,7 +594,7 @@
   PrintRawCompoundStmt(Node->getTryBlock());
   SEHExceptStmt *E = Node->getExceptHandler();
   SEHFinallyStmt *F = Node->getFinallyHandler();
-  if(E)
+  if (E)
     PrintRawSEHExceptHandler(E);
   else {
     assert(F && "Must have a finally block...");
@@ -629,7 +631,8 @@
 
 void StmtPrinter::VisitSEHLeaveStmt(SEHLeaveStmt *Node) {
   Indent() << "__leave;";
-  if (Policy.IncludeNewlines) OS << NL;
+  if (Policy.IncludeNewlines)
+    OS << NL;
 }
 
 //===----------------------------------------------------------------------===//
@@ -995,11 +998,11 @@
 }
 
 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
-  if (const auto *OCED = dyn_cast<OMPCapturedExprDecl>(Node->getDecl())) {
+  if (auto const *OCED = dyn_cast<OMPCapturedExprDecl>(Node->getDecl())) {
     OCED->getInit()->IgnoreImpCasts()->printPretty(OS, nullptr, Policy);
     return;
   }
-  if (const auto *TPOD = dyn_cast<TemplateParamObjectDecl>(Node->getDecl())) {
+  if (auto const *TPOD = dyn_cast<TemplateParamObjectDecl>(Node->getDecl())) {
     TPOD->printAsExpr(OS);
     return;
   }
@@ -1009,7 +1012,7 @@
     OS << "template ";
   OS << Node->getNameInfo();
   if (Node->hasExplicitTemplateArgs()) {
-    const TemplateParameterList *TPL = nullptr;
+    TemplateParameterList const *TPL = nullptr;
     if (!Node->hadMultipleCandidates())
       if (auto *TD = dyn_cast<TemplateDecl>(Node->getDecl()))
         TPL = TD->getTemplateParameters();
@@ -1018,7 +1021,7 @@
 }
 
 void StmtPrinter::VisitDependentScopeDeclRefExpr(
-                                           DependentScopeDeclRefExpr *Node) {
+    DependentScopeDeclRefExpr *Node) {
   if (NestedNameSpecifier *Qualifier = Node->getQualifier())
     Qualifier->print(OS, Policy);
   if (Node->hasTemplateKeyword())
@@ -1038,9 +1041,9 @@
     printTemplateArgumentList(OS, Node->template_arguments(), Policy);
 }
 
-static bool isImplicitSelf(const Expr *E) {
-  if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
-    if (const auto *PD = dyn_cast<ImplicitParamDecl>(DRE->getDecl())) {
+static bool isImplicitSelf(Expr const *E) {
+  if (auto const *DRE = dyn_cast<DeclRefExpr>(E)) {
+    if (auto const *PD = dyn_cast<ImplicitParamDecl>(DRE->getDecl())) {
       if (PD->getParameterKind() == ImplicitParamDecl::ObjCSelf &&
           DRE->getBeginLoc().isInvalid())
         return true;
@@ -1071,7 +1074,7 @@
   }
 
   if (Node->isImplicitProperty()) {
-    if (const auto *Getter = Node->getImplicitPropertyGetter())
+    if (auto const *Getter = Node->getImplicitPropertyGetter())
       Getter->getSelector().print(OS);
     else
       OS << SelectorTable::getPropertyNameFromSetterSelector(
@@ -1105,7 +1108,7 @@
 /// Prints the given expression using the original source text. Returns true on
 /// success, false otherwise.
 static bool printExprAsWritten(raw_ostream &OS, Expr *E,
-                               const ASTContext *Context) {
+                               ASTContext const *Context) {
   if (!Context)
     return false;
   bool Invalid = false;
@@ -1127,18 +1130,38 @@
 
   // Emit suffixes.  Integer literals are always a builtin integer type.
   switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
-  default: llvm_unreachable("Unexpected type for integer literal!");
+  default:
+    llvm_unreachable("Unexpected type for integer literal!");
   case BuiltinType::Char_S:
-  case BuiltinType::Char_U:    OS << "i8"; break;
-  case BuiltinType::UChar:     OS << "Ui8"; break;
-  case BuiltinType::Short:     OS << "i16"; break;
-  case BuiltinType::UShort:    OS << "Ui16"; break;
-  case BuiltinType::Int:       break; // no suffix.
-  case BuiltinType::UInt:      OS << 'U'; break;
-  case BuiltinType::Long:      OS << 'L'; break;
-  case BuiltinType::ULong:     OS << "UL"; break;
-  case BuiltinType::LongLong:  OS << "LL"; break;
-  case BuiltinType::ULongLong: OS << "ULL"; break;
+  case BuiltinType::Char_U:
+    OS << "i8";
+    break;
+  case BuiltinType::UChar:
+    OS << "Ui8";
+    break;
+  case BuiltinType::Short:
+    OS << "i16";
+    break;
+  case BuiltinType::UShort:
+    OS << "Ui16";
+    break;
+  case BuiltinType::Int:
+    break; // no suffix.
+  case BuiltinType::UInt:
+    OS << 'U';
+    break;
+  case BuiltinType::Long:
+    OS << 'L';
+    break;
+  case BuiltinType::ULong:
+    OS << "UL";
+    break;
+  case BuiltinType::LongLong:
+    OS << "LL";
+    break;
+  case BuiltinType::ULongLong:
+    OS << "ULL";
+    break;
   case BuiltinType::Int128:
     break; // no suffix.
   case BuiltinType::UInt128:
@@ -1152,19 +1175,44 @@
   OS << Node->getValueAsString(/*Radix=*/10);
 
   switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
-    default: llvm_unreachable("Unexpected type for fixed point literal!");
-    case BuiltinType::ShortFract:   OS << "hr"; break;
-    case BuiltinType::ShortAccum:   OS << "hk"; break;
-    case BuiltinType::UShortFract:  OS << "uhr"; break;
-    case BuiltinType::UShortAccum:  OS << "uhk"; break;
-    case BuiltinType::Fract:        OS << "r"; break;
-    case BuiltinType::Accum:        OS << "k"; break;
-    case BuiltinType::UFract:       OS << "ur"; break;
-    case BuiltinType::UAccum:       OS << "uk"; break;
-    case BuiltinType::LongFract:    OS << "lr"; break;
-    case BuiltinType::LongAccum:    OS << "lk"; break;
-    case BuiltinType::ULongFract:   OS << "ulr"; break;
-    case BuiltinType::ULongAccum:   OS << "ulk"; break;
+  default:
+    llvm_unreachable("Unexpected type for fixed point literal!");
+  case BuiltinType::ShortFract:
+    OS << "hr";
+    break;
+  case BuiltinType::ShortAccum:
+    OS << "hk";
+    break;
+  case BuiltinType::UShortFract:
+    OS << "uhr";
+    break;
+  case BuiltinType::UShortAccum:
+    OS << "uhk";
+    break;
+  case BuiltinType::Fract:
+    OS << "r";
+    break;
+  case BuiltinType::Accum:
+    OS << "k";
+    break;
+  case BuiltinType::UFract:
+    OS << "ur";
+    break;
+  case BuiltinType::UAccum:
+    OS << "uk";
+    break;
+  case BuiltinType::LongFract:
+    OS << "lr";
+    break;
+  case BuiltinType::LongAccum:
+    OS << "lk";
+    break;
+  case BuiltinType::ULongFract:
+    OS << "ulr";
+    break;
+  case BuiltinType::ULongAccum:
+    OS << "ulk";
+    break;
   }
 }
 
@@ -1181,14 +1229,26 @@
 
   // Emit suffixes.  Float literals are always a builtin float type.
   switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
-  default: llvm_unreachable("Unexpected type for float literal!");
-  case BuiltinType::Half:       break; // FIXME: suffix?
-  case BuiltinType::Ibm128:     break; // FIXME: No suffix for ibm128 literal
-  case BuiltinType::Double:     break; // no suffix.
-  case BuiltinType::Float16:    OS << "F16"; break;
-  case BuiltinType::Float:      OS << 'F'; break;
-  case BuiltinType::LongDouble: OS << 'L'; break;
-  case BuiltinType::Float128:   OS << 'Q'; break;
+  default:
+    llvm_unreachable("Unexpected type for float literal!");
+  case BuiltinType::Half:
+    break; // FIXME: suffix?
+  case BuiltinType::Ibm128:
+    break; // FIXME: No suffix for ibm128 literal
+  case BuiltinType::Double:
+    break; // no suffix.
+  case BuiltinType::Float16:
+    OS << "F16";
+    break;
+  case BuiltinType::Float:
+    OS << 'F';
+    break;
+  case BuiltinType::LongDouble:
+    OS << 'L';
+    break;
+  case BuiltinType::Float128:
+    OS << 'Q';
+    break;
   }
 }
 
@@ -1220,7 +1280,8 @@
     // Print a space if this is an "identifier operator" like __real, or if
     // it might be concatenated incorrectly like '+'.
     switch (Node->getOpcode()) {
-    default: break;
+    default:
+      break;
     case UO_Real:
     case UO_Imag:
     case UO_Extension:
@@ -1275,7 +1336,7 @@
 
 void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(
     UnaryExprOrTypeTraitExpr *Node) {
-  const char *Spelling = getTraitSpelling(Node->getKind());
+  char const *Spelling = getTraitSpelling(Node->getKind());
   if (Node->getKind() == UETT_AlignOf) {
     if (Policy.Alignof)
       Spelling = "alignof";
@@ -1386,7 +1447,8 @@
       break;
     }
 
-    if (i) OS << ", ";
+    if (i)
+      OS << ", ";
     PrintExpr(Call->getArg(i));
   }
 }
@@ -1398,8 +1460,8 @@
   OS << ")";
 }
 
-static bool isImplicitThis(const Expr *E) {
-  if (const auto *TE = dyn_cast<CXXThisExpr>(E))
+static bool isImplicitThis(Expr const *E) {
+  if (auto const *TE = dyn_cast<CXXThisExpr>(E))
     return TE->isImplicit();
   return false;
 }
@@ -1426,7 +1488,7 @@
   if (Node->hasTemplateKeyword())
     OS << "template ";
   OS << Node->getMemberNameInfo();
-  const TemplateParameterList *TPL = nullptr;
+  TemplateParameterList const *TPL = nullptr;
   if (auto *FD = dyn_cast<FunctionDecl>(Node->getMemberDecl())) {
     if (!Node->hadMultipleCandidates())
       if (auto *FTD = FD->getPrimaryTemplate())
@@ -1490,8 +1552,8 @@
 
 // GNU extensions.
 
-void
-StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) {
+void StmtPrinter::VisitBinaryConditionalOperator(
+    BinaryConditionalOperator *Node) {
   PrintExpr(Node->getCommon());
   OS << " ?: ";
   PrintExpr(Node->getFalseExpr());
@@ -1517,14 +1579,13 @@
   OS << ")";
 }
 
-void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
-  OS << "__null";
-}
+void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) { OS << "__null"; }
 
 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
   OS << "__builtin_shufflevector(";
   for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
-    if (i) OS << ", ";
+    if (i)
+      OS << ", ";
     PrintExpr(Node->getExpr(i));
   }
   OS << ")";
@@ -1538,7 +1599,7 @@
   OS << ")";
 }
 
-void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
+void StmtPrinter::VisitInitListExpr(InitListExpr *Node) {
   if (Node->getSyntacticForm()) {
     Visit(Node->getSyntacticForm());
     return;
@@ -1546,7 +1607,8 @@
 
   OS << "{";
   for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
-    if (i) OS << ", ";
+    if (i)
+      OS << ", ";
     if (Node->getInit(i))
       PrintExpr(Node->getInit(i));
     else
@@ -1567,10 +1629,11 @@
   OS << "*";
 }
 
-void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) {
+void StmtPrinter::VisitParenListExpr(ParenListExpr *Node) {
   OS << "(";
   for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {
-    if (i) OS << ", ";
+    if (i)
+      OS << ", ";
     PrintExpr(Node->getExpr(i));
   }
   OS << ")";
@@ -1578,7 +1641,7 @@
 
 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
   bool NeedsEquals = true;
-  for (const DesignatedInitExpr::Designator &D : Node->designators()) {
+  for (DesignatedInitExpr::Designator const &D : Node->designators()) {
     if (D.isFieldDesignator()) {
       if (D.getDotLoc().isInvalid()) {
         if (IdentifierInfo *II = D.getFieldName()) {
@@ -1620,9 +1683,7 @@
   OS << "}";
 }
 
-void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) {
-  OS << "/*no init*/";
-}
+void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) { OS << "/*no init*/"; }
 
 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
   if (Node->getType()->getAsCXXRecordDecl()) {
@@ -1653,12 +1714,12 @@
 }
 
 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
-  const char *Name = nullptr;
+  char const *Name = nullptr;
   switch (Node->getOp()) {
 #define BUILTIN(ID, TYPE, ATTRS)
-#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
-  case AtomicExpr::AO ## ID: \
-    Name = #ID "("; \
+#define ATOMIC_BUILTIN(ID, TYPE, ATTRS)                                        \
+  case AtomicExpr::AO##ID:                                                     \
+    Name = #ID "(";                                                            \
     break;
 #include "clang/Basic/Builtins.def"
   }
@@ -1672,8 +1733,7 @@
     OS << ", ";
     PrintExpr(Node->getVal1());
   }
-  if (Node->getOp() == AtomicExpr::AO__atomic_exchange ||
-      Node->isCmpXChg()) {
+  if (Node->getOp() == AtomicExpr::AO__atomic_exchange || Node->isCmpXChg()) {
     OS << ", ";
     PrintExpr(Node->getVal2());
   }
@@ -1757,9 +1817,9 @@
     CXXRewrittenBinaryOperator *Node) {
   CXXRewrittenBinaryOperator::DecomposedForm Decomposed =
       Node->getDecomposedForm();
-  PrintExpr(const_cast<Expr*>(Decomposed.LHS));
+  PrintExpr(const_cast<Expr *>(Decomposed.LHS));
   OS << ' ' << BinaryOperator::getOpcodeStr(Decomposed.Opcode) << ' ';
-  PrintExpr(const_cast<Expr*>(Decomposed.RHS));
+  PrintExpr(const_cast<Expr *>(Decomposed.RHS));
 }
 
 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
@@ -1825,7 +1885,7 @@
   else
     OS << ".";
   if (NestedNameSpecifier *Qualifier =
-      Node->getQualifierLoc().getNestedNameSpecifier())
+          Node->getQualifierLoc().getNestedNameSpecifier())
     Qualifier->print(OS, Policy);
   OS << Node->getPropertyDecl()->getDeclName();
 }
@@ -1843,15 +1903,15 @@
     OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString();
     break;
   case UserDefinedLiteral::LOK_Template: {
-    const auto *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
-    const TemplateArgumentList *Args =
-      cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs();
+    auto const *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
+    TemplateArgumentList const *Args =
+        cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs();
     assert(Args);
 
     if (Args->size() != 1) {
-      const TemplateParameterList *TPL = nullptr;
+      TemplateParameterList const *TPL = nullptr;
       if (!DRE->hadMultipleCandidates())
-        if (const auto *TD = dyn_cast<TemplateDecl>(DRE->getDecl()))
+        if (auto const *TD = dyn_cast<TemplateDecl>(DRE->getDecl()))
           TPL = TD->getTemplateParameters();
       OS << "operator\"\"" << Node->getUDSuffix()->getName();
       printTemplateArgumentList(OS, Args->asArray(), Policy, TPL);
@@ -1859,8 +1919,8 @@
       return;
     }
 
-    const TemplateArgument &Pack = Args->get(0);
-    for (const auto &P : Pack.pack_elements()) {
+    TemplateArgument const &Pack = Args->get(0);
+    for (auto const &P : Pack.pack_elements()) {
       char C = (char)P.getAsIntegral().getZExtValue();
       OS << C;
     }
@@ -1868,8 +1928,8 @@
   }
   case UserDefinedLiteral::LOK_Integer: {
     // Print integer literal without suffix.
-    const auto *Int = cast<IntegerLiteral>(Node->getCookedLiteral());
-    OS << toString(Int->getValue(), 10, /*isSigned*/false);
+    auto const *Int = cast<IntegerLiteral>(Node->getCookedLiteral());
+    OS << toString(Int->getValue(), 10, /*isSigned*/ false);
     break;
   }
   case UserDefinedLiteral::LOK_Floating: {
@@ -1894,9 +1954,7 @@
   OS << "nullptr";
 }
 
-void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
-  OS << "this";
-}
+void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) { OS << "this"; }
 
 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
   if (!Node->getSubExpr())
@@ -1939,7 +1997,7 @@
   else
     OS << "(";
   for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(),
-                                         ArgEnd = Node->arg_end();
+                                            ArgEnd = Node->arg_end();
        Arg != ArgEnd; ++Arg) {
     if ((*Arg)->isDefaultArgument())
       break;
@@ -1973,9 +2031,8 @@
     break;
   }
   for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(),
-                                 CEnd = Node->explicit_capture_end();
-       C != CEnd;
-       ++C) {
+                                    CEnd = Node->explicit_capture_end();
+       C != CEnd; ++C) {
     if (C->capturesVLAType())
       continue;
 
@@ -2032,14 +2089,14 @@
   if (!Node->getExplicitTemplateParameters().empty()) {
     Node->getTemplateParameterList()->print(
         OS, Node->getLambdaClass()->getASTContext(),
-        /*OmitTemplateKW*/true);
+        /*OmitTemplateKW*/ true);
   }
 
   if (Node->hasExplicitParameters()) {
     OS << '(';
     CXXMethodDecl *Method = Node->getCallOperator();
     NeedComma = false;
-    for (const auto *P : Method->parameters()) {
+    for (auto const *P : Method->parameters()) {
       if (NeedComma) {
         OS << ", ";
       } else {
@@ -2161,7 +2218,8 @@
       break;
     }
 
-    if (i) OS << ", ";
+    if (i)
+      OS << ", ";
     PrintExpr(E->getArg(i));
   }
 
@@ -2183,13 +2241,12 @@
   PrintExpr(E->getSubExpr());
 }
 
-void
-StmtPrinter::VisitCXXUnresolvedConstructExpr(
-                                           CXXUnresolvedConstructExpr *Node) {
+void StmtPrinter::VisitCXXUnresolvedConstructExpr(
+    CXXUnresolvedConstructExpr *Node) {
   Node->getTypeAsWritten().print(OS, Policy);
   OS << "(";
   for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
-                                             ArgEnd = Node->arg_end();
+                                                ArgEnd = Node->arg_end();
        Arg != ArgEnd; ++Arg) {
     if (Arg != Node->arg_begin())
       OS << ", ";
@@ -2199,7 +2256,7 @@
 }
 
 void StmtPrinter::VisitCXXDependentScopeMemberExpr(
-                                         CXXDependentScopeMemberExpr *Node) {
+    CXXDependentScopeMemberExpr *Node) {
   if (!Node->isImplicitAccess()) {
     PrintExpr(Node->getBase());
     OS << (Node->isArrow() ? "->" : ".");
@@ -2265,12 +2322,12 @@
 }
 
 void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr(
-                                       SubstNonTypeTemplateParmPackExpr *Node) {
+    SubstNonTypeTemplateParmPackExpr *Node) {
   OS << *Node->getParameterPack();
 }
 
 void StmtPrinter::VisitSubstNonTypeTemplateParmExpr(
-                                       SubstNonTypeTemplateParmExpr *Node) {
+    SubstNonTypeTemplateParmExpr *Node) {
   Visit(Node->getReplacement());
 }
 
@@ -2278,7 +2335,8 @@
   OS << *E->getParameterPack();
 }
 
-void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){
+void StmtPrinter::VisitMaterializeTemporaryExpr(
+    MaterializeTemporaryExpr *Node) {
   PrintExpr(Node->getSubExpr());
 }
 
@@ -2340,7 +2398,7 @@
         OS << " }";
         if (ExprReq->getNoexceptLoc().isValid())
           OS << " noexcept";
-        const auto &RetReq = ExprReq->getReturnTypeRequirement();
+        auto const &RetReq = ExprReq->getReturnTypeRequirement();
         if (!RetReq.isEmpty()) {
           OS << " -> ";
           if (RetReq.isSubstitutionFailure())
@@ -2471,13 +2529,14 @@
   } else {
     for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
       if (i < selector.getNumArgs()) {
-        if (i > 0) OS << ' ';
+        if (i > 0)
+          OS << ' ';
         if (selector.getIdentifierInfoForSlot(i))
           OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
         else
-           OS << ":";
-      }
-      else OS << ", "; // Handle variadic methods.
+          OS << ":";
+      } else
+        OS << ", "; // Handle variadic methods.
 
       PrintExpr(Mess->getArg(i));
     }
@@ -2489,13 +2548,12 @@
   OS << (Node->getValue() ? "__objc_yes" : "__objc_no");
 }
 
-void
-StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
+void StmtPrinter::VisitObjCIndirectCopyRestoreExpr(
+    ObjCIndirectCopyRestoreExpr *E) {
   PrintExpr(E->getSubExpr());
 }
 
-void
-StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
+void StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
   OS << '(' << E->getBridgeKindName();
   E->getType().print(OS, Policy);
   OS << ')';
@@ -2506,22 +2564,24 @@
   BlockDecl *BD = Node->getBlockDecl();
   OS << "^";
 
-  const FunctionType *AFT = Node->getFunctionType();
+  FunctionType const *AFT = Node->getFunctionType();
 
   if (isa<FunctionNoProtoType>(AFT)) {
     OS << "()";
   } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
     OS << '(';
-    for (BlockDecl::param_iterator AI = BD->param_begin(),
-         E = BD->param_end(); AI != E; ++AI) {
-      if (AI != BD->param_begin()) OS << ", ";
+    for (BlockDecl::param_iterator AI = BD->param_begin(), E = BD->param_end();
+         AI != E; ++AI) {
+      if (AI != BD->param_begin())
+        OS << ", ";
       std::string ParamStr = (*AI)->getNameAsString();
       (*AI)->getType().print(OS, Policy, ParamStr);
     }
 
-    const auto *FT = cast<FunctionProtoType>(AFT);
+    auto const *FT = cast<FunctionProtoType>(AFT);
     if (FT->isVariadic()) {
-      if (!BD->param_empty()) OS << ", ";
+      if (!BD->param_empty())
+        OS << ", ";
       OS << "...";
     }
     OS << ')';
@@ -2540,7 +2600,7 @@
 
 void StmtPrinter::VisitRecoveryExpr(RecoveryExpr *Node) {
   OS << "<recovery-expr>(";
-  const char *Sep = "";
+  char const *Sep = "";
   for (Expr *E : Node->subExpressions()) {
     OS << Sep;
     PrintExpr(E);
@@ -2561,19 +2621,19 @@
 // Stmt method implementations
 //===----------------------------------------------------------------------===//
 
-void Stmt::dumpPretty(const ASTContext &Context) const {
+void Stmt::dumpPretty(ASTContext const &Context) const {
   printPretty(llvm::errs(), nullptr, PrintingPolicy(Context.getLangOpts()));
 }
 
 void Stmt::printPretty(raw_ostream &Out, PrinterHelper *Helper,
-                       const PrintingPolicy &Policy, unsigned Indentation,
-                       StringRef NL, const ASTContext *Context) const {
+                       PrintingPolicy const &Policy, unsigned Indentation,
+                       StringRef NL, ASTContext const *Context) const {
   StmtPrinter P(Out, Helper, Policy, Indentation, NL, Context);
   P.Visit(const_cast<Stmt *>(this));
 }
 
 void Stmt::printJson(raw_ostream &Out, PrinterHelper *Helper,
-                     const PrintingPolicy &Policy, bool AddQuotes) const {
+                     PrintingPolicy const &Policy, bool AddQuotes) const {
   std::string Buf;
   llvm::raw_string_ostream TempOut(Buf);
 
Index: clang/lib/AST/StmtProfile.cpp
===================================================================
--- clang/lib/AST/StmtProfile.cpp
+++ clang/lib/AST/StmtProfile.cpp
@@ -25,202 +25,197 @@
 using namespace clang;
 
 namespace {
-  class StmtProfiler : public ConstStmtVisitor<StmtProfiler> {
-  protected:
-    llvm::FoldingSetNodeID &ID;
-    bool Canonical;
+class StmtProfiler : public ConstStmtVisitor<StmtProfiler> {
+protected:
+  llvm::FoldingSetNodeID &ID;
+  bool Canonical;
 
-  public:
-    StmtProfiler(llvm::FoldingSetNodeID &ID, bool Canonical)
-        : ID(ID), Canonical(Canonical) {}
+public:
+  StmtProfiler(llvm::FoldingSetNodeID &ID, bool Canonical)
+      : ID(ID), Canonical(Canonical) {}
 
-    virtual ~StmtProfiler() {}
+  virtual ~StmtProfiler() {}
 
-    void VisitStmt(const Stmt *S);
+  void VisitStmt(Stmt const *S);
 
-    virtual void HandleStmtClass(Stmt::StmtClass SC) = 0;
+  virtual void HandleStmtClass(Stmt::StmtClass SC) = 0;
 
-#define STMT(Node, Base) void Visit##Node(const Node *S);
+#define STMT(Node, Base) void Visit##Node(Node const *S);
 #include "clang/AST/StmtNodes.inc"
 
-    /// Visit a declaration that is referenced within an expression
-    /// or statement.
-    virtual void VisitDecl(const Decl *D) = 0;
+  /// Visit a declaration that is referenced within an expression
+  /// or statement.
+  virtual void VisitDecl(Decl const *D) = 0;
 
-    /// Visit a type that is referenced within an expression or
-    /// statement.
-    virtual void VisitType(QualType T) = 0;
+  /// Visit a type that is referenced within an expression or
+  /// statement.
+  virtual void VisitType(QualType T) = 0;
 
-    /// Visit a name that occurs within an expression or statement.
-    virtual void VisitName(DeclarationName Name, bool TreatAsDecl = false) = 0;
+  /// Visit a name that occurs within an expression or statement.
+  virtual void VisitName(DeclarationName Name, bool TreatAsDecl = false) = 0;
 
-    /// Visit identifiers that are not in Decl's or Type's.
-    virtual void VisitIdentifierInfo(IdentifierInfo *II) = 0;
+  /// Visit identifiers that are not in Decl's or Type's.
+  virtual void VisitIdentifierInfo(IdentifierInfo *II) = 0;
 
-    /// Visit a nested-name-specifier that occurs within an expression
-    /// or statement.
-    virtual void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) = 0;
+  /// Visit a nested-name-specifier that occurs within an expression
+  /// or statement.
+  virtual void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) = 0;
 
-    /// Visit a template name that occurs within an expression or
-    /// statement.
-    virtual void VisitTemplateName(TemplateName Name) = 0;
+  /// Visit a template name that occurs within an expression or
+  /// statement.
+  virtual void VisitTemplateName(TemplateName Name) = 0;
 
-    /// Visit template arguments that occur within an expression or
-    /// statement.
-    void VisitTemplateArguments(const TemplateArgumentLoc *Args,
-                                unsigned NumArgs);
+  /// Visit template arguments that occur within an expression or
+  /// statement.
+  void VisitTemplateArguments(TemplateArgumentLoc const *Args,
+                              unsigned NumArgs);
 
-    /// Visit a single template argument.
-    void VisitTemplateArgument(const TemplateArgument &Arg);
-  };
+  /// Visit a single template argument.
+  void VisitTemplateArgument(TemplateArgument const &Arg);
+};
 
-  class StmtProfilerWithPointers : public StmtProfiler {
-    const ASTContext &Context;
+class StmtProfilerWithPointers : public StmtProfiler {
+  ASTContext const &Context;
 
-  public:
-    StmtProfilerWithPointers(llvm::FoldingSetNodeID &ID,
-                             const ASTContext &Context, bool Canonical)
-        : StmtProfiler(ID, Canonical), Context(Context) {}
-  private:
-    void HandleStmtClass(Stmt::StmtClass SC) override {
-      ID.AddInteger(SC);
-    }
+public:
+  StmtProfilerWithPointers(llvm::FoldingSetNodeID &ID,
+                           ASTContext const &Context, bool Canonical)
+      : StmtProfiler(ID, Canonical), Context(Context) {}
+
+private:
+  void HandleStmtClass(Stmt::StmtClass SC) override { ID.AddInteger(SC); }
+
+  void VisitDecl(Decl const *D) override {
+    ID.AddInteger(D ? D->getKind() : 0);
+
+    if (Canonical && D) {
+      if (NonTypeTemplateParmDecl const *NTTP =
+              dyn_cast<NonTypeTemplateParmDecl>(D)) {
+        ID.AddInteger(NTTP->getDepth());
+        ID.AddInteger(NTTP->getIndex());
+        ID.AddBoolean(NTTP->isParameterPack());
+        VisitType(NTTP->getType());
+        return;
+      }
+
+      if (ParmVarDecl const *Parm = dyn_cast<ParmVarDecl>(D)) {
+        // The Itanium C++ ABI uses the type, scope depth, and scope
+        // index of a parameter when mangling expressions that involve
+        // function parameters, so we will use the parameter's type for
+        // establishing function parameter identity. That way, our
+        // definition of "equivalent" (per C++ [temp.over.link]) is at
+        // least as strong as the definition of "equivalent" used for
+        // name mangling.
+        VisitType(Parm->getType());
+        ID.AddInteger(Parm->getFunctionScopeDepth());
+        ID.AddInteger(Parm->getFunctionScopeIndex());
+        return;
+      }
 
-    void VisitDecl(const Decl *D) override {
-      ID.AddInteger(D ? D->getKind() : 0);
-
-      if (Canonical && D) {
-        if (const NonTypeTemplateParmDecl *NTTP =
-                dyn_cast<NonTypeTemplateParmDecl>(D)) {
-          ID.AddInteger(NTTP->getDepth());
-          ID.AddInteger(NTTP->getIndex());
-          ID.AddBoolean(NTTP->isParameterPack());
-          VisitType(NTTP->getType());
-          return;
-        }
-
-        if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
-          // The Itanium C++ ABI uses the type, scope depth, and scope
-          // index of a parameter when mangling expressions that involve
-          // function parameters, so we will use the parameter's type for
-          // establishing function parameter identity. That way, our
-          // definition of "equivalent" (per C++ [temp.over.link]) is at
-          // least as strong as the definition of "equivalent" used for
-          // name mangling.
-          VisitType(Parm->getType());
-          ID.AddInteger(Parm->getFunctionScopeDepth());
-          ID.AddInteger(Parm->getFunctionScopeIndex());
-          return;
-        }
-
-        if (const TemplateTypeParmDecl *TTP =
-                dyn_cast<TemplateTypeParmDecl>(D)) {
-          ID.AddInteger(TTP->getDepth());
-          ID.AddInteger(TTP->getIndex());
-          ID.AddBoolean(TTP->isParameterPack());
-          return;
-        }
-
-        if (const TemplateTemplateParmDecl *TTP =
-                dyn_cast<TemplateTemplateParmDecl>(D)) {
-          ID.AddInteger(TTP->getDepth());
-          ID.AddInteger(TTP->getIndex());
-          ID.AddBoolean(TTP->isParameterPack());
-          return;
-        }
+      if (TemplateTypeParmDecl const *TTP = dyn_cast<TemplateTypeParmDecl>(D)) {
+        ID.AddInteger(TTP->getDepth());
+        ID.AddInteger(TTP->getIndex());
+        ID.AddBoolean(TTP->isParameterPack());
+        return;
       }
 
-      ID.AddPointer(D ? D->getCanonicalDecl() : nullptr);
+      if (TemplateTemplateParmDecl const *TTP =
+              dyn_cast<TemplateTemplateParmDecl>(D)) {
+        ID.AddInteger(TTP->getDepth());
+        ID.AddInteger(TTP->getIndex());
+        ID.AddBoolean(TTP->isParameterPack());
+        return;
+      }
     }
 
-    void VisitType(QualType T) override {
-      if (Canonical && !T.isNull())
-        T = Context.getCanonicalType(T);
+    ID.AddPointer(D ? D->getCanonicalDecl() : nullptr);
+  }
 
-      ID.AddPointer(T.getAsOpaquePtr());
-    }
+  void VisitType(QualType T) override {
+    if (Canonical && !T.isNull())
+      T = Context.getCanonicalType(T);
 
-    void VisitName(DeclarationName Name, bool /*TreatAsDecl*/) override {
-      ID.AddPointer(Name.getAsOpaquePtr());
-    }
+    ID.AddPointer(T.getAsOpaquePtr());
+  }
 
-    void VisitIdentifierInfo(IdentifierInfo *II) override {
-      ID.AddPointer(II);
-    }
+  void VisitName(DeclarationName Name, bool /*TreatAsDecl*/) override {
+    ID.AddPointer(Name.getAsOpaquePtr());
+  }
 
-    void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
-      if (Canonical)
-        NNS = Context.getCanonicalNestedNameSpecifier(NNS);
-      ID.AddPointer(NNS);
-    }
+  void VisitIdentifierInfo(IdentifierInfo *II) override { ID.AddPointer(II); }
 
-    void VisitTemplateName(TemplateName Name) override {
-      if (Canonical)
-        Name = Context.getCanonicalTemplateName(Name);
+  void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
+    if (Canonical)
+      NNS = Context.getCanonicalNestedNameSpecifier(NNS);
+    ID.AddPointer(NNS);
+  }
 
-      Name.Profile(ID);
-    }
-  };
-
-  class StmtProfilerWithoutPointers : public StmtProfiler {
-    ODRHash &Hash;
-  public:
-    StmtProfilerWithoutPointers(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
-        : StmtProfiler(ID, false), Hash(Hash) {}
-
-  private:
-    void HandleStmtClass(Stmt::StmtClass SC) override {
-      if (SC == Stmt::UnresolvedLookupExprClass) {
-        // Pretend that the name looked up is a Decl due to how templates
-        // handle some Decl lookups.
-        ID.AddInteger(Stmt::DeclRefExprClass);
-      } else {
-        ID.AddInteger(SC);
-      }
-    }
+  void VisitTemplateName(TemplateName Name) override {
+    if (Canonical)
+      Name = Context.getCanonicalTemplateName(Name);
 
-    void VisitType(QualType T) override {
-      Hash.AddQualType(T);
-    }
+    Name.Profile(ID);
+  }
+};
 
-    void VisitName(DeclarationName Name, bool TreatAsDecl) override {
-      if (TreatAsDecl) {
-        // A Decl can be null, so each Decl is preceded by a boolean to
-        // store its nullness.  Add a boolean here to match.
-        ID.AddBoolean(true);
-      }
-      Hash.AddDeclarationName(Name, TreatAsDecl);
+class StmtProfilerWithoutPointers : public StmtProfiler {
+  ODRHash &Hash;
+
+public:
+  StmtProfilerWithoutPointers(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
+      : StmtProfiler(ID, false), Hash(Hash) {}
+
+private:
+  void HandleStmtClass(Stmt::StmtClass SC) override {
+    if (SC == Stmt::UnresolvedLookupExprClass) {
+      // Pretend that the name looked up is a Decl due to how templates
+      // handle some Decl lookups.
+      ID.AddInteger(Stmt::DeclRefExprClass);
+    } else {
+      ID.AddInteger(SC);
     }
-    void VisitIdentifierInfo(IdentifierInfo *II) override {
-      ID.AddBoolean(II);
-      if (II) {
-        Hash.AddIdentifierInfo(II);
-      }
+  }
+
+  void VisitType(QualType T) override { Hash.AddQualType(T); }
+
+  void VisitName(DeclarationName Name, bool TreatAsDecl) override {
+    if (TreatAsDecl) {
+      // A Decl can be null, so each Decl is preceded by a boolean to
+      // store its nullness.  Add a boolean here to match.
+      ID.AddBoolean(true);
     }
-    void VisitDecl(const Decl *D) override {
-      ID.AddBoolean(D);
-      if (D) {
-        Hash.AddDecl(D);
-      }
+    Hash.AddDeclarationName(Name, TreatAsDecl);
+  }
+  void VisitIdentifierInfo(IdentifierInfo *II) override {
+    ID.AddBoolean(II);
+    if (II) {
+      Hash.AddIdentifierInfo(II);
     }
-    void VisitTemplateName(TemplateName Name) override {
-      Hash.AddTemplateName(Name);
+  }
+  void VisitDecl(Decl const *D) override {
+    ID.AddBoolean(D);
+    if (D) {
+      Hash.AddDecl(D);
     }
-    void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
-      ID.AddBoolean(NNS);
-      if (NNS) {
-        Hash.AddNestedNameSpecifier(NNS);
-      }
+  }
+  void VisitTemplateName(TemplateName Name) override {
+    Hash.AddTemplateName(Name);
+  }
+  void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
+    ID.AddBoolean(NNS);
+    if (NNS) {
+      Hash.AddNestedNameSpecifier(NNS);
     }
-  };
-}
+  }
+};
+} // namespace
 
-void StmtProfiler::VisitStmt(const Stmt *S) {
+void StmtProfiler::VisitStmt(Stmt const *S) {
   assert(S && "Requires non-null Stmt pointer");
 
   HandleStmtClass(S->getStmtClass());
 
-  for (const Stmt *SubStmt : S->children()) {
+  for (Stmt const *SubStmt : S->children()) {
     if (SubStmt)
       Visit(SubStmt);
     else
@@ -228,83 +223,65 @@
   }
 }
 
-void StmtProfiler::VisitDeclStmt(const DeclStmt *S) {
+void StmtProfiler::VisitDeclStmt(DeclStmt const *S) {
   VisitStmt(S);
-  for (const auto *D : S->decls())
+  for (auto const *D : S->decls())
     VisitDecl(D);
 }
 
-void StmtProfiler::VisitNullStmt(const NullStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitNullStmt(NullStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitCompoundStmt(const CompoundStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitCompoundStmt(CompoundStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitCaseStmt(const CaseStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitCaseStmt(CaseStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitDefaultStmt(const DefaultStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitDefaultStmt(DefaultStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitLabelStmt(const LabelStmt *S) {
+void StmtProfiler::VisitLabelStmt(LabelStmt const *S) {
   VisitStmt(S);
   VisitDecl(S->getDecl());
 }
 
-void StmtProfiler::VisitAttributedStmt(const AttributedStmt *S) {
+void StmtProfiler::VisitAttributedStmt(AttributedStmt const *S) {
   VisitStmt(S);
   // TODO: maybe visit attributes?
 }
 
-void StmtProfiler::VisitIfStmt(const IfStmt *S) {
+void StmtProfiler::VisitIfStmt(IfStmt const *S) {
   VisitStmt(S);
   VisitDecl(S->getConditionVariable());
 }
 
-void StmtProfiler::VisitSwitchStmt(const SwitchStmt *S) {
+void StmtProfiler::VisitSwitchStmt(SwitchStmt const *S) {
   VisitStmt(S);
   VisitDecl(S->getConditionVariable());
 }
 
-void StmtProfiler::VisitWhileStmt(const WhileStmt *S) {
+void StmtProfiler::VisitWhileStmt(WhileStmt const *S) {
   VisitStmt(S);
   VisitDecl(S->getConditionVariable());
 }
 
-void StmtProfiler::VisitDoStmt(const DoStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitDoStmt(DoStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitForStmt(const ForStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitForStmt(ForStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitGotoStmt(const GotoStmt *S) {
+void StmtProfiler::VisitGotoStmt(GotoStmt const *S) {
   VisitStmt(S);
   VisitDecl(S->getLabel());
 }
 
-void StmtProfiler::VisitIndirectGotoStmt(const IndirectGotoStmt *S) {
+void StmtProfiler::VisitIndirectGotoStmt(IndirectGotoStmt const *S) {
   VisitStmt(S);
 }
 
-void StmtProfiler::VisitContinueStmt(const ContinueStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitContinueStmt(ContinueStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitBreakStmt(const BreakStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitBreakStmt(BreakStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitReturnStmt(const ReturnStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitReturnStmt(ReturnStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitGCCAsmStmt(const GCCAsmStmt *S) {
+void StmtProfiler::VisitGCCAsmStmt(GCCAsmStmt const *S) {
   VisitStmt(S);
   ID.AddBoolean(S->isVolatile());
   ID.AddBoolean(S->isSimple());
@@ -327,81 +304,69 @@
     VisitDecl(L->getLabel());
 }
 
-void StmtProfiler::VisitMSAsmStmt(const MSAsmStmt *S) {
+void StmtProfiler::VisitMSAsmStmt(MSAsmStmt const *S) {
   // FIXME: Implement MS style inline asm statement profiler.
   VisitStmt(S);
 }
 
-void StmtProfiler::VisitCXXCatchStmt(const CXXCatchStmt *S) {
+void StmtProfiler::VisitCXXCatchStmt(CXXCatchStmt const *S) {
   VisitStmt(S);
   VisitType(S->getCaughtType());
 }
 
-void StmtProfiler::VisitCXXTryStmt(const CXXTryStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitCXXTryStmt(CXXTryStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
+void StmtProfiler::VisitCXXForRangeStmt(CXXForRangeStmt const *S) {
   VisitStmt(S);
 }
 
-void StmtProfiler::VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) {
+void StmtProfiler::VisitMSDependentExistsStmt(MSDependentExistsStmt const *S) {
   VisitStmt(S);
   ID.AddBoolean(S->isIfExists());
   VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier());
   VisitName(S->getNameInfo().getName());
 }
 
-void StmtProfiler::VisitSEHTryStmt(const SEHTryStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitSEHTryStmt(SEHTryStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitSEHFinallyStmt(const SEHFinallyStmt *S) {
+void StmtProfiler::VisitSEHFinallyStmt(SEHFinallyStmt const *S) {
   VisitStmt(S);
 }
 
-void StmtProfiler::VisitSEHExceptStmt(const SEHExceptStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitSEHExceptStmt(SEHExceptStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitSEHLeaveStmt(const SEHLeaveStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitSEHLeaveStmt(SEHLeaveStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitCapturedStmt(const CapturedStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitCapturedStmt(CapturedStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
+void StmtProfiler::VisitObjCForCollectionStmt(ObjCForCollectionStmt const *S) {
   VisitStmt(S);
 }
 
-void StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) {
+void StmtProfiler::VisitObjCAtCatchStmt(ObjCAtCatchStmt const *S) {
   VisitStmt(S);
   ID.AddBoolean(S->hasEllipsis());
   if (S->getCatchParamDecl())
     VisitType(S->getCatchParamDecl()->getType());
 }
 
-void StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) {
+void StmtProfiler::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt const *S) {
   VisitStmt(S);
 }
 
-void StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitObjCAtTryStmt(ObjCAtTryStmt const *S) { VisitStmt(S); }
 
-void
-StmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) {
+void StmtProfiler::VisitObjCAtSynchronizedStmt(
+    ObjCAtSynchronizedStmt const *S) {
   VisitStmt(S);
 }
 
-void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) {
+void StmtProfiler::VisitObjCAtThrowStmt(ObjCAtThrowStmt const *S) {
   VisitStmt(S);
 }
 
-void
-StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) {
+void StmtProfiler::VisitObjCAutoreleasePoolStmt(
+    ObjCAutoreleasePoolStmt const *S) {
   VisitStmt(S);
 }
 
@@ -409,196 +374,194 @@
 class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> {
   StmtProfiler *Profiler;
   /// Process clauses with list of variables.
-  template <typename T>
-  void VisitOMPClauseList(T *Node);
+  template <typename T> void VisitOMPClauseList(T *Node);
 
 public:
-  OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { }
+  OMPClauseProfiler(StmtProfiler *P) : Profiler(P) {}
 #define GEN_CLANG_CLAUSE_CLASS
-#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
+#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class const *C);
 #include "llvm/Frontend/OpenMP/OMP.inc"
-  void VistOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
-  void VistOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
+  void VistOMPClauseWithPreInit(OMPClauseWithPreInit const *C);
+  void VistOMPClauseWithPostUpdate(OMPClauseWithPostUpdate const *C);
 };
 
 void OMPClauseProfiler::VistOMPClauseWithPreInit(
-    const OMPClauseWithPreInit *C) {
+    OMPClauseWithPreInit const *C) {
   if (auto *S = C->getPreInitStmt())
     Profiler->VisitStmt(S);
 }
 
 void OMPClauseProfiler::VistOMPClauseWithPostUpdate(
-    const OMPClauseWithPostUpdate *C) {
+    OMPClauseWithPostUpdate const *C) {
   VistOMPClauseWithPreInit(C);
   if (auto *E = C->getPostUpdateExpr())
     Profiler->VisitStmt(E);
 }
 
-void OMPClauseProfiler::VisitOMPIfClause(const OMPIfClause *C) {
+void OMPClauseProfiler::VisitOMPIfClause(OMPIfClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getCondition())
     Profiler->VisitStmt(C->getCondition());
 }
 
-void OMPClauseProfiler::VisitOMPFinalClause(const OMPFinalClause *C) {
+void OMPClauseProfiler::VisitOMPFinalClause(OMPFinalClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getCondition())
     Profiler->VisitStmt(C->getCondition());
 }
 
-void OMPClauseProfiler::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) {
+void OMPClauseProfiler::VisitOMPNumThreadsClause(OMPNumThreadsClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getNumThreads())
     Profiler->VisitStmt(C->getNumThreads());
 }
 
-void OMPClauseProfiler::VisitOMPSafelenClause(const OMPSafelenClause *C) {
+void OMPClauseProfiler::VisitOMPSafelenClause(OMPSafelenClause const *C) {
   if (C->getSafelen())
     Profiler->VisitStmt(C->getSafelen());
 }
 
-void OMPClauseProfiler::VisitOMPSimdlenClause(const OMPSimdlenClause *C) {
+void OMPClauseProfiler::VisitOMPSimdlenClause(OMPSimdlenClause const *C) {
   if (C->getSimdlen())
     Profiler->VisitStmt(C->getSimdlen());
 }
 
-void OMPClauseProfiler::VisitOMPSizesClause(const OMPSizesClause *C) {
+void OMPClauseProfiler::VisitOMPSizesClause(OMPSizesClause const *C) {
   for (auto E : C->getSizesRefs())
     if (E)
       Profiler->VisitExpr(E);
 }
 
-void OMPClauseProfiler::VisitOMPFullClause(const OMPFullClause *C) {}
+void OMPClauseProfiler::VisitOMPFullClause(OMPFullClause const *C) {}
 
-void OMPClauseProfiler::VisitOMPPartialClause(const OMPPartialClause *C) {
-  if (const Expr *Factor = C->getFactor())
+void OMPClauseProfiler::VisitOMPPartialClause(OMPPartialClause const *C) {
+  if (Expr const *Factor = C->getFactor())
     Profiler->VisitExpr(Factor);
 }
 
-void OMPClauseProfiler::VisitOMPAllocatorClause(const OMPAllocatorClause *C) {
+void OMPClauseProfiler::VisitOMPAllocatorClause(OMPAllocatorClause const *C) {
   if (C->getAllocator())
     Profiler->VisitStmt(C->getAllocator());
 }
 
-void OMPClauseProfiler::VisitOMPCollapseClause(const OMPCollapseClause *C) {
+void OMPClauseProfiler::VisitOMPCollapseClause(OMPCollapseClause const *C) {
   if (C->getNumForLoops())
     Profiler->VisitStmt(C->getNumForLoops());
 }
 
-void OMPClauseProfiler::VisitOMPDetachClause(const OMPDetachClause *C) {
+void OMPClauseProfiler::VisitOMPDetachClause(OMPDetachClause const *C) {
   if (Expr *Evt = C->getEventHandler())
     Profiler->VisitStmt(Evt);
 }
 
-void OMPClauseProfiler::VisitOMPNovariantsClause(const OMPNovariantsClause *C) {
+void OMPClauseProfiler::VisitOMPNovariantsClause(OMPNovariantsClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getCondition())
     Profiler->VisitStmt(C->getCondition());
 }
 
-void OMPClauseProfiler::VisitOMPNocontextClause(const OMPNocontextClause *C) {
+void OMPClauseProfiler::VisitOMPNocontextClause(OMPNocontextClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getCondition())
     Profiler->VisitStmt(C->getCondition());
 }
 
-void OMPClauseProfiler::VisitOMPDefaultClause(const OMPDefaultClause *C) { }
+void OMPClauseProfiler::VisitOMPDefaultClause(OMPDefaultClause const *C) {}
 
-void OMPClauseProfiler::VisitOMPProcBindClause(const OMPProcBindClause *C) { }
+void OMPClauseProfiler::VisitOMPProcBindClause(OMPProcBindClause const *C) {}
 
 void OMPClauseProfiler::VisitOMPUnifiedAddressClause(
-    const OMPUnifiedAddressClause *C) {}
+    OMPUnifiedAddressClause const *C) {}
 
 void OMPClauseProfiler::VisitOMPUnifiedSharedMemoryClause(
-    const OMPUnifiedSharedMemoryClause *C) {}
+    OMPUnifiedSharedMemoryClause const *C) {}
 
 void OMPClauseProfiler::VisitOMPReverseOffloadClause(
-    const OMPReverseOffloadClause *C) {}
+    OMPReverseOffloadClause const *C) {}
 
 void OMPClauseProfiler::VisitOMPDynamicAllocatorsClause(
-    const OMPDynamicAllocatorsClause *C) {}
+    OMPDynamicAllocatorsClause const *C) {}
 
 void OMPClauseProfiler::VisitOMPAtomicDefaultMemOrderClause(
-    const OMPAtomicDefaultMemOrderClause *C) {}
+    OMPAtomicDefaultMemOrderClause const *C) {}
 
-void OMPClauseProfiler::VisitOMPScheduleClause(const OMPScheduleClause *C) {
+void OMPClauseProfiler::VisitOMPScheduleClause(OMPScheduleClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (auto *S = C->getChunkSize())
     Profiler->VisitStmt(S);
 }
 
-void OMPClauseProfiler::VisitOMPOrderedClause(const OMPOrderedClause *C) {
+void OMPClauseProfiler::VisitOMPOrderedClause(OMPOrderedClause const *C) {
   if (auto *Num = C->getNumForLoops())
     Profiler->VisitStmt(Num);
 }
 
-void OMPClauseProfiler::VisitOMPNowaitClause(const OMPNowaitClause *) {}
+void OMPClauseProfiler::VisitOMPNowaitClause(OMPNowaitClause const *) {}
 
-void OMPClauseProfiler::VisitOMPUntiedClause(const OMPUntiedClause *) {}
+void OMPClauseProfiler::VisitOMPUntiedClause(OMPUntiedClause const *) {}
 
-void OMPClauseProfiler::VisitOMPMergeableClause(const OMPMergeableClause *) {}
+void OMPClauseProfiler::VisitOMPMergeableClause(OMPMergeableClause const *) {}
 
-void OMPClauseProfiler::VisitOMPReadClause(const OMPReadClause *) {}
+void OMPClauseProfiler::VisitOMPReadClause(OMPReadClause const *) {}
 
-void OMPClauseProfiler::VisitOMPWriteClause(const OMPWriteClause *) {}
+void OMPClauseProfiler::VisitOMPWriteClause(OMPWriteClause const *) {}
 
-void OMPClauseProfiler::VisitOMPUpdateClause(const OMPUpdateClause *) {}
+void OMPClauseProfiler::VisitOMPUpdateClause(OMPUpdateClause const *) {}
 
-void OMPClauseProfiler::VisitOMPCaptureClause(const OMPCaptureClause *) {}
+void OMPClauseProfiler::VisitOMPCaptureClause(OMPCaptureClause const *) {}
 
-void OMPClauseProfiler::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
+void OMPClauseProfiler::VisitOMPSeqCstClause(OMPSeqCstClause const *) {}
 
-void OMPClauseProfiler::VisitOMPAcqRelClause(const OMPAcqRelClause *) {}
+void OMPClauseProfiler::VisitOMPAcqRelClause(OMPAcqRelClause const *) {}
 
-void OMPClauseProfiler::VisitOMPAcquireClause(const OMPAcquireClause *) {}
+void OMPClauseProfiler::VisitOMPAcquireClause(OMPAcquireClause const *) {}
 
-void OMPClauseProfiler::VisitOMPReleaseClause(const OMPReleaseClause *) {}
+void OMPClauseProfiler::VisitOMPReleaseClause(OMPReleaseClause const *) {}
 
-void OMPClauseProfiler::VisitOMPRelaxedClause(const OMPRelaxedClause *) {}
+void OMPClauseProfiler::VisitOMPRelaxedClause(OMPRelaxedClause const *) {}
 
-void OMPClauseProfiler::VisitOMPThreadsClause(const OMPThreadsClause *) {}
+void OMPClauseProfiler::VisitOMPThreadsClause(OMPThreadsClause const *) {}
 
-void OMPClauseProfiler::VisitOMPSIMDClause(const OMPSIMDClause *) {}
+void OMPClauseProfiler::VisitOMPSIMDClause(OMPSIMDClause const *) {}
 
-void OMPClauseProfiler::VisitOMPNogroupClause(const OMPNogroupClause *) {}
+void OMPClauseProfiler::VisitOMPNogroupClause(OMPNogroupClause const *) {}
 
-void OMPClauseProfiler::VisitOMPInitClause(const OMPInitClause *C) {
+void OMPClauseProfiler::VisitOMPInitClause(OMPInitClause const *C) {
   VisitOMPClauseList(C);
 }
 
-void OMPClauseProfiler::VisitOMPUseClause(const OMPUseClause *C) {
+void OMPClauseProfiler::VisitOMPUseClause(OMPUseClause const *C) {
   if (C->getInteropVar())
     Profiler->VisitStmt(C->getInteropVar());
 }
 
-void OMPClauseProfiler::VisitOMPDestroyClause(const OMPDestroyClause *C) {
+void OMPClauseProfiler::VisitOMPDestroyClause(OMPDestroyClause const *C) {
   if (C->getInteropVar())
     Profiler->VisitStmt(C->getInteropVar());
 }
 
-void OMPClauseProfiler::VisitOMPFilterClause(const OMPFilterClause *C) {
+void OMPClauseProfiler::VisitOMPFilterClause(OMPFilterClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getThreadID())
     Profiler->VisitStmt(C->getThreadID());
 }
 
-template<typename T>
-void OMPClauseProfiler::VisitOMPClauseList(T *Node) {
+template <typename T> void OMPClauseProfiler::VisitOMPClauseList(T *Node) {
   for (auto *E : Node->varlists()) {
     if (E)
       Profiler->VisitStmt(E);
   }
 }
 
-void OMPClauseProfiler::VisitOMPPrivateClause(const OMPPrivateClause *C) {
+void OMPClauseProfiler::VisitOMPPrivateClause(OMPPrivateClause const *C) {
   VisitOMPClauseList(C);
   for (auto *E : C->private_copies()) {
     if (E)
       Profiler->VisitStmt(E);
   }
 }
-void
-OMPClauseProfiler::VisitOMPFirstprivateClause(const OMPFirstprivateClause *C) {
+void OMPClauseProfiler::VisitOMPFirstprivateClause(
+    OMPFirstprivateClause const *C) {
   VisitOMPClauseList(C);
   VistOMPClauseWithPreInit(C);
   for (auto *E : C->private_copies()) {
@@ -610,8 +573,8 @@
       Profiler->VisitStmt(E);
   }
 }
-void
-OMPClauseProfiler::VisitOMPLastprivateClause(const OMPLastprivateClause *C) {
+void OMPClauseProfiler::VisitOMPLastprivateClause(
+    OMPLastprivateClause const *C) {
   VisitOMPClauseList(C);
   VistOMPClauseWithPostUpdate(C);
   for (auto *E : C->source_exprs()) {
@@ -627,11 +590,10 @@
       Profiler->VisitStmt(E);
   }
 }
-void OMPClauseProfiler::VisitOMPSharedClause(const OMPSharedClause *C) {
+void OMPClauseProfiler::VisitOMPSharedClause(OMPSharedClause const *C) {
   VisitOMPClauseList(C);
 }
-void OMPClauseProfiler::VisitOMPReductionClause(
-                                         const OMPReductionClause *C) {
+void OMPClauseProfiler::VisitOMPReductionClause(OMPReductionClause const *C) {
   Profiler->VisitNestedNameSpecifier(
       C->getQualifierLoc().getNestedNameSpecifier());
   Profiler->VisitName(C->getNameInfo().getName());
@@ -669,7 +631,7 @@
   }
 }
 void OMPClauseProfiler::VisitOMPTaskReductionClause(
-    const OMPTaskReductionClause *C) {
+    OMPTaskReductionClause const *C) {
   Profiler->VisitNestedNameSpecifier(
       C->getQualifierLoc().getNestedNameSpecifier());
   Profiler->VisitName(C->getNameInfo().getName());
@@ -693,7 +655,7 @@
   }
 }
 void OMPClauseProfiler::VisitOMPInReductionClause(
-    const OMPInReductionClause *C) {
+    OMPInReductionClause const *C) {
   Profiler->VisitNestedNameSpecifier(
       C->getQualifierLoc().getNestedNameSpecifier());
   Profiler->VisitName(C->getNameInfo().getName());
@@ -720,7 +682,7 @@
       Profiler->VisitStmt(E);
   }
 }
-void OMPClauseProfiler::VisitOMPLinearClause(const OMPLinearClause *C) {
+void OMPClauseProfiler::VisitOMPLinearClause(OMPLinearClause const *C) {
   VisitOMPClauseList(C);
   VistOMPClauseWithPostUpdate(C);
   for (auto *E : C->privates()) {
@@ -744,12 +706,12 @@
   if (C->getCalcStep())
     Profiler->VisitStmt(C->getCalcStep());
 }
-void OMPClauseProfiler::VisitOMPAlignedClause(const OMPAlignedClause *C) {
+void OMPClauseProfiler::VisitOMPAlignedClause(OMPAlignedClause const *C) {
   VisitOMPClauseList(C);
   if (C->getAlignment())
     Profiler->VisitStmt(C->getAlignment());
 }
-void OMPClauseProfiler::VisitOMPCopyinClause(const OMPCopyinClause *C) {
+void OMPClauseProfiler::VisitOMPCopyinClause(OMPCopyinClause const *C) {
   VisitOMPClauseList(C);
   for (auto *E : C->source_exprs()) {
     if (E)
@@ -764,8 +726,8 @@
       Profiler->VisitStmt(E);
   }
 }
-void
-OMPClauseProfiler::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) {
+void OMPClauseProfiler::VisitOMPCopyprivateClause(
+    OMPCopyprivateClause const *C) {
   VisitOMPClauseList(C);
   for (auto *E : C->source_exprs()) {
     if (E)
@@ -780,90 +742,90 @@
       Profiler->VisitStmt(E);
   }
 }
-void OMPClauseProfiler::VisitOMPFlushClause(const OMPFlushClause *C) {
+void OMPClauseProfiler::VisitOMPFlushClause(OMPFlushClause const *C) {
   VisitOMPClauseList(C);
 }
-void OMPClauseProfiler::VisitOMPDepobjClause(const OMPDepobjClause *C) {
-  if (const Expr *Depobj = C->getDepobj())
+void OMPClauseProfiler::VisitOMPDepobjClause(OMPDepobjClause const *C) {
+  if (Expr const *Depobj = C->getDepobj())
     Profiler->VisitStmt(Depobj);
 }
-void OMPClauseProfiler::VisitOMPDependClause(const OMPDependClause *C) {
+void OMPClauseProfiler::VisitOMPDependClause(OMPDependClause const *C) {
   VisitOMPClauseList(C);
 }
-void OMPClauseProfiler::VisitOMPDeviceClause(const OMPDeviceClause *C) {
+void OMPClauseProfiler::VisitOMPDeviceClause(OMPDeviceClause const *C) {
   if (C->getDevice())
     Profiler->VisitStmt(C->getDevice());
 }
-void OMPClauseProfiler::VisitOMPMapClause(const OMPMapClause *C) {
+void OMPClauseProfiler::VisitOMPMapClause(OMPMapClause const *C) {
   VisitOMPClauseList(C);
 }
-void OMPClauseProfiler::VisitOMPAllocateClause(const OMPAllocateClause *C) {
+void OMPClauseProfiler::VisitOMPAllocateClause(OMPAllocateClause const *C) {
   if (Expr *Allocator = C->getAllocator())
     Profiler->VisitStmt(Allocator);
   VisitOMPClauseList(C);
 }
-void OMPClauseProfiler::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) {
+void OMPClauseProfiler::VisitOMPNumTeamsClause(OMPNumTeamsClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getNumTeams())
     Profiler->VisitStmt(C->getNumTeams());
 }
 void OMPClauseProfiler::VisitOMPThreadLimitClause(
-    const OMPThreadLimitClause *C) {
+    OMPThreadLimitClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getThreadLimit())
     Profiler->VisitStmt(C->getThreadLimit());
 }
-void OMPClauseProfiler::VisitOMPPriorityClause(const OMPPriorityClause *C) {
+void OMPClauseProfiler::VisitOMPPriorityClause(OMPPriorityClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getPriority())
     Profiler->VisitStmt(C->getPriority());
 }
-void OMPClauseProfiler::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) {
+void OMPClauseProfiler::VisitOMPGrainsizeClause(OMPGrainsizeClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getGrainsize())
     Profiler->VisitStmt(C->getGrainsize());
 }
-void OMPClauseProfiler::VisitOMPNumTasksClause(const OMPNumTasksClause *C) {
+void OMPClauseProfiler::VisitOMPNumTasksClause(OMPNumTasksClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (C->getNumTasks())
     Profiler->VisitStmt(C->getNumTasks());
 }
-void OMPClauseProfiler::VisitOMPHintClause(const OMPHintClause *C) {
+void OMPClauseProfiler::VisitOMPHintClause(OMPHintClause const *C) {
   if (C->getHint())
     Profiler->VisitStmt(C->getHint());
 }
-void OMPClauseProfiler::VisitOMPToClause(const OMPToClause *C) {
+void OMPClauseProfiler::VisitOMPToClause(OMPToClause const *C) {
   VisitOMPClauseList(C);
 }
-void OMPClauseProfiler::VisitOMPFromClause(const OMPFromClause *C) {
+void OMPClauseProfiler::VisitOMPFromClause(OMPFromClause const *C) {
   VisitOMPClauseList(C);
 }
 void OMPClauseProfiler::VisitOMPUseDevicePtrClause(
-    const OMPUseDevicePtrClause *C) {
+    OMPUseDevicePtrClause const *C) {
   VisitOMPClauseList(C);
 }
 void OMPClauseProfiler::VisitOMPUseDeviceAddrClause(
-    const OMPUseDeviceAddrClause *C) {
+    OMPUseDeviceAddrClause const *C) {
   VisitOMPClauseList(C);
 }
 void OMPClauseProfiler::VisitOMPIsDevicePtrClause(
-    const OMPIsDevicePtrClause *C) {
+    OMPIsDevicePtrClause const *C) {
   VisitOMPClauseList(C);
 }
 void OMPClauseProfiler::VisitOMPNontemporalClause(
-    const OMPNontemporalClause *C) {
+    OMPNontemporalClause const *C) {
   VisitOMPClauseList(C);
   for (auto *E : C->private_refs())
     Profiler->VisitStmt(E);
 }
-void OMPClauseProfiler::VisitOMPInclusiveClause(const OMPInclusiveClause *C) {
+void OMPClauseProfiler::VisitOMPInclusiveClause(OMPInclusiveClause const *C) {
   VisitOMPClauseList(C);
 }
-void OMPClauseProfiler::VisitOMPExclusiveClause(const OMPExclusiveClause *C) {
+void OMPClauseProfiler::VisitOMPExclusiveClause(OMPExclusiveClause const *C) {
   VisitOMPClauseList(C);
 }
 void OMPClauseProfiler::VisitOMPUsesAllocatorsClause(
-    const OMPUsesAllocatorsClause *C) {
+    OMPUsesAllocatorsClause const *C) {
   for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
     OMPUsesAllocatorsClause::Data D = C->getAllocatorData(I);
     Profiler->VisitStmt(D.Allocator);
@@ -871,17 +833,17 @@
       Profiler->VisitStmt(D.AllocatorTraits);
   }
 }
-void OMPClauseProfiler::VisitOMPAffinityClause(const OMPAffinityClause *C) {
-  if (const Expr *Modifier = C->getModifier())
+void OMPClauseProfiler::VisitOMPAffinityClause(OMPAffinityClause const *C) {
+  if (Expr const *Modifier = C->getModifier())
     Profiler->VisitStmt(Modifier);
-  for (const Expr *E : C->varlists())
+  for (Expr const *E : C->varlists())
     Profiler->VisitStmt(E);
 }
-void OMPClauseProfiler::VisitOMPOrderClause(const OMPOrderClause *C) {}
+void OMPClauseProfiler::VisitOMPOrderClause(OMPOrderClause const *C) {}
 } // namespace
 
-void
-StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) {
+void StmtProfiler::VisitOMPExecutableDirective(
+    OMPExecutableDirective const *S) {
   VisitStmt(S);
   OMPClauseProfiler P(this);
   ArrayRef<OMPClause *> Clauses = S->clauses();
@@ -891,305 +853,302 @@
       P.Visit(*I);
 }
 
-void StmtProfiler::VisitOMPCanonicalLoop(const OMPCanonicalLoop *L) {
+void StmtProfiler::VisitOMPCanonicalLoop(OMPCanonicalLoop const *L) {
   VisitStmt(L);
 }
 
-void StmtProfiler::VisitOMPLoopBasedDirective(const OMPLoopBasedDirective *S) {
+void StmtProfiler::VisitOMPLoopBasedDirective(OMPLoopBasedDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPLoopDirective(const OMPLoopDirective *S) {
+void StmtProfiler::VisitOMPLoopDirective(OMPLoopDirective const *S) {
   VisitOMPLoopBasedDirective(S);
 }
 
-void StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) {
+void StmtProfiler::VisitOMPParallelDirective(OMPParallelDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPSimdDirective(const OMPSimdDirective *S) {
+void StmtProfiler::VisitOMPSimdDirective(OMPSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
-void StmtProfiler::VisitOMPTileDirective(const OMPTileDirective *S) {
+void StmtProfiler::VisitOMPTileDirective(OMPTileDirective const *S) {
   VisitOMPLoopBasedDirective(S);
 }
 
-void StmtProfiler::VisitOMPUnrollDirective(const OMPUnrollDirective *S) {
+void StmtProfiler::VisitOMPUnrollDirective(OMPUnrollDirective const *S) {
   VisitOMPLoopBasedDirective(S);
 }
 
-void StmtProfiler::VisitOMPForDirective(const OMPForDirective *S) {
+void StmtProfiler::VisitOMPForDirective(OMPForDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
-void StmtProfiler::VisitOMPForSimdDirective(const OMPForSimdDirective *S) {
+void StmtProfiler::VisitOMPForSimdDirective(OMPForSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
-void StmtProfiler::VisitOMPSectionsDirective(const OMPSectionsDirective *S) {
+void StmtProfiler::VisitOMPSectionsDirective(OMPSectionsDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) {
+void StmtProfiler::VisitOMPSectionDirective(OMPSectionDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPSingleDirective(const OMPSingleDirective *S) {
+void StmtProfiler::VisitOMPSingleDirective(OMPSingleDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPMasterDirective(const OMPMasterDirective *S) {
+void StmtProfiler::VisitOMPMasterDirective(OMPMasterDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPCriticalDirective(const OMPCriticalDirective *S) {
+void StmtProfiler::VisitOMPCriticalDirective(OMPCriticalDirective const *S) {
   VisitOMPExecutableDirective(S);
   VisitName(S->getDirectiveName().getName());
 }
 
-void
-StmtProfiler::VisitOMPParallelForDirective(const OMPParallelForDirective *S) {
+void StmtProfiler::VisitOMPParallelForDirective(
+    OMPParallelForDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPParallelForSimdDirective(
-    const OMPParallelForSimdDirective *S) {
+    OMPParallelForSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPParallelMasterDirective(
-    const OMPParallelMasterDirective *S) {
+    OMPParallelMasterDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPParallelSectionsDirective(
-    const OMPParallelSectionsDirective *S) {
+    OMPParallelSectionsDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPTaskDirective(const OMPTaskDirective *S) {
+void StmtProfiler::VisitOMPTaskDirective(OMPTaskDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *S) {
+void StmtProfiler::VisitOMPTaskyieldDirective(OMPTaskyieldDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPBarrierDirective(const OMPBarrierDirective *S) {
+void StmtProfiler::VisitOMPBarrierDirective(OMPBarrierDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *S) {
+void StmtProfiler::VisitOMPTaskwaitDirective(OMPTaskwaitDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *S) {
+void StmtProfiler::VisitOMPTaskgroupDirective(OMPTaskgroupDirective const *S) {
   VisitOMPExecutableDirective(S);
-  if (const Expr *E = S->getReductionRef())
+  if (Expr const *E = S->getReductionRef())
     VisitStmt(E);
 }
 
-void StmtProfiler::VisitOMPFlushDirective(const OMPFlushDirective *S) {
+void StmtProfiler::VisitOMPFlushDirective(OMPFlushDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPDepobjDirective(const OMPDepobjDirective *S) {
+void StmtProfiler::VisitOMPDepobjDirective(OMPDepobjDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPScanDirective(const OMPScanDirective *S) {
+void StmtProfiler::VisitOMPScanDirective(OMPScanDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPOrderedDirective(const OMPOrderedDirective *S) {
+void StmtProfiler::VisitOMPOrderedDirective(OMPOrderedDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPAtomicDirective(const OMPAtomicDirective *S) {
+void StmtProfiler::VisitOMPAtomicDirective(OMPAtomicDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPTargetDirective(const OMPTargetDirective *S) {
+void StmtProfiler::VisitOMPTargetDirective(OMPTargetDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPTargetDataDirective(const OMPTargetDataDirective *S) {
+void StmtProfiler::VisitOMPTargetDataDirective(
+    OMPTargetDataDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetEnterDataDirective(
-    const OMPTargetEnterDataDirective *S) {
+    OMPTargetEnterDataDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetExitDataDirective(
-    const OMPTargetExitDataDirective *S) {
+    OMPTargetExitDataDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetParallelDirective(
-    const OMPTargetParallelDirective *S) {
+    OMPTargetParallelDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetParallelForDirective(
-    const OMPTargetParallelForDirective *S) {
+    OMPTargetParallelForDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPTeamsDirective(const OMPTeamsDirective *S) {
+void StmtProfiler::VisitOMPTeamsDirective(OMPTeamsDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPCancellationPointDirective(
-    const OMPCancellationPointDirective *S) {
+    OMPCancellationPointDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPCancelDirective(const OMPCancelDirective *S) {
+void StmtProfiler::VisitOMPCancelDirective(OMPCancelDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *S) {
+void StmtProfiler::VisitOMPTaskLoopDirective(OMPTaskLoopDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTaskLoopSimdDirective(
-    const OMPTaskLoopSimdDirective *S) {
+    OMPTaskLoopSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPMasterTaskLoopDirective(
-    const OMPMasterTaskLoopDirective *S) {
+    OMPMasterTaskLoopDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPMasterTaskLoopSimdDirective(
-    const OMPMasterTaskLoopSimdDirective *S) {
+    OMPMasterTaskLoopSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPParallelMasterTaskLoopDirective(
-    const OMPParallelMasterTaskLoopDirective *S) {
+    OMPParallelMasterTaskLoopDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPParallelMasterTaskLoopSimdDirective(
-    const OMPParallelMasterTaskLoopSimdDirective *S) {
+    OMPParallelMasterTaskLoopSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPDistributeDirective(
-    const OMPDistributeDirective *S) {
+    OMPDistributeDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void OMPClauseProfiler::VisitOMPDistScheduleClause(
-    const OMPDistScheduleClause *C) {
+    OMPDistScheduleClause const *C) {
   VistOMPClauseWithPreInit(C);
   if (auto *S = C->getChunkSize())
     Profiler->VisitStmt(S);
 }
 
-void OMPClauseProfiler::VisitOMPDefaultmapClause(const OMPDefaultmapClause *) {}
+void OMPClauseProfiler::VisitOMPDefaultmapClause(OMPDefaultmapClause const *) {}
 
 void StmtProfiler::VisitOMPTargetUpdateDirective(
-    const OMPTargetUpdateDirective *S) {
+    OMPTargetUpdateDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPDistributeParallelForDirective(
-    const OMPDistributeParallelForDirective *S) {
+    OMPDistributeParallelForDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPDistributeParallelForSimdDirective(
-    const OMPDistributeParallelForSimdDirective *S) {
+    OMPDistributeParallelForSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPDistributeSimdDirective(
-    const OMPDistributeSimdDirective *S) {
+    OMPDistributeSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetParallelForSimdDirective(
-    const OMPTargetParallelForSimdDirective *S) {
+    OMPTargetParallelForSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetSimdDirective(
-    const OMPTargetSimdDirective *S) {
+    OMPTargetSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTeamsDistributeDirective(
-    const OMPTeamsDistributeDirective *S) {
+    OMPTeamsDistributeDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTeamsDistributeSimdDirective(
-    const OMPTeamsDistributeSimdDirective *S) {
+    OMPTeamsDistributeSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTeamsDistributeParallelForSimdDirective(
-    const OMPTeamsDistributeParallelForSimdDirective *S) {
+    OMPTeamsDistributeParallelForSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTeamsDistributeParallelForDirective(
-    const OMPTeamsDistributeParallelForDirective *S) {
+    OMPTeamsDistributeParallelForDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetTeamsDirective(
-    const OMPTargetTeamsDirective *S) {
+    OMPTargetTeamsDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetTeamsDistributeDirective(
-    const OMPTargetTeamsDistributeDirective *S) {
+    OMPTargetTeamsDistributeDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForDirective(
-    const OMPTargetTeamsDistributeParallelForDirective *S) {
+    OMPTargetTeamsDistributeParallelForDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
-    const OMPTargetTeamsDistributeParallelForSimdDirective *S) {
+    OMPTargetTeamsDistributeParallelForSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
 void StmtProfiler::VisitOMPTargetTeamsDistributeSimdDirective(
-    const OMPTargetTeamsDistributeSimdDirective *S) {
+    OMPTargetTeamsDistributeSimdDirective const *S) {
   VisitOMPLoopDirective(S);
 }
 
-void StmtProfiler::VisitOMPInteropDirective(const OMPInteropDirective *S) {
+void StmtProfiler::VisitOMPInteropDirective(OMPInteropDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPDispatchDirective(const OMPDispatchDirective *S) {
+void StmtProfiler::VisitOMPDispatchDirective(OMPDispatchDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitOMPMaskedDirective(const OMPMaskedDirective *S) {
+void StmtProfiler::VisitOMPMaskedDirective(OMPMaskedDirective const *S) {
   VisitOMPExecutableDirective(S);
 }
 
-void StmtProfiler::VisitExpr(const Expr *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitExpr(Expr const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitConstantExpr(const ConstantExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitConstantExpr(ConstantExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) {
+void StmtProfiler::VisitDeclRefExpr(DeclRefExpr const *S) {
   VisitExpr(S);
   if (!Canonical)
     VisitNestedNameSpecifier(S->getQualifier());
@@ -1202,69 +1161,65 @@
 }
 
 void StmtProfiler::VisitSYCLUniqueStableNameExpr(
-    const SYCLUniqueStableNameExpr *S) {
+    SYCLUniqueStableNameExpr const *S) {
   VisitExpr(S);
   VisitType(S->getTypeSourceInfo()->getType());
 }
 
-void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) {
+void StmtProfiler::VisitPredefinedExpr(PredefinedExpr const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getIdentKind());
 }
 
-void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) {
+void StmtProfiler::VisitIntegerLiteral(IntegerLiteral const *S) {
   VisitExpr(S);
   S->getValue().Profile(ID);
   ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
 }
 
-void StmtProfiler::VisitFixedPointLiteral(const FixedPointLiteral *S) {
+void StmtProfiler::VisitFixedPointLiteral(FixedPointLiteral const *S) {
   VisitExpr(S);
   S->getValue().Profile(ID);
   ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
 }
 
-void StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) {
+void StmtProfiler::VisitCharacterLiteral(CharacterLiteral const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getKind());
   ID.AddInteger(S->getValue());
 }
 
-void StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) {
+void StmtProfiler::VisitFloatingLiteral(FloatingLiteral const *S) {
   VisitExpr(S);
   S->getValue().Profile(ID);
   ID.AddBoolean(S->isExact());
   ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
 }
 
-void StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) {
+void StmtProfiler::VisitImaginaryLiteral(ImaginaryLiteral const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitStringLiteral(const StringLiteral *S) {
+void StmtProfiler::VisitStringLiteral(StringLiteral const *S) {
   VisitExpr(S);
   ID.AddString(S->getBytes());
   ID.AddInteger(S->getKind());
 }
 
-void StmtProfiler::VisitParenExpr(const ParenExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitParenExpr(ParenExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitParenListExpr(const ParenListExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitParenListExpr(ParenListExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) {
+void StmtProfiler::VisitUnaryOperator(UnaryOperator const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getOpcode());
 }
 
-void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) {
+void StmtProfiler::VisitOffsetOfExpr(OffsetOfExpr const *S) {
   VisitType(S->getTypeSourceInfo()->getType());
   unsigned n = S->getNumComponents();
   for (unsigned i = 0; i < n; ++i) {
-    const OffsetOfNode &ON = S->getComponent(i);
+    OffsetOfNode const &ON = S->getComponent(i);
     ID.AddInteger(ON.getKind());
     switch (ON.getKind()) {
     case OffsetOfNode::Array:
@@ -1288,41 +1243,39 @@
   VisitExpr(S);
 }
 
-void
-StmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) {
+void StmtProfiler::VisitUnaryExprOrTypeTraitExpr(
+    UnaryExprOrTypeTraitExpr const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getKind());
   if (S->isArgumentType())
     VisitType(S->getArgumentType());
 }
 
-void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) {
+void StmtProfiler::VisitArraySubscriptExpr(ArraySubscriptExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitMatrixSubscriptExpr(const MatrixSubscriptExpr *S) {
+void StmtProfiler::VisitMatrixSubscriptExpr(MatrixSubscriptExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitOMPArraySectionExpr(const OMPArraySectionExpr *S) {
+void StmtProfiler::VisitOMPArraySectionExpr(OMPArraySectionExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitOMPArrayShapingExpr(const OMPArrayShapingExpr *S) {
+void StmtProfiler::VisitOMPArrayShapingExpr(OMPArrayShapingExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitOMPIteratorExpr(const OMPIteratorExpr *S) {
+void StmtProfiler::VisitOMPIteratorExpr(OMPIteratorExpr const *S) {
   VisitExpr(S);
   for (unsigned I = 0, E = S->numOfIterators(); I < E; ++I)
     VisitDecl(S->getIteratorDecl(I));
 }
 
-void StmtProfiler::VisitCallExpr(const CallExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitCallExpr(CallExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitMemberExpr(const MemberExpr *S) {
+void StmtProfiler::VisitMemberExpr(MemberExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getMemberDecl());
   if (!Canonical)
@@ -1330,78 +1283,68 @@
   ID.AddBoolean(S->isArrow());
 }
 
-void StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) {
+void StmtProfiler::VisitCompoundLiteralExpr(CompoundLiteralExpr const *S) {
   VisitExpr(S);
   ID.AddBoolean(S->isFileScope());
 }
 
-void StmtProfiler::VisitCastExpr(const CastExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitCastExpr(CastExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) {
+void StmtProfiler::VisitImplicitCastExpr(ImplicitCastExpr const *S) {
   VisitCastExpr(S);
   ID.AddInteger(S->getValueKind());
 }
 
-void StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) {
+void StmtProfiler::VisitExplicitCastExpr(ExplicitCastExpr const *S) {
   VisitCastExpr(S);
   VisitType(S->getTypeAsWritten());
 }
 
-void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) {
+void StmtProfiler::VisitCStyleCastExpr(CStyleCastExpr const *S) {
   VisitExplicitCastExpr(S);
 }
 
-void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) {
+void StmtProfiler::VisitBinaryOperator(BinaryOperator const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getOpcode());
 }
 
-void
-StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) {
+void StmtProfiler::VisitCompoundAssignOperator(
+    CompoundAssignOperator const *S) {
   VisitBinaryOperator(S);
 }
 
-void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) {
+void StmtProfiler::VisitConditionalOperator(ConditionalOperator const *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitBinaryConditionalOperator(
-    const BinaryConditionalOperator *S) {
+    BinaryConditionalOperator const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) {
+void StmtProfiler::VisitAddrLabelExpr(AddrLabelExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getLabel());
 }
 
-void StmtProfiler::VisitStmtExpr(const StmtExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitStmtExpr(StmtExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) {
+void StmtProfiler::VisitShuffleVectorExpr(ShuffleVectorExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitConvertVectorExpr(const ConvertVectorExpr *S) {
+void StmtProfiler::VisitConvertVectorExpr(ConvertVectorExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitChooseExpr(ChooseExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitGNUNullExpr(GNUNullExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitVAArgExpr(VAArgExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitInitListExpr(const InitListExpr *S) {
+void StmtProfiler::VisitInitListExpr(InitListExpr const *S) {
   if (S->getSyntacticForm()) {
     VisitInitListExpr(S->getSyntacticForm());
     return;
@@ -1410,10 +1353,10 @@
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) {
+void StmtProfiler::VisitDesignatedInitExpr(DesignatedInitExpr const *S) {
   VisitExpr(S);
   ID.AddBoolean(S->usesGNUSyntax());
-  for (const DesignatedInitExpr::Designator &D : S->designators()) {
+  for (DesignatedInitExpr::Designator const &D : S->designators()) {
     if (D.isFieldDesignator()) {
       ID.AddInteger(0);
       VisitName(D.getFieldName());
@@ -1433,41 +1376,40 @@
 // Seems that if VisitInitListExpr() only works on the syntactic form of an
 // InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
 void StmtProfiler::VisitDesignatedInitUpdateExpr(
-    const DesignatedInitUpdateExpr *S) {
+    DesignatedInitUpdateExpr const *S) {
   llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "
                    "initializer");
 }
 
-void StmtProfiler::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *S) {
+void StmtProfiler::VisitArrayInitLoopExpr(ArrayInitLoopExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitArrayInitIndexExpr(const ArrayInitIndexExpr *S) {
+void StmtProfiler::VisitArrayInitIndexExpr(ArrayInitIndexExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitNoInitExpr(const NoInitExpr *S) {
+void StmtProfiler::VisitNoInitExpr(NoInitExpr const *S) {
   llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer");
 }
 
-void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) {
+void StmtProfiler::VisitImplicitValueInitExpr(ImplicitValueInitExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) {
+void StmtProfiler::VisitExtVectorElementExpr(ExtVectorElementExpr const *S) {
   VisitExpr(S);
   VisitName(&S->getAccessor());
 }
 
-void StmtProfiler::VisitBlockExpr(const BlockExpr *S) {
+void StmtProfiler::VisitBlockExpr(BlockExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getBlockDecl());
 }
 
-void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) {
+void StmtProfiler::VisitGenericSelectionExpr(GenericSelectionExpr const *S) {
   VisitExpr(S);
-  for (const GenericSelectionExpr::ConstAssociation Assoc :
-       S->associations()) {
+  for (const GenericSelectionExpr::ConstAssociation Assoc : S->associations()) {
     QualType T = Assoc.getType();
     if (T.isNull())
       ID.AddPointer(nullptr);
@@ -1477,29 +1419,30 @@
   }
 }
 
-void StmtProfiler::VisitPseudoObjectExpr(const PseudoObjectExpr *S) {
+void StmtProfiler::VisitPseudoObjectExpr(PseudoObjectExpr const *S) {
   VisitExpr(S);
-  for (PseudoObjectExpr::const_semantics_iterator
-         i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i)
+  for (PseudoObjectExpr::const_semantics_iterator i = S->semantics_begin(),
+                                                  e = S->semantics_end();
+       i != e; ++i)
     // Normally, we would not profile the source expressions of OVEs.
-    if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(*i))
+    if (OpaqueValueExpr const *OVE = dyn_cast<OpaqueValueExpr>(*i))
       Visit(OVE->getSourceExpr());
 }
 
-void StmtProfiler::VisitAtomicExpr(const AtomicExpr *S) {
+void StmtProfiler::VisitAtomicExpr(AtomicExpr const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getOp());
 }
 
 void StmtProfiler::VisitConceptSpecializationExpr(
-                                           const ConceptSpecializationExpr *S) {
+    ConceptSpecializationExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getNamedConcept());
-  for (const TemplateArgument &Arg : S->getTemplateArguments())
+  for (TemplateArgument const &Arg : S->getTemplateArguments())
     VisitTemplateArgument(Arg);
 }
 
-void StmtProfiler::VisitRequiresExpr(const RequiresExpr *S) {
+void StmtProfiler::VisitRequiresExpr(RequiresExpr const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getLocalParameters().size());
   for (ParmVarDecl *LocalParam : S->getLocalParameters())
@@ -1521,7 +1464,7 @@
       //    expression. It is equivalent to the simple-requirement x++; [...]
       // We therefore do not profile isSimple() here.
       ID.AddBoolean(ExprReq->getNoexceptLoc().isValid());
-      const concepts::ExprRequirement::ReturnTypeRequirement &RetReq =
+      concepts::ExprRequirement::ReturnTypeRequirement const &RetReq =
           ExprReq->getReturnTypeRequirement();
       if (RetReq.isEmpty()) {
         ID.AddInteger(0);
@@ -1542,7 +1485,7 @@
   }
 }
 
-static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
+static Stmt::StmtClass DecodeOperatorCall(CXXOperatorCallExpr const *S,
                                           UnaryOperatorKind &UnaryOp,
                                           BinaryOperatorKind &BinaryOp) {
   switch (S->getOperator()) {
@@ -1705,13 +1648,11 @@
     return Stmt::BinaryOperatorClass;
 
   case OO_PlusPlus:
-    UnaryOp = S->getNumArgs() == 1? UO_PreInc
-                                  : UO_PostInc;
+    UnaryOp = S->getNumArgs() == 1 ? UO_PreInc : UO_PostInc;
     return Stmt::UnaryOperatorClass;
 
   case OO_MinusMinus:
-    UnaryOp = S->getNumArgs() == 1? UO_PreDec
-                                  : UO_PostDec;
+    UnaryOp = S->getNumArgs() == 1 ? UO_PreDec : UO_PostDec;
     return Stmt::UnaryOperatorClass;
 
   case OO_Comma:
@@ -1738,14 +1679,15 @@
 
 #if defined(_MSC_VER) && !defined(__clang__)
 #if _MSC_VER == 1911
-// Work around https://developercommunity.visualstudio.com/content/problem/84002/clang-cl-when-built-with-vc-2017-crashes-cause-vc.html
+// Work around
+// https://developercommunity.visualstudio.com/content/problem/84002/clang-cl-when-built-with-vc-2017-crashes-cause-vc.html
 // MSVC 2017 update 3 miscompiles this function, and a clang built with it
 // will crash in stage 2 of a bootstrap build.
 #pragma optimize("", off)
 #endif
 #endif
 
-void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) {
+void StmtProfiler::VisitCXXOperatorCallExpr(CXXOperatorCallExpr const *S) {
   if (S->isTypeDependent()) {
     // Type-dependent operator calls are profiled like their underlying
     // syntactic operator.
@@ -1778,7 +1720,7 @@
 }
 
 void StmtProfiler::VisitCXXRewrittenBinaryOperator(
-    const CXXRewrittenBinaryOperator *S) {
+    CXXRewrittenBinaryOperator const *S) {
   // If a rewritten operator were ever to be type-dependent, we should profile
   // it following its syntactic operator.
   assert(!S->isTypeDependent() &&
@@ -1793,139 +1735,134 @@
 #endif
 #endif
 
-void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) {
+void StmtProfiler::VisitCXXMemberCallExpr(CXXMemberCallExpr const *S) {
   VisitCallExpr(S);
 }
 
-void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) {
+void StmtProfiler::VisitCUDAKernelCallExpr(CUDAKernelCallExpr const *S) {
   VisitCallExpr(S);
 }
 
-void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitAsTypeExpr(AsTypeExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) {
+void StmtProfiler::VisitCXXNamedCastExpr(CXXNamedCastExpr const *S) {
   VisitExplicitCastExpr(S);
 }
 
-void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) {
+void StmtProfiler::VisitCXXStaticCastExpr(CXXStaticCastExpr const *S) {
   VisitCXXNamedCastExpr(S);
 }
 
-void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) {
+void StmtProfiler::VisitCXXDynamicCastExpr(CXXDynamicCastExpr const *S) {
   VisitCXXNamedCastExpr(S);
 }
 
-void
-StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) {
+void StmtProfiler::VisitCXXReinterpretCastExpr(
+    CXXReinterpretCastExpr const *S) {
   VisitCXXNamedCastExpr(S);
 }
 
-void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) {
+void StmtProfiler::VisitCXXConstCastExpr(CXXConstCastExpr const *S) {
   VisitCXXNamedCastExpr(S);
 }
 
-void StmtProfiler::VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *S) {
+void StmtProfiler::VisitBuiltinBitCastExpr(BuiltinBitCastExpr const *S) {
   VisitExpr(S);
   VisitType(S->getTypeInfoAsWritten()->getType());
 }
 
-void StmtProfiler::VisitCXXAddrspaceCastExpr(const CXXAddrspaceCastExpr *S) {
+void StmtProfiler::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr const *S) {
   VisitCXXNamedCastExpr(S);
 }
 
-void StmtProfiler::VisitUserDefinedLiteral(const UserDefinedLiteral *S) {
+void StmtProfiler::VisitUserDefinedLiteral(UserDefinedLiteral const *S) {
   VisitCallExpr(S);
 }
 
-void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) {
+void StmtProfiler::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr const *S) {
   VisitExpr(S);
   ID.AddBoolean(S->getValue());
 }
 
-void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) {
+void StmtProfiler::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr const *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitCXXStdInitializerListExpr(
-    const CXXStdInitializerListExpr *S) {
+    CXXStdInitializerListExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) {
+void StmtProfiler::VisitCXXTypeidExpr(CXXTypeidExpr const *S) {
   VisitExpr(S);
   if (S->isTypeOperand())
     VisitType(S->getTypeOperandSourceInfo()->getType());
 }
 
-void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) {
+void StmtProfiler::VisitCXXUuidofExpr(CXXUuidofExpr const *S) {
   VisitExpr(S);
   if (S->isTypeOperand())
     VisitType(S->getTypeOperandSourceInfo()->getType());
 }
 
-void StmtProfiler::VisitMSPropertyRefExpr(const MSPropertyRefExpr *S) {
+void StmtProfiler::VisitMSPropertyRefExpr(MSPropertyRefExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getPropertyDecl());
 }
 
 void StmtProfiler::VisitMSPropertySubscriptExpr(
-    const MSPropertySubscriptExpr *S) {
+    MSPropertySubscriptExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) {
+void StmtProfiler::VisitCXXThisExpr(CXXThisExpr const *S) {
   VisitExpr(S);
   ID.AddBoolean(S->isImplicit());
 }
 
-void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitCXXThrowExpr(CXXThrowExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) {
+void StmtProfiler::VisitCXXDefaultArgExpr(CXXDefaultArgExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getParam());
 }
 
-void StmtProfiler::VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *S) {
+void StmtProfiler::VisitCXXDefaultInitExpr(CXXDefaultInitExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getField());
 }
 
-void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) {
+void StmtProfiler::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr const *S) {
   VisitExpr(S);
   VisitDecl(
-         const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor()));
+      const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor()));
 }
 
-void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) {
+void StmtProfiler::VisitCXXConstructExpr(CXXConstructExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getConstructor());
   ID.AddBoolean(S->isElidable());
 }
 
 void StmtProfiler::VisitCXXInheritedCtorInitExpr(
-    const CXXInheritedCtorInitExpr *S) {
+    CXXInheritedCtorInitExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getConstructor());
 }
 
-void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) {
+void StmtProfiler::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr const *S) {
   VisitExplicitCastExpr(S);
 }
 
-void
-StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) {
+void StmtProfiler::VisitCXXTemporaryObjectExpr(
+    CXXTemporaryObjectExpr const *S) {
   VisitCXXConstructExpr(S);
 }
 
-void
-StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) {
+void StmtProfiler::VisitLambdaExpr(LambdaExpr const *S) {
   VisitExpr(S);
   for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(),
-                                 CEnd = S->explicit_capture_end();
+                                    CEnd = S->explicit_capture_end();
        C != CEnd; ++C) {
     if (C->capturesVLAType())
       continue;
@@ -1950,19 +1887,19 @@
   VisitStmt(S->getBody());
 }
 
-void
-StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) {
+void StmtProfiler::VisitCXXScalarValueInitExpr(
+    CXXScalarValueInitExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) {
+void StmtProfiler::VisitCXXDeleteExpr(CXXDeleteExpr const *S) {
   VisitExpr(S);
   ID.AddBoolean(S->isGlobalDelete());
   ID.AddBoolean(S->isArrayForm());
   VisitDecl(S->getOperatorDelete());
 }
 
-void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) {
+void StmtProfiler::VisitCXXNewExpr(CXXNewExpr const *S) {
   VisitExpr(S);
   VisitType(S->getAllocatedType());
   VisitDecl(S->getOperatorNew());
@@ -1974,8 +1911,8 @@
   ID.AddInteger(S->getInitializationStyle());
 }
 
-void
-StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) {
+void StmtProfiler::VisitCXXPseudoDestructorExpr(
+    CXXPseudoDestructorExpr const *S) {
   VisitExpr(S);
   ID.AddBoolean(S->isArrow());
   VisitNestedNameSpecifier(S->getQualifier());
@@ -1989,7 +1926,7 @@
     VisitIdentifierInfo(S->getDestroyedTypeIdentifier());
 }
 
-void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) {
+void StmtProfiler::VisitOverloadExpr(OverloadExpr const *S) {
   VisitExpr(S);
   VisitNestedNameSpecifier(S->getQualifier());
   VisitName(S->getName(), /*TreatAsDecl*/ true);
@@ -1998,12 +1935,11 @@
     VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
 }
 
-void
-StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) {
+void StmtProfiler::VisitUnresolvedLookupExpr(UnresolvedLookupExpr const *S) {
   VisitOverloadExpr(S);
 }
 
-void StmtProfiler::VisitTypeTraitExpr(const TypeTraitExpr *S) {
+void StmtProfiler::VisitTypeTraitExpr(TypeTraitExpr const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getTrait());
   ID.AddInteger(S->getNumArgs());
@@ -2011,20 +1947,20 @@
     VisitType(S->getArg(I)->getType());
 }
 
-void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) {
+void StmtProfiler::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getTrait());
   VisitType(S->getQueriedType());
 }
 
-void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) {
+void StmtProfiler::VisitExpressionTraitExpr(ExpressionTraitExpr const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getTrait());
   VisitExpr(S->getQueriedExpression());
 }
 
 void StmtProfiler::VisitDependentScopeDeclRefExpr(
-    const DependentScopeDeclRefExpr *S) {
+    DependentScopeDeclRefExpr const *S) {
   VisitExpr(S);
   VisitName(S->getDeclName());
   VisitNestedNameSpecifier(S->getQualifier());
@@ -2033,19 +1969,19 @@
     VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
 }
 
-void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) {
+void StmtProfiler::VisitExprWithCleanups(ExprWithCleanups const *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitCXXUnresolvedConstructExpr(
-    const CXXUnresolvedConstructExpr *S) {
+    CXXUnresolvedConstructExpr const *S) {
   VisitExpr(S);
   VisitType(S->getTypeAsWritten());
   ID.AddInteger(S->isListInitialization());
 }
 
 void StmtProfiler::VisitCXXDependentScopeMemberExpr(
-    const CXXDependentScopeMemberExpr *S) {
+    CXXDependentScopeMemberExpr const *S) {
   ID.AddBoolean(S->isImplicitAccess());
   if (!S->isImplicitAccess()) {
     VisitExpr(S);
@@ -2058,7 +1994,7 @@
     VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
 }
 
-void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) {
+void StmtProfiler::VisitUnresolvedMemberExpr(UnresolvedMemberExpr const *S) {
   ID.AddBoolean(S->isImplicitAccess());
   if (!S->isImplicitAccess()) {
     VisitExpr(S);
@@ -2071,21 +2007,21 @@
     VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
 }
 
-void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) {
+void StmtProfiler::VisitCXXNoexceptExpr(CXXNoexceptExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) {
+void StmtProfiler::VisitPackExpansionExpr(PackExpansionExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) {
+void StmtProfiler::VisitSizeOfPackExpr(SizeOfPackExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getPack());
   if (S->isPartiallySubstituted()) {
     auto Args = S->getPartialArguments();
     ID.AddInteger(Args.size());
-    for (const auto &TA : Args)
+    for (auto const &TA : Args)
       VisitTemplateArgument(TA);
   } else {
     ID.AddInteger(0);
@@ -2093,19 +2029,19 @@
 }
 
 void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr(
-    const SubstNonTypeTemplateParmPackExpr *S) {
+    SubstNonTypeTemplateParmPackExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getParameterPack());
   VisitTemplateArgument(S->getArgumentPack());
 }
 
 void StmtProfiler::VisitSubstNonTypeTemplateParmExpr(
-    const SubstNonTypeTemplateParmExpr *E) {
+    SubstNonTypeTemplateParmExpr const *E) {
   // Profile exactly as the replacement expression.
   Visit(E->getReplacement());
 }
 
-void StmtProfiler::VisitFunctionParmPackExpr(const FunctionParmPackExpr *S) {
+void StmtProfiler::VisitFunctionParmPackExpr(FunctionParmPackExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getParameterPack());
   ID.AddInteger(S->getNumExpansions());
@@ -2114,88 +2050,76 @@
 }
 
 void StmtProfiler::VisitMaterializeTemporaryExpr(
-                                           const MaterializeTemporaryExpr *S) {
+    MaterializeTemporaryExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitCXXFoldExpr(const CXXFoldExpr *S) {
+void StmtProfiler::VisitCXXFoldExpr(CXXFoldExpr const *S) {
   VisitExpr(S);
   ID.AddInteger(S->getOperator());
 }
 
-void StmtProfiler::VisitCoroutineBodyStmt(const CoroutineBodyStmt *S) {
+void StmtProfiler::VisitCoroutineBodyStmt(CoroutineBodyStmt const *S) {
   VisitStmt(S);
 }
 
-void StmtProfiler::VisitCoreturnStmt(const CoreturnStmt *S) {
-  VisitStmt(S);
-}
+void StmtProfiler::VisitCoreturnStmt(CoreturnStmt const *S) { VisitStmt(S); }
 
-void StmtProfiler::VisitCoawaitExpr(const CoawaitExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitCoawaitExpr(CoawaitExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitDependentCoawaitExpr(const DependentCoawaitExpr *S) {
+void StmtProfiler::VisitDependentCoawaitExpr(DependentCoawaitExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitCoyieldExpr(const CoyieldExpr *S) {
-  VisitExpr(S);
-}
+void StmtProfiler::VisitCoyieldExpr(CoyieldExpr const *S) { VisitExpr(S); }
 
-void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
+void StmtProfiler::VisitOpaqueValueExpr(OpaqueValueExpr const *E) {
   VisitExpr(E);
 }
 
-void StmtProfiler::VisitTypoExpr(const TypoExpr *E) {
-  VisitExpr(E);
-}
+void StmtProfiler::VisitTypoExpr(TypoExpr const *E) { VisitExpr(E); }
 
-void StmtProfiler::VisitSourceLocExpr(const SourceLocExpr *E) {
-  VisitExpr(E);
-}
+void StmtProfiler::VisitSourceLocExpr(SourceLocExpr const *E) { VisitExpr(E); }
 
-void StmtProfiler::VisitRecoveryExpr(const RecoveryExpr *E) { VisitExpr(E); }
+void StmtProfiler::VisitRecoveryExpr(RecoveryExpr const *E) { VisitExpr(E); }
 
-void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) {
+void StmtProfiler::VisitObjCStringLiteral(ObjCStringLiteral const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
-  VisitExpr(E);
-}
+void StmtProfiler::VisitObjCBoxedExpr(ObjCBoxedExpr const *E) { VisitExpr(E); }
 
-void StmtProfiler::VisitObjCArrayLiteral(const ObjCArrayLiteral *E) {
+void StmtProfiler::VisitObjCArrayLiteral(ObjCArrayLiteral const *E) {
   VisitExpr(E);
 }
 
-void StmtProfiler::VisitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E) {
+void StmtProfiler::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral const *E) {
   VisitExpr(E);
 }
 
-void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) {
+void StmtProfiler::VisitObjCEncodeExpr(ObjCEncodeExpr const *S) {
   VisitExpr(S);
   VisitType(S->getEncodedType());
 }
 
-void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) {
+void StmtProfiler::VisitObjCSelectorExpr(ObjCSelectorExpr const *S) {
   VisitExpr(S);
   VisitName(S->getSelector());
 }
 
-void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) {
+void StmtProfiler::VisitObjCProtocolExpr(ObjCProtocolExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getProtocol());
 }
 
-void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) {
+void StmtProfiler::VisitObjCIvarRefExpr(ObjCIvarRefExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getDecl());
   ID.AddBoolean(S->isArrow());
   ID.AddBoolean(S->isFreeIvar());
 }
 
-void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) {
+void StmtProfiler::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr const *S) {
   VisitExpr(S);
   if (S->isImplicitProperty()) {
     VisitDecl(S->getImplicitPropertyGetter());
@@ -2209,52 +2133,52 @@
   }
 }
 
-void StmtProfiler::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *S) {
+void StmtProfiler::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr const *S) {
   VisitExpr(S);
   VisitDecl(S->getAtIndexMethodDecl());
   VisitDecl(S->setAtIndexMethodDecl());
 }
 
-void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) {
+void StmtProfiler::VisitObjCMessageExpr(ObjCMessageExpr const *S) {
   VisitExpr(S);
   VisitName(S->getSelector());
   VisitDecl(S->getMethodDecl());
 }
 
-void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) {
+void StmtProfiler::VisitObjCIsaExpr(ObjCIsaExpr const *S) {
   VisitExpr(S);
   ID.AddBoolean(S->isArrow());
 }
 
-void StmtProfiler::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *S) {
+void StmtProfiler::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr const *S) {
   VisitExpr(S);
   ID.AddBoolean(S->getValue());
 }
 
 void StmtProfiler::VisitObjCIndirectCopyRestoreExpr(
-    const ObjCIndirectCopyRestoreExpr *S) {
+    ObjCIndirectCopyRestoreExpr const *S) {
   VisitExpr(S);
   ID.AddBoolean(S->shouldCopy());
 }
 
-void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) {
+void StmtProfiler::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr const *S) {
   VisitExplicitCastExpr(S);
   ID.AddBoolean(S->getBridgeKind());
 }
 
 void StmtProfiler::VisitObjCAvailabilityCheckExpr(
-    const ObjCAvailabilityCheckExpr *S) {
+    ObjCAvailabilityCheckExpr const *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitTemplateArguments(const TemplateArgumentLoc *Args,
+void StmtProfiler::VisitTemplateArguments(TemplateArgumentLoc const *Args,
                                           unsigned NumArgs) {
   ID.AddInteger(NumArgs);
   for (unsigned I = 0; I != NumArgs; ++I)
     VisitTemplateArgument(Args[I].getArgument());
 }
 
-void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) {
+void StmtProfiler::VisitTemplateArgument(TemplateArgument const &Arg) {
   // Mostly repetitive with TemplateArgument::Profile!
   ID.AddInteger(Arg.getKind());
   switch (Arg.getKind()) {
@@ -2290,13 +2214,13 @@
     break;
 
   case TemplateArgument::Pack:
-    for (const auto &P : Arg.pack_elements())
+    for (auto const &P : Arg.pack_elements())
       VisitTemplateArgument(P);
     break;
   }
 }
 
-void Stmt::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
+void Stmt::Profile(llvm::FoldingSetNodeID &ID, ASTContext const &Context,
                    bool Canonical) const {
   StmtProfilerWithPointers Profiler(ID, Context, Canonical);
   Profiler.Visit(this);
Index: clang/lib/AST/StmtViz.cpp
===================================================================
--- clang/lib/AST/StmtViz.cpp
+++ clang/lib/AST/StmtViz.cpp
@@ -11,15 +11,15 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/StmtGraphTraits.h"
 #include "clang/AST/Decl.h"
+#include "clang/AST/StmtGraphTraits.h"
 #include "llvm/Support/GraphWriter.h"
 
 using namespace clang;
 
 void Stmt::viewAST() const {
 #ifndef NDEBUG
-  llvm::ViewGraph(this,"AST");
+  llvm::ViewGraph(this, "AST");
 #else
   llvm::errs() << "Stmt::viewAST is only available in debug builds on "
                << "systems with Graphviz or gv!\n";
@@ -27,11 +27,10 @@
 }
 
 namespace llvm {
-template<>
-struct DOTGraphTraits<const Stmt*> : public DefaultDOTGraphTraits {
-  DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
+template <> struct DOTGraphTraits<Stmt const *> : public DefaultDOTGraphTraits {
+  DOTGraphTraits(bool isSimple = false) : DefaultDOTGraphTraits(isSimple) {}
 
-  static std::string getNodeLabel(const Stmt* Node, const Stmt* Graph) {
+  static std::string getNodeLabel(Stmt const *Node, Stmt const *Graph) {
 
 #ifndef NDEBUG
     std::string OutSStr;
@@ -43,13 +42,14 @@
       Out << "<NULL>";
 
     std::string OutStr = Out.str();
-    if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
+    if (OutStr[0] == '\n')
+      OutStr.erase(OutStr.begin());
 
     // Process string output to make it nicer...
     for (unsigned i = 0; i != OutStr.length(); ++i)
-      if (OutStr[i] == '\n') {                            // Left justify
+      if (OutStr[i] == '\n') { // Left justify
         OutStr[i] = '\\';
-        OutStr.insert(OutStr.begin()+i+1, 'l');
+        OutStr.insert(OutStr.begin() + i + 1, 'l');
       }
 
     return OutStr;
Index: clang/lib/AST/TemplateBase.cpp
===================================================================
--- clang/lib/AST/TemplateBase.cpp
+++ clang/lib/AST/TemplateBase.cpp
@@ -54,13 +54,13 @@
 ///
 /// \param IncludeType If set, ensure that the type of the expression printed
 /// matches the type of the template argument.
-static void printIntegral(const TemplateArgument &TemplArg, raw_ostream &Out,
-                          const PrintingPolicy &Policy, bool IncludeType) {
-  const Type *T = TemplArg.getIntegralType().getTypePtr();
-  const llvm::APSInt &Val = TemplArg.getAsIntegral();
+static void printIntegral(TemplateArgument const &TemplArg, raw_ostream &Out,
+                          PrintingPolicy const &Policy, bool IncludeType) {
+  Type const *T = TemplArg.getIntegralType().getTypePtr();
+  llvm::APSInt const &Val = TemplArg.getAsIntegral();
 
-  if (const EnumType *ET = T->getAs<EnumType>()) {
-    for (const EnumConstantDecl* ECD : ET->getDecl()->enumerators()) {
+  if (EnumType const *ET = T->getAs<EnumType>()) {
+    for (EnumConstantDecl const *ECD : ET->getDecl()->enumerators()) {
       // In Sema::CheckTemplateArugment, enum template arguments value are
       // extended to the size of the integer underlying the enum type.  This
       // may create a size difference between the enum value and template
@@ -102,7 +102,7 @@
       Kind = CharacterLiteral::Ascii;
     CharacterLiteral::print(Val.getExtValue(), Kind, Out);
   } else if (IncludeType) {
-    if (const auto *BT = T->getAs<BuiltinType>()) {
+    if (auto const *BT = T->getAs<BuiltinType>()) {
       switch (BT->getKind()) {
       case BuiltinType::ULongLong:
         Out << Val << "ULL";
@@ -136,7 +136,7 @@
 
 static unsigned getArrayDepth(QualType type) {
   unsigned count = 0;
-  while (const auto *arrayType = type->getAsArrayTypeUnsafe()) {
+  while (auto const *arrayType = type->getAsArrayTypeUnsafe()) {
     count++;
     type = arrayType->getElementType();
   }
@@ -158,7 +158,7 @@
 // TemplateArgument Implementation
 //===----------------------------------------------------------------------===//
 
-TemplateArgument::TemplateArgument(ASTContext &Ctx, const llvm::APSInt &Value,
+TemplateArgument::TemplateArgument(ASTContext &Ctx, llvm::APSInt const &Value,
                                    QualType Type) {
   Integer.Kind = Integral;
   // Copy the APSInt value into our decomposed form.
@@ -227,7 +227,7 @@
     return Deps;
 
   case Pack:
-    for (const auto &P : pack_elements())
+    for (auto const &P : pack_elements())
       Deps |= P.getDependence();
     return Deps;
   }
@@ -303,7 +303,7 @@
 }
 
 void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID,
-                               const ASTContext &Context) const {
+                               ASTContext const &Context) const {
   ID.AddInteger(getKind());
   switch (getKind()) {
   case Null:
@@ -319,23 +319,23 @@
 
   case Declaration:
     getParamTypeForDecl().Profile(ID);
-    ID.AddPointer(getAsDecl()? getAsDecl()->getCanonicalDecl() : nullptr);
+    ID.AddPointer(getAsDecl() ? getAsDecl()->getCanonicalDecl() : nullptr);
     break;
 
   case Template:
   case TemplateExpansion: {
     TemplateName Template = getAsTemplateOrTemplatePattern();
-    if (TemplateTemplateParmDecl *TTP
-          = dyn_cast_or_null<TemplateTemplateParmDecl>(
-                                                Template.getAsTemplateDecl())) {
+    if (TemplateTemplateParmDecl *TTP =
+            dyn_cast_or_null<TemplateTemplateParmDecl>(
+                Template.getAsTemplateDecl())) {
       ID.AddBoolean(true);
       ID.AddInteger(TTP->getDepth());
       ID.AddInteger(TTP->getPosition());
       ID.AddBoolean(TTP->isParameterPack());
     } else {
       ID.AddBoolean(false);
-      ID.AddPointer(Context.getCanonicalTemplateName(Template)
-                                                          .getAsVoidPointer());
+      ID.AddPointer(
+          Context.getCanonicalTemplateName(Template).getAsVoidPointer());
     }
     break;
   }
@@ -356,8 +356,9 @@
   }
 }
 
-bool TemplateArgument::structurallyEquals(const TemplateArgument &Other) const {
-  if (getKind() != Other.getKind()) return false;
+bool TemplateArgument::structurallyEquals(TemplateArgument const &Other) const {
+  if (getKind() != Other.getKind())
+    return false;
 
   switch (getKind()) {
   case Null:
@@ -379,7 +380,8 @@
            getAsIntegral() == Other.getAsIntegral();
 
   case Pack:
-    if (Args.NumArgs != Other.Args.NumArgs) return false;
+    if (Args.NumArgs != Other.Args.NumArgs)
+      return false;
     for (unsigned I = 0, E = Args.NumArgs; I != E; ++I)
       if (!Args.Args[I].structurallyEquals(Other.Args.Args[I]))
         return false;
@@ -414,7 +416,7 @@
   llvm_unreachable("Invalid TemplateArgument Kind!");
 }
 
-void TemplateArgument::print(const PrintingPolicy &Policy, raw_ostream &Out,
+void TemplateArgument::print(PrintingPolicy const &Policy, raw_ostream &Out,
                              bool IncludeType) const {
 
   switch (getKind()) {
@@ -471,7 +473,7 @@
   case Pack:
     Out << "<";
     bool First = true;
-    for (const auto &P : pack_elements()) {
+    for (auto const &P : pack_elements()) {
       if (First)
         First = false;
       else
@@ -538,7 +540,7 @@
 }
 
 template <typename T>
-static const T &DiagTemplateArg(const T &DB, const TemplateArgument &Arg) {
+static const T &DiagTemplateArg(const T &DB, TemplateArgument const &Arg) {
   switch (Arg.getKind()) {
   case TemplateArgument::Null:
     // This is bad, but not as bad as crashing because of argument
@@ -591,8 +593,8 @@
   llvm_unreachable("Invalid TemplateArgument Kind!");
 }
 
-const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
-                                             const TemplateArgument &Arg) {
+StreamingDiagnostic const &clang::operator<<(StreamingDiagnostic const &DB,
+                                             TemplateArgument const &Arg) {
   return DiagTemplateArg(DB, Arg);
 }
 
@@ -607,16 +609,16 @@
   Pointer = Template;
 }
 
-const ASTTemplateArgumentListInfo *
-ASTTemplateArgumentListInfo::Create(const ASTContext &C,
-                                    const TemplateArgumentListInfo &List) {
+ASTTemplateArgumentListInfo const *
+ASTTemplateArgumentListInfo::Create(ASTContext const &C,
+                                    TemplateArgumentListInfo const &List) {
   std::size_t size = totalSizeToAlloc<TemplateArgumentLoc>(List.size());
   void *Mem = C.Allocate(size, alignof(ASTTemplateArgumentListInfo));
   return new (Mem) ASTTemplateArgumentListInfo(List);
 }
 
 ASTTemplateArgumentListInfo::ASTTemplateArgumentListInfo(
-    const TemplateArgumentListInfo &Info) {
+    TemplateArgumentListInfo const &Info) {
   LAngleLoc = Info.getLAngleLoc();
   RAngleLoc = Info.getRAngleLoc();
   NumTemplateArgs = Info.size();
@@ -627,7 +629,7 @@
 }
 
 void ASTTemplateKWAndArgsInfo::initializeFrom(
-    SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info,
+    SourceLocation TemplateKWLoc, TemplateArgumentListInfo const &Info,
     TemplateArgumentLoc *OutArgArray) {
   this->TemplateKWLoc = TemplateKWLoc;
   LAngleLoc = Info.getLAngleLoc();
@@ -647,7 +649,7 @@
 }
 
 void ASTTemplateKWAndArgsInfo::initializeFrom(
-    SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &Info,
+    SourceLocation TemplateKWLoc, TemplateArgumentListInfo const &Info,
     TemplateArgumentLoc *OutArgArray, TemplateArgumentDependence &Deps) {
   this->TemplateKWLoc = TemplateKWLoc;
   LAngleLoc = Info.getLAngleLoc();
@@ -661,7 +663,7 @@
   }
 }
 
-void ASTTemplateKWAndArgsInfo::copyInto(const TemplateArgumentLoc *ArgArray,
+void ASTTemplateKWAndArgsInfo::copyInto(TemplateArgumentLoc const *ArgArray,
                                         TemplateArgumentListInfo &Info) const {
   Info.setLAngleLoc(LAngleLoc);
   Info.setRAngleLoc(RAngleLoc);
Index: clang/lib/AST/TemplateName.cpp
===================================================================
--- clang/lib/AST/TemplateName.cpp
+++ clang/lib/AST/TemplateName.cpp
@@ -32,8 +32,7 @@
 
 using namespace clang;
 
-TemplateArgument
-SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
+TemplateArgument SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
   return TemplateArgument(llvm::makeArrayRef(Arguments, size()));
 }
 
@@ -41,9 +40,9 @@
   Profile(ID, Parameter, Replacement);
 }
 
-void SubstTemplateTemplateParmStorage::Profile(llvm::FoldingSetNodeID &ID,
-                                           TemplateTemplateParmDecl *parameter,
-                                               TemplateName replacement) {
+void SubstTemplateTemplateParmStorage::Profile(
+    llvm::FoldingSetNodeID &ID, TemplateTemplateParmDecl *parameter,
+    TemplateName replacement) {
   ID.AddPointer(parameter);
   ID.AddPointer(replacement.getAsVoidPointer());
 }
@@ -53,10 +52,9 @@
   Profile(ID, Context, Parameter, getArgumentPack());
 }
 
-void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
-                                                   ASTContext &Context,
-                                           TemplateTemplateParmDecl *Parameter,
-                                             const TemplateArgument &ArgPack) {
+void SubstTemplateTemplateParmPackStorage::Profile(
+    llvm::FoldingSetNodeID &ID, ASTContext &Context,
+    TemplateTemplateParmDecl *Parameter, TemplateArgument const &ArgPack) {
   ID.AddPointer(Parameter);
   ArgPack.Profile(ID, Context);
 }
@@ -87,8 +85,8 @@
   if (Storage.is<QualifiedTemplateName *>())
     return QualifiedTemplate;
 
-  UncommonTemplateNameStorage *uncommon
-    = Storage.get<UncommonTemplateNameStorage*>();
+  UncommonTemplateNameStorage *uncommon =
+      Storage.get<UncommonTemplateNameStorage *>();
   if (uncommon->getAsOverloadedStorage())
     return OverloadedTemplate;
   if (uncommon->getAsAssumedTemplateName())
@@ -220,7 +218,7 @@
   return getDependence() & TemplateNameDependence::UnexpandedPack;
 }
 
-void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
+void TemplateName::print(raw_ostream &OS, PrintingPolicy const &Policy,
                          Qualified Qual) const {
   if (TemplateDecl *Template = Storage.dyn_cast<TemplateDecl *>())
     if (Qual == Qualified::Fully &&
@@ -249,11 +247,11 @@
       OS << DTN->getIdentifier()->getName();
     else
       OS << "operator " << getOperatorSpelling(DTN->getOperator());
-  } else if (SubstTemplateTemplateParmStorage *subst
-               = getAsSubstTemplateTemplateParm()) {
+  } else if (SubstTemplateTemplateParmStorage *subst =
+                 getAsSubstTemplateTemplateParm()) {
     subst->getReplacement().print(OS, Policy, Qual);
-  } else if (SubstTemplateTemplateParmPackStorage *SubstPack
-                                        = getAsSubstTemplateTemplateParmPack())
+  } else if (SubstTemplateTemplateParmPackStorage *SubstPack =
+                 getAsSubstTemplateTemplateParmPack())
     OS << *SubstPack->getParameterPack();
   else if (AssumedTemplateStorage *Assumed = getAsAssumedTemplateName()) {
     Assumed->getDeclName().print(OS, Policy);
@@ -263,7 +261,7 @@
   }
 }
 
-const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
+StreamingDiagnostic const &clang::operator<<(StreamingDiagnostic const &DB,
                                              TemplateName N) {
   std::string NameStr;
   llvm::raw_string_ostream OS(NameStr);
@@ -278,12 +276,10 @@
 }
 
 void TemplateName::dump(raw_ostream &OS) const {
-  LangOptions LO;  // FIXME!
+  LangOptions LO; // FIXME!
   LO.CPlusPlus = true;
   LO.Bool = true;
   print(OS, PrintingPolicy(LO));
 }
 
-LLVM_DUMP_METHOD void TemplateName::dump() const {
-  dump(llvm::errs());
-}
+LLVM_DUMP_METHOD void TemplateName::dump() const { dump(llvm::errs()); }
Index: clang/lib/AST/TextNodeDumper.cpp
===================================================================
--- clang/lib/AST/TextNodeDumper.cpp
+++ clang/lib/AST/TextNodeDumper.cpp
@@ -31,14 +31,14 @@
 static void dumpPreviousDeclImpl(raw_ostream &OS, ...) {}
 
 template <typename T>
-static void dumpPreviousDeclImpl(raw_ostream &OS, const Mergeable<T> *D) {
+static void dumpPreviousDeclImpl(raw_ostream &OS, Mergeable<T> const *D) {
   const T *First = D->getFirstDecl();
   if (First != D)
     OS << " first " << First;
 }
 
 template <typename T>
-static void dumpPreviousDeclImpl(raw_ostream &OS, const Redeclarable<T> *D) {
+static void dumpPreviousDeclImpl(raw_ostream &OS, Redeclarable<T> const *D) {
   const T *Prev = D->getPreviousDecl();
   if (Prev)
     OS << " prev " << Prev;
@@ -46,7 +46,7 @@
 
 /// Dump the previous declaration in the redeclaration chain for a declaration,
 /// if any.
-static void dumpPreviousDecl(raw_ostream &OS, const Decl *D) {
+static void dumpPreviousDecl(raw_ostream &OS, Decl const *D) {
   switch (D->getKind()) {
 #define DECL(DERIVED, BASE)                                                    \
   case Decl::DERIVED:                                                          \
@@ -57,7 +57,7 @@
   llvm_unreachable("Decl that isn't part of DeclNodes.inc!");
 }
 
-TextNodeDumper::TextNodeDumper(raw_ostream &OS, const ASTContext &Context,
+TextNodeDumper::TextNodeDumper(raw_ostream &OS, ASTContext const &Context,
                                bool ShowColors)
     : TextTreeStructure(OS, ShowColors), OS(OS), ShowColors(ShowColors),
       Context(&Context), SM(&Context.getSourceManager()),
@@ -67,8 +67,8 @@
 TextNodeDumper::TextNodeDumper(raw_ostream &OS, bool ShowColors)
     : TextTreeStructure(OS, ShowColors), OS(OS), ShowColors(ShowColors) {}
 
-void TextNodeDumper::Visit(const comments::Comment *C,
-                           const comments::FullComment *FC) {
+void TextNodeDumper::Visit(comments::Comment const *C,
+                           comments::FullComment const *FC) {
   if (!C) {
     ColorScope Color(OS, ShowColors, NullColor);
     OS << "<<<NULL>>>";
@@ -83,10 +83,10 @@
   dumpSourceRange(C->getSourceRange());
 
   ConstCommentVisitor<TextNodeDumper, void,
-                      const comments::FullComment *>::visit(C, FC);
+                      comments::FullComment const *>::visit(C, FC);
 }
 
-void TextNodeDumper::Visit(const Attr *A) {
+void TextNodeDumper::Visit(Attr const *A) {
   {
     ColorScope Color(OS, ShowColors, AttrColor);
 
@@ -109,8 +109,8 @@
   ConstAttrVisitor<TextNodeDumper>::Visit(A);
 }
 
-void TextNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
-                           const Decl *From, StringRef Label) {
+void TextNodeDumper::Visit(TemplateArgument const &TA, SourceRange R,
+                           Decl const *From, StringRef Label) {
   OS << "TemplateArgument";
   if (R.isValid())
     dumpSourceRange(R);
@@ -121,7 +121,7 @@
   ConstTemplateArgumentVisitor<TextNodeDumper>::Visit(TA);
 }
 
-void TextNodeDumper::Visit(const Stmt *Node) {
+void TextNodeDumper::Visit(Stmt const *Node) {
   if (!Node) {
     ColorScope Color(OS, ShowColors, NullColor);
     OS << "<<<NULL>>>";
@@ -134,7 +134,7 @@
   dumpPointer(Node);
   dumpSourceRange(Node->getSourceRange());
 
-  if (const auto *E = dyn_cast<Expr>(Node)) {
+  if (auto const *E = dyn_cast<Expr>(Node)) {
     dumpType(E->getType());
 
     if (E->containsErrors()) {
@@ -183,7 +183,7 @@
   ConstStmtVisitor<TextNodeDumper>::Visit(Node);
 }
 
-void TextNodeDumper::Visit(const Type *T) {
+void TextNodeDumper::Visit(Type const *T) {
   if (!T) {
     ColorScope Color(OS, ShowColors, NullColor);
     OS << "<<<NULL>>>";
@@ -239,7 +239,7 @@
   OS << " " << T.split().Quals.getAsString();
 }
 
-void TextNodeDumper::Visit(const Decl *D) {
+void TextNodeDumper::Visit(Decl const *D) {
   if (!D) {
     ColorScope Color(OS, ShowColors, NullColor);
     OS << "<<<NULL>>>";
@@ -265,7 +265,7 @@
     for (Module *M : D->getASTContext().getModulesWithMergedDefinition(
              const_cast<NamedDecl *>(ND)))
       AddChild([=] { OS << "also in " << M->getFullModuleName(); });
-  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
+  if (NamedDecl const *ND = dyn_cast<NamedDecl>(D))
     if (!ND->isUnconditionallyVisible())
       OS << " hidden";
   if (D->isImplicit())
@@ -278,7 +278,7 @@
 
   if (D->isInvalidDecl())
     OS << " invalid";
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+  if (FunctionDecl const *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->isConstexprSpecified())
       OS << " constexpr";
     if (FD->isConsteval())
@@ -286,9 +286,9 @@
   }
 
   if (!isa<FunctionDecl>(*D)) {
-    const auto *MD = dyn_cast<ObjCMethodDecl>(D);
+    auto const *MD = dyn_cast<ObjCMethodDecl>(D);
     if (!MD || !MD->isThisDeclarationADefinition()) {
-      const auto *DC = dyn_cast<DeclContext>(D);
+      auto const *DC = dyn_cast<DeclContext>(D);
       if (DC && DC->hasExternalLexicalStorage()) {
         ColorScope Color(OS, ShowColors, UndeserializedColor);
         OS << " <undeserialized declarations>";
@@ -299,7 +299,7 @@
   ConstDeclVisitor<TextNodeDumper>::Visit(D);
 }
 
-void TextNodeDumper::Visit(const CXXCtorInitializer *Init) {
+void TextNodeDumper::Visit(CXXCtorInitializer const *Init) {
   OS << "CXXCtorInitializer";
   if (Init->isAnyMemberInitializer()) {
     OS << ' ';
@@ -313,7 +313,7 @@
   }
 }
 
-void TextNodeDumper::Visit(const BlockDecl::Capture &C) {
+void TextNodeDumper::Visit(BlockDecl::Capture const &C) {
   OS << "capture";
   if (C.isByRef())
     OS << " byref";
@@ -325,7 +325,7 @@
   }
 }
 
-void TextNodeDumper::Visit(const OMPClause *C) {
+void TextNodeDumper::Visit(OMPClause const *C) {
   if (!C) {
     ColorScope Color(OS, ShowColors, NullColor);
     OS << "<<<NULL>>> OMPClause";
@@ -343,8 +343,8 @@
     OS << " <implicit>";
 }
 
-void TextNodeDumper::Visit(const GenericSelectionExpr::ConstAssociation &A) {
-  const TypeSourceInfo *TSI = A.getTypeSourceInfo();
+void TextNodeDumper::Visit(GenericSelectionExpr::ConstAssociation const &A) {
+  TypeSourceInfo const *TSI = A.getTypeSourceInfo();
   if (TSI) {
     OS << "case ";
     dumpType(TSI->getType());
@@ -356,7 +356,7 @@
     OS << " selected";
 }
 
-void TextNodeDumper::Visit(const concepts::Requirement *R) {
+void TextNodeDumper::Visit(concepts::Requirement const *R) {
   if (!R) {
     ColorScope Color(OS, ShowColors, NullColor);
     OS << "<<<NULL>>> Requirement";
@@ -396,7 +396,7 @@
     OS << " contains_unexpanded_pack";
 }
 
-static double GetApproxValue(const llvm::APFloat &F) {
+static double GetApproxValue(llvm::APFloat const &F) {
   llvm::APFloat V = F;
   bool ignored;
   V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
@@ -405,7 +405,7 @@
 }
 
 /// True if the \p APValue \p Value can be folded onto the current line.
-static bool isSimpleAPValue(const APValue &Value) {
+static bool isSimpleAPValue(APValue const &Value) {
   switch (Value.getKind()) {
   case APValue::None:
   case APValue::Indeterminate:
@@ -442,8 +442,8 @@
 /// \param[in] LabelSingular  The label to use on a line with a single child
 /// \param[in] LabelPlurial   The label to use on a line with multiple children
 void TextNodeDumper::dumpAPValueChildren(
-    const APValue &Value, QualType Ty,
-    const APValue &(*IdxToChildFun)(const APValue &, unsigned),
+    APValue const &Value, QualType Ty,
+    APValue const &(*IdxToChildFun)(APValue const &, unsigned),
     unsigned NumChildren, StringRef LabelSingular, StringRef LabelPlurial) {
   // To save some vertical space we print up to MaxChildrenPerLine APValues
   // considered to be simple (by isSimpleAPValue) on a single line.
@@ -474,7 +474,7 @@
   }
 }
 
-void TextNodeDumper::Visit(const APValue &Value, QualType Ty) {
+void TextNodeDumper::Visit(APValue const &Value, QualType Ty) {
   ColorScope Color(OS, ShowColors, ValueKindColor);
   switch (Value.getKind()) {
   case APValue::None:
@@ -510,7 +510,7 @@
 
     dumpAPValueChildren(
         Value, Ty,
-        [](const APValue &Value, unsigned Index) -> const APValue & {
+        [](APValue const &Value, unsigned Index) -> APValue const & {
           return Value.getVectorElt(Index);
         },
         VectorLength, "element", "elements");
@@ -543,7 +543,7 @@
 
     dumpAPValueChildren(
         Value, Ty,
-        [](const APValue &Value, unsigned Index) -> const APValue & {
+        [](APValue const &Value, unsigned Index) -> APValue const & {
           return Value.getArrayInitializedElt(Index);
         },
         NumInitializedElements, "element", "elements");
@@ -565,14 +565,14 @@
 
     dumpAPValueChildren(
         Value, Ty,
-        [](const APValue &Value, unsigned Index) -> const APValue & {
+        [](APValue const &Value, unsigned Index) -> APValue const & {
           return Value.getStructBase(Index);
         },
         Value.getStructNumBases(), "base", "bases");
 
     dumpAPValueChildren(
         Value, Ty,
-        [](const APValue &Value, unsigned Index) -> const APValue & {
+        [](APValue const &Value, unsigned Index) -> APValue const & {
           return Value.getStructField(Index);
         },
         Value.getStructNumFields(), "field", "fields");
@@ -583,12 +583,12 @@
     OS << "Union";
     {
       ColorScope Color(OS, ShowColors, ValueColor);
-      if (const FieldDecl *FD = Value.getUnionField())
+      if (FieldDecl const *FD = Value.getUnionField())
         OS << " ." << *cast<NamedDecl>(FD);
     }
     // If the union value is considered to be simple, fold it into the
     // current line to save some vertical space.
-    const APValue &UnionValue = Value.getUnionValue();
+    APValue const &UnionValue = Value.getUnionValue();
     if (isSimpleAPValue(UnionValue)) {
       OS << ' ';
       Visit(UnionValue, Ty);
@@ -608,7 +608,7 @@
   llvm_unreachable("Unknown APValue kind!");
 }
 
-void TextNodeDumper::dumpPointer(const void *Ptr) {
+void TextNodeDumper::dumpPointer(void const *Ptr) {
   ColorScope Color(OS, ShowColors, AddressColor);
   OS << ' ' << Ptr;
 }
@@ -677,7 +677,7 @@
   dumpBareType(T);
 }
 
-void TextNodeDumper::dumpBareDeclRef(const Decl *D) {
+void TextNodeDumper::dumpBareDeclRef(Decl const *D) {
   if (!D) {
     ColorScope Color(OS, ShowColors, NullColor);
     OS << "<<<NULL>>>";
@@ -690,16 +690,16 @@
   }
   dumpPointer(D);
 
-  if (const NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
+  if (NamedDecl const *ND = dyn_cast<NamedDecl>(D)) {
     ColorScope Color(OS, ShowColors, DeclNameColor);
     OS << " '" << ND->getDeclName() << '\'';
   }
 
-  if (const ValueDecl *VD = dyn_cast<ValueDecl>(D))
+  if (ValueDecl const *VD = dyn_cast<ValueDecl>(D))
     dumpType(VD->getType());
 }
 
-void TextNodeDumper::dumpName(const NamedDecl *ND) {
+void TextNodeDumper::dumpName(NamedDecl const *ND) {
   if (ND->getDeclName()) {
     ColorScope Color(OS, ShowColors, DeclNameColor);
     OS << ' ' << ND->getDeclName();
@@ -707,14 +707,14 @@
 }
 
 void TextNodeDumper::dumpAccessSpecifier(AccessSpecifier AS) {
-  const auto AccessSpelling = getAccessSpelling(AS);
+  auto const AccessSpelling = getAccessSpelling(AS);
   if (AccessSpelling.empty())
     return;
   OS << AccessSpelling;
 }
 
 void TextNodeDumper::dumpCleanupObject(
-    const ExprWithCleanups::CleanupObject &C) {
+    ExprWithCleanups::CleanupObject const &C) {
   if (auto *BD = C.dyn_cast<BlockDecl *>())
     dumpDeclRef(BD, "cleanup");
   else if (auto *CLE = C.dyn_cast<CompoundLiteralExpr *>())
@@ -730,7 +730,7 @@
     llvm_unreachable("unexpected cleanup type");
 }
 
-void TextNodeDumper::dumpDeclRef(const Decl *D, StringRef Label) {
+void TextNodeDumper::dumpDeclRef(Decl const *D, StringRef Label) {
   if (!D)
     return;
 
@@ -741,10 +741,10 @@
   });
 }
 
-const char *TextNodeDumper::getCommandName(unsigned CommandID) {
+char const *TextNodeDumper::getCommandName(unsigned CommandID) {
   if (Traits)
     return Traits->getCommandInfo(CommandID)->Name;
-  const comments::CommandInfo *Info =
+  comments::CommandInfo const *Info =
       comments::CommandTraits::getBuiltinCommandInfo(CommandID);
   if (Info)
     return Info->Name;
@@ -758,13 +758,13 @@
 #include "clang/Basic/FPOptions.def"
 }
 
-void TextNodeDumper::visitTextComment(const comments::TextComment *C,
-                                      const comments::FullComment *) {
+void TextNodeDumper::visitTextComment(comments::TextComment const *C,
+                                      comments::FullComment const *) {
   OS << " Text=\"" << C->getText() << "\"";
 }
 
 void TextNodeDumper::visitInlineCommandComment(
-    const comments::InlineCommandComment *C, const comments::FullComment *) {
+    comments::InlineCommandComment const *C, comments::FullComment const *) {
   OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
   switch (C->getRenderKind()) {
   case comments::InlineCommandComment::RenderNormal:
@@ -789,12 +789,12 @@
 }
 
 void TextNodeDumper::visitHTMLStartTagComment(
-    const comments::HTMLStartTagComment *C, const comments::FullComment *) {
+    comments::HTMLStartTagComment const *C, comments::FullComment const *) {
   OS << " Name=\"" << C->getTagName() << "\"";
   if (C->getNumAttrs() != 0) {
     OS << " Attrs: ";
     for (unsigned i = 0, e = C->getNumAttrs(); i != e; ++i) {
-      const comments::HTMLStartTagComment::Attribute &Attr = C->getAttr(i);
+      comments::HTMLStartTagComment::Attribute const &Attr = C->getAttr(i);
       OS << " \"" << Attr.Name << "=\"" << Attr.Value << "\"";
     }
   }
@@ -803,19 +803,19 @@
 }
 
 void TextNodeDumper::visitHTMLEndTagComment(
-    const comments::HTMLEndTagComment *C, const comments::FullComment *) {
+    comments::HTMLEndTagComment const *C, comments::FullComment const *) {
   OS << " Name=\"" << C->getTagName() << "\"";
 }
 
 void TextNodeDumper::visitBlockCommandComment(
-    const comments::BlockCommandComment *C, const comments::FullComment *) {
+    comments::BlockCommandComment const *C, comments::FullComment const *) {
   OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
   for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
     OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
 }
 
 void TextNodeDumper::visitParamCommandComment(
-    const comments::ParamCommandComment *C, const comments::FullComment *FC) {
+    comments::ParamCommandComment const *C, comments::FullComment const *FC) {
   OS << " "
      << comments::ParamCommandComment::getDirectionAsString(C->getDirection());
 
@@ -836,7 +836,7 @@
 }
 
 void TextNodeDumper::visitTParamCommandComment(
-    const comments::TParamCommandComment *C, const comments::FullComment *FC) {
+    comments::TParamCommandComment const *C, comments::FullComment const *FC) {
   if (C->hasParamName()) {
     if (C->isPositionValid())
       OS << " Param=\"" << C->getParamName(FC) << "\"";
@@ -856,7 +856,7 @@
 }
 
 void TextNodeDumper::visitVerbatimBlockComment(
-    const comments::VerbatimBlockComment *C, const comments::FullComment *) {
+    comments::VerbatimBlockComment const *C, comments::FullComment const *) {
   OS << " Name=\"" << getCommandName(C->getCommandID())
      << "\""
         " CloseName=\""
@@ -864,59 +864,59 @@
 }
 
 void TextNodeDumper::visitVerbatimBlockLineComment(
-    const comments::VerbatimBlockLineComment *C,
-    const comments::FullComment *) {
+    comments::VerbatimBlockLineComment const *C,
+    comments::FullComment const *) {
   OS << " Text=\"" << C->getText() << "\"";
 }
 
 void TextNodeDumper::visitVerbatimLineComment(
-    const comments::VerbatimLineComment *C, const comments::FullComment *) {
+    comments::VerbatimLineComment const *C, comments::FullComment const *) {
   OS << " Text=\"" << C->getText() << "\"";
 }
 
-void TextNodeDumper::VisitNullTemplateArgument(const TemplateArgument &) {
+void TextNodeDumper::VisitNullTemplateArgument(TemplateArgument const &) {
   OS << " null";
 }
 
-void TextNodeDumper::VisitTypeTemplateArgument(const TemplateArgument &TA) {
+void TextNodeDumper::VisitTypeTemplateArgument(TemplateArgument const &TA) {
   OS << " type";
   dumpType(TA.getAsType());
 }
 
 void TextNodeDumper::VisitDeclarationTemplateArgument(
-    const TemplateArgument &TA) {
+    TemplateArgument const &TA) {
   OS << " decl";
   dumpDeclRef(TA.getAsDecl());
 }
 
-void TextNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &) {
+void TextNodeDumper::VisitNullPtrTemplateArgument(TemplateArgument const &) {
   OS << " nullptr";
 }
 
-void TextNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
+void TextNodeDumper::VisitIntegralTemplateArgument(TemplateArgument const &TA) {
   OS << " integral " << TA.getAsIntegral();
 }
 
-void TextNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
+void TextNodeDumper::VisitTemplateTemplateArgument(TemplateArgument const &TA) {
   OS << " template ";
   TA.getAsTemplate().dump(OS);
 }
 
 void TextNodeDumper::VisitTemplateExpansionTemplateArgument(
-    const TemplateArgument &TA) {
+    TemplateArgument const &TA) {
   OS << " template expansion ";
   TA.getAsTemplateOrTemplatePattern().dump(OS);
 }
 
-void TextNodeDumper::VisitExpressionTemplateArgument(const TemplateArgument &) {
+void TextNodeDumper::VisitExpressionTemplateArgument(TemplateArgument const &) {
   OS << " expr";
 }
 
-void TextNodeDumper::VisitPackTemplateArgument(const TemplateArgument &) {
+void TextNodeDumper::VisitPackTemplateArgument(TemplateArgument const &) {
   OS << " pack";
 }
 
-static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {
+static void dumpBasePath(raw_ostream &OS, CastExpr const *Node) {
   if (Node->path_empty())
     return;
 
@@ -925,11 +925,11 @@
   for (CastExpr::path_const_iterator I = Node->path_begin(),
                                      E = Node->path_end();
        I != E; ++I) {
-    const CXXBaseSpecifier *Base = *I;
+    CXXBaseSpecifier const *Base = *I;
     if (!First)
       OS << " -> ";
 
-    const auto *RD =
+    auto const *RD =
         cast<CXXRecordDecl>(Base->getType()->castAs<RecordType>()->getDecl());
 
     if (Base->isVirtual())
@@ -941,7 +941,7 @@
   OS << ')';
 }
 
-void TextNodeDumper::VisitIfStmt(const IfStmt *Node) {
+void TextNodeDumper::VisitIfStmt(IfStmt const *Node) {
   if (Node->hasInitStorage())
     OS << " has_init";
   if (Node->hasVarStorage())
@@ -950,56 +950,57 @@
     OS << " has_else";
 }
 
-void TextNodeDumper::VisitSwitchStmt(const SwitchStmt *Node) {
+void TextNodeDumper::VisitSwitchStmt(SwitchStmt const *Node) {
   if (Node->hasInitStorage())
     OS << " has_init";
   if (Node->hasVarStorage())
     OS << " has_var";
 }
 
-void TextNodeDumper::VisitWhileStmt(const WhileStmt *Node) {
+void TextNodeDumper::VisitWhileStmt(WhileStmt const *Node) {
   if (Node->hasVarStorage())
     OS << " has_var";
 }
 
-void TextNodeDumper::VisitLabelStmt(const LabelStmt *Node) {
+void TextNodeDumper::VisitLabelStmt(LabelStmt const *Node) {
   OS << " '" << Node->getName() << "'";
   if (Node->isSideEntry())
     OS << " side_entry";
 }
 
-void TextNodeDumper::VisitGotoStmt(const GotoStmt *Node) {
+void TextNodeDumper::VisitGotoStmt(GotoStmt const *Node) {
   OS << " '" << Node->getLabel()->getName() << "'";
   dumpPointer(Node->getLabel());
 }
 
-void TextNodeDumper::VisitCaseStmt(const CaseStmt *Node) {
+void TextNodeDumper::VisitCaseStmt(CaseStmt const *Node) {
   if (Node->caseStmtIsGNURange())
     OS << " gnu_range";
 }
 
-void TextNodeDumper::VisitConstantExpr(const ConstantExpr *Node) {
+void TextNodeDumper::VisitConstantExpr(ConstantExpr const *Node) {
   if (Node->hasAPValueResult())
     AddChild("value",
              [=] { Visit(Node->getAPValueResult(), Node->getType()); });
 }
 
-void TextNodeDumper::VisitCallExpr(const CallExpr *Node) {
+void TextNodeDumper::VisitCallExpr(CallExpr const *Node) {
   if (Node->usesADL())
     OS << " adl";
   if (Node->hasStoredFPFeatures())
     printFPOptions(Node->getFPFeatures());
 }
 
-void TextNodeDumper::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *Node) {
-  const char *OperatorSpelling = clang::getOperatorSpelling(Node->getOperator());
+void TextNodeDumper::VisitCXXOperatorCallExpr(CXXOperatorCallExpr const *Node) {
+  char const *OperatorSpelling =
+      clang::getOperatorSpelling(Node->getOperator());
   if (OperatorSpelling)
     OS << " '" << OperatorSpelling << "'";
 
   VisitCallExpr(Node);
 }
 
-void TextNodeDumper::VisitCastExpr(const CastExpr *Node) {
+void TextNodeDumper::VisitCastExpr(CastExpr const *Node) {
   OS << " <";
   {
     ColorScope Color(OS, ShowColors, CastColor);
@@ -1011,13 +1012,13 @@
     printFPOptions(Node->getFPFeatures());
 }
 
-void TextNodeDumper::VisitImplicitCastExpr(const ImplicitCastExpr *Node) {
+void TextNodeDumper::VisitImplicitCastExpr(ImplicitCastExpr const *Node) {
   VisitCastExpr(Node);
   if (Node->isPartOfExplicitCast())
     OS << " part_of_explicit_cast";
 }
 
-void TextNodeDumper::VisitDeclRefExpr(const DeclRefExpr *Node) {
+void TextNodeDumper::VisitDeclRefExpr(DeclRefExpr const *Node) {
   OS << " ";
   dumpBareDeclRef(Node->getDecl());
   if (Node->getDecl() != Node->getFoundDecl()) {
@@ -1026,15 +1027,22 @@
     OS << ")";
   }
   switch (Node->isNonOdrUse()) {
-  case NOUR_None: break;
-  case NOUR_Unevaluated: OS << " non_odr_use_unevaluated"; break;
-  case NOUR_Constant: OS << " non_odr_use_constant"; break;
-  case NOUR_Discarded: OS << " non_odr_use_discarded"; break;
+  case NOUR_None:
+    break;
+  case NOUR_Unevaluated:
+    OS << " non_odr_use_unevaluated";
+    break;
+  case NOUR_Constant:
+    OS << " non_odr_use_constant";
+    break;
+  case NOUR_Discarded:
+    OS << " non_odr_use_discarded";
+    break;
   }
 }
 
 void TextNodeDumper::VisitUnresolvedLookupExpr(
-    const UnresolvedLookupExpr *Node) {
+    UnresolvedLookupExpr const *Node) {
   OS << " (";
   if (!Node->requiresADL())
     OS << "no ";
@@ -1048,7 +1056,7 @@
     dumpPointer(*I);
 }
 
-void TextNodeDumper::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Node) {
+void TextNodeDumper::VisitObjCIvarRefExpr(ObjCIvarRefExpr const *Node) {
   {
     ColorScope Color(OS, ShowColors, DeclKindNameColor);
     OS << " " << Node->getDecl()->getDeclKindName() << "Decl";
@@ -1060,54 +1068,54 @@
 }
 
 void TextNodeDumper::VisitSYCLUniqueStableNameExpr(
-    const SYCLUniqueStableNameExpr *Node) {
+    SYCLUniqueStableNameExpr const *Node) {
   dumpType(Node->getTypeSourceInfo()->getType());
 }
 
-void TextNodeDumper::VisitPredefinedExpr(const PredefinedExpr *Node) {
+void TextNodeDumper::VisitPredefinedExpr(PredefinedExpr const *Node) {
   OS << " " << PredefinedExpr::getIdentKindName(Node->getIdentKind());
 }
 
-void TextNodeDumper::VisitCharacterLiteral(const CharacterLiteral *Node) {
+void TextNodeDumper::VisitCharacterLiteral(CharacterLiteral const *Node) {
   ColorScope Color(OS, ShowColors, ValueColor);
   OS << " " << Node->getValue();
 }
 
-void TextNodeDumper::VisitIntegerLiteral(const IntegerLiteral *Node) {
+void TextNodeDumper::VisitIntegerLiteral(IntegerLiteral const *Node) {
   bool isSigned = Node->getType()->isSignedIntegerType();
   ColorScope Color(OS, ShowColors, ValueColor);
   OS << " " << toString(Node->getValue(), 10, isSigned);
 }
 
-void TextNodeDumper::VisitFixedPointLiteral(const FixedPointLiteral *Node) {
+void TextNodeDumper::VisitFixedPointLiteral(FixedPointLiteral const *Node) {
   ColorScope Color(OS, ShowColors, ValueColor);
   OS << " " << Node->getValueAsString(/*Radix=*/10);
 }
 
-void TextNodeDumper::VisitFloatingLiteral(const FloatingLiteral *Node) {
+void TextNodeDumper::VisitFloatingLiteral(FloatingLiteral const *Node) {
   ColorScope Color(OS, ShowColors, ValueColor);
   OS << " " << Node->getValueAsApproximateDouble();
 }
 
-void TextNodeDumper::VisitStringLiteral(const StringLiteral *Str) {
+void TextNodeDumper::VisitStringLiteral(StringLiteral const *Str) {
   ColorScope Color(OS, ShowColors, ValueColor);
   OS << " ";
   Str->outputString(OS);
 }
 
-void TextNodeDumper::VisitInitListExpr(const InitListExpr *ILE) {
+void TextNodeDumper::VisitInitListExpr(InitListExpr const *ILE) {
   if (auto *Field = ILE->getInitializedFieldInUnion()) {
     OS << " field ";
     dumpBareDeclRef(Field);
   }
 }
 
-void TextNodeDumper::VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
+void TextNodeDumper::VisitGenericSelectionExpr(GenericSelectionExpr const *E) {
   if (E->isResultDependent())
     OS << " result_dependent";
 }
 
-void TextNodeDumper::VisitUnaryOperator(const UnaryOperator *Node) {
+void TextNodeDumper::VisitUnaryOperator(UnaryOperator const *Node) {
   OS << " " << (Node->isPostfix() ? "postfix" : "prefix") << " '"
      << UnaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
   if (!Node->canOverflow())
@@ -1117,37 +1125,44 @@
 }
 
 void TextNodeDumper::VisitUnaryExprOrTypeTraitExpr(
-    const UnaryExprOrTypeTraitExpr *Node) {
+    UnaryExprOrTypeTraitExpr const *Node) {
   OS << " " << getTraitSpelling(Node->getKind());
 
   if (Node->isArgumentType())
     dumpType(Node->getArgumentType());
 }
 
-void TextNodeDumper::VisitMemberExpr(const MemberExpr *Node) {
+void TextNodeDumper::VisitMemberExpr(MemberExpr const *Node) {
   OS << " " << (Node->isArrow() ? "->" : ".") << *Node->getMemberDecl();
   dumpPointer(Node->getMemberDecl());
   switch (Node->isNonOdrUse()) {
-  case NOUR_None: break;
-  case NOUR_Unevaluated: OS << " non_odr_use_unevaluated"; break;
-  case NOUR_Constant: OS << " non_odr_use_constant"; break;
-  case NOUR_Discarded: OS << " non_odr_use_discarded"; break;
+  case NOUR_None:
+    break;
+  case NOUR_Unevaluated:
+    OS << " non_odr_use_unevaluated";
+    break;
+  case NOUR_Constant:
+    OS << " non_odr_use_constant";
+    break;
+  case NOUR_Discarded:
+    OS << " non_odr_use_discarded";
+    break;
   }
 }
 
 void TextNodeDumper::VisitExtVectorElementExpr(
-    const ExtVectorElementExpr *Node) {
+    ExtVectorElementExpr const *Node) {
   OS << " " << Node->getAccessor().getNameStart();
 }
 
-void TextNodeDumper::VisitBinaryOperator(const BinaryOperator *Node) {
+void TextNodeDumper::VisitBinaryOperator(BinaryOperator const *Node) {
   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode()) << "'";
   if (Node->hasStoredFPFeatures())
     printFPOptions(Node->getStoredFPFeatures());
 }
 
 void TextNodeDumper::VisitCompoundAssignOperator(
-    const CompoundAssignOperator *Node) {
+    CompoundAssignOperator const *Node) {
   OS << " '" << BinaryOperator::getOpcodeStr(Node->getOpcode())
      << "' ComputeLHSTy=";
   dumpBareType(Node->getComputationLHSType());
@@ -1157,12 +1172,12 @@
     printFPOptions(Node->getStoredFPFeatures());
 }
 
-void TextNodeDumper::VisitAddrLabelExpr(const AddrLabelExpr *Node) {
+void TextNodeDumper::VisitAddrLabelExpr(AddrLabelExpr const *Node) {
   OS << " " << Node->getLabel()->getName();
   dumpPointer(Node->getLabel());
 }
 
-void TextNodeDumper::VisitCXXNamedCastExpr(const CXXNamedCastExpr *Node) {
+void TextNodeDumper::VisitCXXNamedCastExpr(CXXNamedCastExpr const *Node) {
   OS << " " << Node->getCastName() << "<"
      << Node->getTypeAsWritten().getAsString() << ">"
      << " <" << Node->getCastKindName();
@@ -1170,38 +1185,38 @@
   OS << ">";
 }
 
-void TextNodeDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *Node) {
+void TextNodeDumper::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr const *Node) {
   OS << " " << (Node->getValue() ? "true" : "false");
 }
 
-void TextNodeDumper::VisitCXXThisExpr(const CXXThisExpr *Node) {
+void TextNodeDumper::VisitCXXThisExpr(CXXThisExpr const *Node) {
   if (Node->isImplicit())
     OS << " implicit";
   OS << " this";
 }
 
 void TextNodeDumper::VisitCXXFunctionalCastExpr(
-    const CXXFunctionalCastExpr *Node) {
+    CXXFunctionalCastExpr const *Node) {
   OS << " functional cast to " << Node->getTypeAsWritten().getAsString() << " <"
      << Node->getCastKindName() << ">";
   if (Node->hasStoredFPFeatures())
     printFPOptions(Node->getFPFeatures());
 }
 
-void TextNodeDumper::VisitCXXStaticCastExpr(const CXXStaticCastExpr *Node) {
+void TextNodeDumper::VisitCXXStaticCastExpr(CXXStaticCastExpr const *Node) {
   VisitCXXNamedCastExpr(Node);
   if (Node->hasStoredFPFeatures())
     printFPOptions(Node->getFPFeatures());
 }
 
 void TextNodeDumper::VisitCXXUnresolvedConstructExpr(
-    const CXXUnresolvedConstructExpr *Node) {
+    CXXUnresolvedConstructExpr const *Node) {
   dumpType(Node->getTypeAsWritten());
   if (Node->isListInitialization())
     OS << " list";
 }
 
-void TextNodeDumper::VisitCXXConstructExpr(const CXXConstructExpr *Node) {
+void TextNodeDumper::VisitCXXConstructExpr(CXXConstructExpr const *Node) {
   CXXConstructorDecl *Ctor = Node->getConstructor();
   dumpType(Ctor->getType());
   if (Node->isElidable())
@@ -1215,13 +1230,13 @@
 }
 
 void TextNodeDumper::VisitCXXBindTemporaryExpr(
-    const CXXBindTemporaryExpr *Node) {
+    CXXBindTemporaryExpr const *Node) {
   OS << " (CXXTemporary";
   dumpPointer(Node);
   OS << ")";
 }
 
-void TextNodeDumper::VisitCXXNewExpr(const CXXNewExpr *Node) {
+void TextNodeDumper::VisitCXXNewExpr(CXXNewExpr const *Node) {
   if (Node->isGlobalNew())
     OS << " global";
   if (Node->isArray())
@@ -1234,7 +1249,7 @@
   // usually not that interesting.
 }
 
-void TextNodeDumper::VisitCXXDeleteExpr(const CXXDeleteExpr *Node) {
+void TextNodeDumper::VisitCXXDeleteExpr(CXXDeleteExpr const *Node) {
   if (Node->isGlobalDelete())
     OS << " global";
   if (Node->isArrayForm())
@@ -1245,42 +1260,42 @@
   }
 }
 
-void TextNodeDumper::VisitTypeTraitExpr(const TypeTraitExpr *Node) {
+void TextNodeDumper::VisitTypeTraitExpr(TypeTraitExpr const *Node) {
   OS << " " << getTraitSpelling(Node->getTrait());
 }
 
-void TextNodeDumper::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *Node) {
+void TextNodeDumper::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr const *Node) {
   OS << " " << getTraitSpelling(Node->getTrait());
 }
 
-void TextNodeDumper::VisitExpressionTraitExpr(const ExpressionTraitExpr *Node) {
+void TextNodeDumper::VisitExpressionTraitExpr(ExpressionTraitExpr const *Node) {
   OS << " " << getTraitSpelling(Node->getTrait());
 }
 
 void TextNodeDumper::VisitMaterializeTemporaryExpr(
-    const MaterializeTemporaryExpr *Node) {
-  if (const ValueDecl *VD = Node->getExtendingDecl()) {
+    MaterializeTemporaryExpr const *Node) {
+  if (ValueDecl const *VD = Node->getExtendingDecl()) {
     OS << " extended by ";
     dumpBareDeclRef(VD);
   }
 }
 
-void TextNodeDumper::VisitExprWithCleanups(const ExprWithCleanups *Node) {
+void TextNodeDumper::VisitExprWithCleanups(ExprWithCleanups const *Node) {
   for (unsigned i = 0, e = Node->getNumObjects(); i != e; ++i)
     dumpCleanupObject(Node->getObject(i));
 }
 
-void TextNodeDumper::VisitSizeOfPackExpr(const SizeOfPackExpr *Node) {
+void TextNodeDumper::VisitSizeOfPackExpr(SizeOfPackExpr const *Node) {
   dumpPointer(Node->getPack());
   dumpName(Node->getPack());
 }
 
 void TextNodeDumper::VisitCXXDependentScopeMemberExpr(
-    const CXXDependentScopeMemberExpr *Node) {
+    CXXDependentScopeMemberExpr const *Node) {
   OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember();
 }
 
-void TextNodeDumper::VisitObjCMessageExpr(const ObjCMessageExpr *Node) {
+void TextNodeDumper::VisitObjCMessageExpr(ObjCMessageExpr const *Node) {
   OS << " selector=";
   Node->getSelector().print(OS);
   switch (Node->getReceiverKind()) {
@@ -1302,32 +1317,32 @@
   }
 }
 
-void TextNodeDumper::VisitObjCBoxedExpr(const ObjCBoxedExpr *Node) {
+void TextNodeDumper::VisitObjCBoxedExpr(ObjCBoxedExpr const *Node) {
   if (auto *BoxingMethod = Node->getBoxingMethod()) {
     OS << " selector=";
     BoxingMethod->getSelector().print(OS);
   }
 }
 
-void TextNodeDumper::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node) {
+void TextNodeDumper::VisitObjCAtCatchStmt(ObjCAtCatchStmt const *Node) {
   if (!Node->getCatchParamDecl())
     OS << " catch all";
 }
 
-void TextNodeDumper::VisitObjCEncodeExpr(const ObjCEncodeExpr *Node) {
+void TextNodeDumper::VisitObjCEncodeExpr(ObjCEncodeExpr const *Node) {
   dumpType(Node->getEncodedType());
 }
 
-void TextNodeDumper::VisitObjCSelectorExpr(const ObjCSelectorExpr *Node) {
+void TextNodeDumper::VisitObjCSelectorExpr(ObjCSelectorExpr const *Node) {
   OS << " ";
   Node->getSelector().print(OS);
 }
 
-void TextNodeDumper::VisitObjCProtocolExpr(const ObjCProtocolExpr *Node) {
+void TextNodeDumper::VisitObjCProtocolExpr(ObjCProtocolExpr const *Node) {
   OS << ' ' << *Node->getProtocol();
 }
 
-void TextNodeDumper::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Node) {
+void TextNodeDumper::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr const *Node) {
   if (Node->isImplicitProperty()) {
     OS << " Kind=MethodRef Getter=\"";
     if (Node->getImplicitPropertyGetter())
@@ -1359,7 +1374,7 @@
 }
 
 void TextNodeDumper::VisitObjCSubscriptRefExpr(
-    const ObjCSubscriptRefExpr *Node) {
+    ObjCSubscriptRefExpr const *Node) {
   if (Node->isArraySubscriptRefExpr())
     OS << " Kind=ArraySubscript GetterForArray=\"";
   else
@@ -1379,11 +1394,11 @@
     OS << "(null)";
 }
 
-void TextNodeDumper::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *Node) {
+void TextNodeDumper::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr const *Node) {
   OS << " " << (Node->getValue() ? "__objc_yes" : "__objc_no");
 }
 
-void TextNodeDumper::VisitOMPIteratorExpr(const OMPIteratorExpr *Node) {
+void TextNodeDumper::VisitOMPIteratorExpr(OMPIteratorExpr const *Node) {
   OS << " ";
   for (unsigned I = 0, E = Node->numOfIterators(); I < E; ++I) {
     Visit(Node->getIteratorDecl(I));
@@ -1401,23 +1416,22 @@
 }
 
 void TextNodeDumper::VisitConceptSpecializationExpr(
-    const ConceptSpecializationExpr *Node) {
+    ConceptSpecializationExpr const *Node) {
   OS << " ";
   dumpBareDeclRef(Node->getFoundDecl());
 }
 
-void TextNodeDumper::VisitRequiresExpr(
-    const RequiresExpr *Node) {
+void TextNodeDumper::VisitRequiresExpr(RequiresExpr const *Node) {
   if (!Node->isValueDependent())
     OS << (Node->isSatisfied() ? " satisfied" : " unsatisfied");
 }
 
-void TextNodeDumper::VisitRValueReferenceType(const ReferenceType *T) {
+void TextNodeDumper::VisitRValueReferenceType(ReferenceType const *T) {
   if (T->isSpelledAsLValue())
     OS << " written as lvalue reference";
 }
 
-void TextNodeDumper::VisitArrayType(const ArrayType *T) {
+void TextNodeDumper::VisitArrayType(ArrayType const *T) {
   switch (T->getSizeModifier()) {
   case ArrayType::Normal:
     break;
@@ -1431,31 +1445,31 @@
   OS << " " << T->getIndexTypeQualifiers().getAsString();
 }
 
-void TextNodeDumper::VisitConstantArrayType(const ConstantArrayType *T) {
+void TextNodeDumper::VisitConstantArrayType(ConstantArrayType const *T) {
   OS << " " << T->getSize();
   VisitArrayType(T);
 }
 
-void TextNodeDumper::VisitVariableArrayType(const VariableArrayType *T) {
+void TextNodeDumper::VisitVariableArrayType(VariableArrayType const *T) {
   OS << " ";
   dumpSourceRange(T->getBracketsRange());
   VisitArrayType(T);
 }
 
 void TextNodeDumper::VisitDependentSizedArrayType(
-    const DependentSizedArrayType *T) {
+    DependentSizedArrayType const *T) {
   VisitArrayType(T);
   OS << " ";
   dumpSourceRange(T->getBracketsRange());
 }
 
 void TextNodeDumper::VisitDependentSizedExtVectorType(
-    const DependentSizedExtVectorType *T) {
+    DependentSizedExtVectorType const *T) {
   OS << " ";
   dumpLocation(T->getAttributeLoc());
 }
 
-void TextNodeDumper::VisitVectorType(const VectorType *T) {
+void TextNodeDumper::VisitVectorType(VectorType const *T) {
   switch (T->getVectorKind()) {
   case VectorType::GenericVector:
     break;
@@ -1484,7 +1498,7 @@
   OS << " " << T->getNumElements();
 }
 
-void TextNodeDumper::VisitFunctionType(const FunctionType *T) {
+void TextNodeDumper::VisitFunctionType(FunctionType const *T) {
   auto EI = T->getExtInfo();
   if (EI.getNoReturn())
     OS << " noreturn";
@@ -1495,7 +1509,7 @@
   OS << " " << FunctionType::getNameForCallConv(EI.getCC());
 }
 
-void TextNodeDumper::VisitFunctionProtoType(const FunctionProtoType *T) {
+void TextNodeDumper::VisitFunctionProtoType(FunctionProtoType const *T) {
   auto EPI = T->getExtProtoInfo();
   if (EPI.HasTrailingReturn)
     OS << " trailing_return";
@@ -1522,15 +1536,15 @@
   VisitFunctionType(T);
 }
 
-void TextNodeDumper::VisitUnresolvedUsingType(const UnresolvedUsingType *T) {
+void TextNodeDumper::VisitUnresolvedUsingType(UnresolvedUsingType const *T) {
   dumpDeclRef(T->getDecl());
 }
 
-void TextNodeDumper::VisitTypedefType(const TypedefType *T) {
+void TextNodeDumper::VisitTypedefType(TypedefType const *T) {
   dumpDeclRef(T->getDecl());
 }
 
-void TextNodeDumper::VisitUnaryTransformType(const UnaryTransformType *T) {
+void TextNodeDumper::VisitUnaryTransformType(UnaryTransformType const *T) {
   switch (T->getUTTKind()) {
   case UnaryTransformType::EnumUnderlyingType:
     OS << " underlying_type";
@@ -1538,31 +1552,31 @@
   }
 }
 
-void TextNodeDumper::VisitTagType(const TagType *T) {
+void TextNodeDumper::VisitTagType(TagType const *T) {
   dumpDeclRef(T->getDecl());
 }
 
-void TextNodeDumper::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
+void TextNodeDumper::VisitTemplateTypeParmType(TemplateTypeParmType const *T) {
   OS << " depth " << T->getDepth() << " index " << T->getIndex();
   if (T->isParameterPack())
     OS << " pack";
   dumpDeclRef(T->getDecl());
 }
 
-void TextNodeDumper::VisitAutoType(const AutoType *T) {
+void TextNodeDumper::VisitAutoType(AutoType const *T) {
   if (T->isDecltypeAuto())
     OS << " decltype(auto)";
   if (!T->isDeduced())
     OS << " undeduced";
   if (T->isConstrained()) {
     dumpDeclRef(T->getTypeConstraintConcept());
-    for (const auto &Arg : T->getTypeConstraintArguments())
+    for (auto const &Arg : T->getTypeConstraintArguments())
       VisitTemplateArgument(Arg);
   }
 }
 
 void TextNodeDumper::VisitTemplateSpecializationType(
-    const TemplateSpecializationType *T) {
+    TemplateSpecializationType const *T) {
   if (T->isTypeAlias())
     OS << " alias";
   OS << " ";
@@ -1570,29 +1584,29 @@
 }
 
 void TextNodeDumper::VisitInjectedClassNameType(
-    const InjectedClassNameType *T) {
+    InjectedClassNameType const *T) {
   dumpDeclRef(T->getDecl());
 }
 
-void TextNodeDumper::VisitObjCInterfaceType(const ObjCInterfaceType *T) {
+void TextNodeDumper::VisitObjCInterfaceType(ObjCInterfaceType const *T) {
   dumpDeclRef(T->getDecl());
 }
 
-void TextNodeDumper::VisitPackExpansionType(const PackExpansionType *T) {
+void TextNodeDumper::VisitPackExpansionType(PackExpansionType const *T) {
   if (auto N = T->getNumExpansions())
     OS << " expansions " << *N;
 }
 
-void TextNodeDumper::VisitLabelDecl(const LabelDecl *D) { dumpName(D); }
+void TextNodeDumper::VisitLabelDecl(LabelDecl const *D) { dumpName(D); }
 
-void TextNodeDumper::VisitTypedefDecl(const TypedefDecl *D) {
+void TextNodeDumper::VisitTypedefDecl(TypedefDecl const *D) {
   dumpName(D);
   dumpType(D->getUnderlyingType());
   if (D->isModulePrivate())
     OS << " __module_private__";
 }
 
-void TextNodeDumper::VisitEnumDecl(const EnumDecl *D) {
+void TextNodeDumper::VisitEnumDecl(EnumDecl const *D) {
   if (D->isScoped()) {
     if (D->isScopedUsingClassTag())
       OS << " class";
@@ -1606,7 +1620,7 @@
     dumpType(D->getIntegerType());
 }
 
-void TextNodeDumper::VisitRecordDecl(const RecordDecl *D) {
+void TextNodeDumper::VisitRecordDecl(RecordDecl const *D) {
   OS << ' ' << D->getKindName();
   dumpName(D);
   if (D->isModulePrivate())
@@ -1615,20 +1629,20 @@
     OS << " definition";
 }
 
-void TextNodeDumper::VisitEnumConstantDecl(const EnumConstantDecl *D) {
+void TextNodeDumper::VisitEnumConstantDecl(EnumConstantDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
 }
 
-void TextNodeDumper::VisitIndirectFieldDecl(const IndirectFieldDecl *D) {
+void TextNodeDumper::VisitIndirectFieldDecl(IndirectFieldDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
 
-  for (const auto *Child : D->chain())
+  for (auto const *Child : D->chain())
     dumpDeclRef(Child);
 }
 
-void TextNodeDumper::VisitFunctionDecl(const FunctionDecl *D) {
+void TextNodeDumper::VisitFunctionDecl(FunctionDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
 
@@ -1654,7 +1668,7 @@
   if (D->isTrivial())
     OS << " trivial";
 
-  if (const auto *FPT = D->getType()->getAs<FunctionProtoType>()) {
+  if (auto const *FPT = D->getType()->getAs<FunctionProtoType>()) {
     FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
     switch (EPI.ExceptionSpec.Type) {
     default:
@@ -1668,9 +1682,9 @@
     }
   }
 
-  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
+  if (auto const *MD = dyn_cast<CXXMethodDecl>(D)) {
     if (MD->size_overridden_methods() != 0) {
-      auto dumpOverride = [=](const CXXMethodDecl *D) {
+      auto dumpOverride = [=](CXXMethodDecl const *D) {
         SplitQualType T_split = D->getType().split();
         OS << D << " " << D->getParent()->getName() << "::" << D->getDeclName()
            << " '" << QualType::getAsString(T_split, PrintPolicy) << "'";
@@ -1699,7 +1713,7 @@
 }
 
 void TextNodeDumper::VisitLifetimeExtendedTemporaryDecl(
-    const LifetimeExtendedTemporaryDecl *D) {
+    LifetimeExtendedTemporaryDecl const *D) {
   OS << " extended by ";
   dumpBareDeclRef(D->getExtendingDecl());
   OS << " mangling ";
@@ -1709,7 +1723,7 @@
   }
 }
 
-void TextNodeDumper::VisitFieldDecl(const FieldDecl *D) {
+void TextNodeDumper::VisitFieldDecl(FieldDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
   if (D->isMutable())
@@ -1718,7 +1732,7 @@
     OS << " __module_private__";
 }
 
-void TextNodeDumper::VisitVarDecl(const VarDecl *D) {
+void TextNodeDumper::VisitVarDecl(VarDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
   StorageClass SC = D->getStorageClass();
@@ -1761,27 +1775,27 @@
     OS << " pack";
 
   if (D->hasInit()) {
-    const Expr *E = D->getInit();
+    Expr const *E = D->getInit();
     // Only dump the value of constexpr VarDecls for now.
     if (E && !E->isValueDependent() && D->isConstexpr()) {
-      const APValue *Value = D->evaluateValue();
+      APValue const *Value = D->evaluateValue();
       if (Value)
         AddChild("value", [=] { Visit(*Value, E->getType()); });
     }
   }
 }
 
-void TextNodeDumper::VisitBindingDecl(const BindingDecl *D) {
+void TextNodeDumper::VisitBindingDecl(BindingDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
 }
 
-void TextNodeDumper::VisitCapturedDecl(const CapturedDecl *D) {
+void TextNodeDumper::VisitCapturedDecl(CapturedDecl const *D) {
   if (D->isNothrow())
     OS << " nothrow";
 }
 
-void TextNodeDumper::VisitImportDecl(const ImportDecl *D) {
+void TextNodeDumper::VisitImportDecl(ImportDecl const *D) {
   OS << ' ' << D->getImportedModule()->getFullModuleName();
 
   for (Decl *InitD :
@@ -1789,7 +1803,7 @@
     dumpDeclRef(InitD, "initializer");
 }
 
-void TextNodeDumper::VisitPragmaCommentDecl(const PragmaCommentDecl *D) {
+void TextNodeDumper::VisitPragmaCommentDecl(PragmaCommentDecl const *D) {
   OS << ' ';
   switch (D->getCommentKind()) {
   case PCK_Unknown:
@@ -1816,23 +1830,23 @@
 }
 
 void TextNodeDumper::VisitPragmaDetectMismatchDecl(
-    const PragmaDetectMismatchDecl *D) {
+    PragmaDetectMismatchDecl const *D) {
   OS << " \"" << D->getName() << "\" \"" << D->getValue() << "\"";
 }
 
 void TextNodeDumper::VisitOMPExecutableDirective(
-    const OMPExecutableDirective *D) {
+    OMPExecutableDirective const *D) {
   if (D->isStandaloneDirective())
     OS << " openmp_standalone_directive";
 }
 
 void TextNodeDumper::VisitOMPDeclareReductionDecl(
-    const OMPDeclareReductionDecl *D) {
+    OMPDeclareReductionDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
   OS << " combiner";
   dumpPointer(D->getCombiner());
-  if (const auto *Initializer = D->getInitializer()) {
+  if (auto const *Initializer = D->getInitializer()) {
     OS << " initializer";
     dumpPointer(Initializer);
     switch (D->getInitializerKind()) {
@@ -1848,8 +1862,8 @@
   }
 }
 
-void TextNodeDumper::VisitOMPRequiresDecl(const OMPRequiresDecl *D) {
-  for (const auto *C : D->clauselists()) {
+void TextNodeDumper::VisitOMPRequiresDecl(OMPRequiresDecl const *D) {
+  for (auto const *C : D->clauselists()) {
     AddChild([=] {
       if (!C) {
         ColorScope Color(OS, ShowColors, NullColor);
@@ -1869,12 +1883,12 @@
   }
 }
 
-void TextNodeDumper::VisitOMPCapturedExprDecl(const OMPCapturedExprDecl *D) {
+void TextNodeDumper::VisitOMPCapturedExprDecl(OMPCapturedExprDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
 }
 
-void TextNodeDumper::VisitNamespaceDecl(const NamespaceDecl *D) {
+void TextNodeDumper::VisitNamespaceDecl(NamespaceDecl const *D) {
   dumpName(D);
   if (D->isInline())
     OS << " inline";
@@ -1882,27 +1896,27 @@
     dumpDeclRef(D->getOriginalNamespace(), "original");
 }
 
-void TextNodeDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
+void TextNodeDumper::VisitUsingDirectiveDecl(UsingDirectiveDecl const *D) {
   OS << ' ';
   dumpBareDeclRef(D->getNominatedNamespace());
 }
 
-void TextNodeDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
+void TextNodeDumper::VisitNamespaceAliasDecl(NamespaceAliasDecl const *D) {
   dumpName(D);
   dumpDeclRef(D->getAliasedNamespace());
 }
 
-void TextNodeDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {
+void TextNodeDumper::VisitTypeAliasDecl(TypeAliasDecl const *D) {
   dumpName(D);
   dumpType(D->getUnderlyingType());
 }
 
 void TextNodeDumper::VisitTypeAliasTemplateDecl(
-    const TypeAliasTemplateDecl *D) {
+    TypeAliasTemplateDecl const *D) {
   dumpName(D);
 }
 
-void TextNodeDumper::VisitCXXRecordDecl(const CXXRecordDecl *D) {
+void TextNodeDumper::VisitCXXRecordDecl(CXXRecordDecl const *D) {
   VisitRecordDecl(D);
   if (!D->isCompleteDefinition())
     return;
@@ -2034,7 +2048,7 @@
     });
   });
 
-  for (const auto &I : D->bases()) {
+  for (auto const &I : D->bases()) {
     AddChild([=] {
       if (I.isVirtual())
         OS << "virtual ";
@@ -2046,24 +2060,24 @@
   }
 }
 
-void TextNodeDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
+void TextNodeDumper::VisitFunctionTemplateDecl(FunctionTemplateDecl const *D) {
   dumpName(D);
 }
 
-void TextNodeDumper::VisitClassTemplateDecl(const ClassTemplateDecl *D) {
+void TextNodeDumper::VisitClassTemplateDecl(ClassTemplateDecl const *D) {
   dumpName(D);
 }
 
-void TextNodeDumper::VisitVarTemplateDecl(const VarTemplateDecl *D) {
+void TextNodeDumper::VisitVarTemplateDecl(VarTemplateDecl const *D) {
   dumpName(D);
 }
 
-void TextNodeDumper::VisitBuiltinTemplateDecl(const BuiltinTemplateDecl *D) {
+void TextNodeDumper::VisitBuiltinTemplateDecl(BuiltinTemplateDecl const *D) {
   dumpName(D);
 }
 
-void TextNodeDumper::VisitTemplateTypeParmDecl(const TemplateTypeParmDecl *D) {
-  if (const auto *TC = D->getTypeConstraint()) {
+void TextNodeDumper::VisitTemplateTypeParmDecl(TemplateTypeParmDecl const *D) {
+  if (auto const *TC = D->getTypeConstraint()) {
     OS << " ";
     dumpBareDeclRef(TC->getNamedConcept());
     if (TC->getNamedConcept() != TC->getFoundDecl()) {
@@ -2082,7 +2096,7 @@
 }
 
 void TextNodeDumper::VisitNonTypeTemplateParmDecl(
-    const NonTypeTemplateParmDecl *D) {
+    NonTypeTemplateParmDecl const *D) {
   dumpType(D->getType());
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
@@ -2091,27 +2105,27 @@
 }
 
 void TextNodeDumper::VisitTemplateTemplateParmDecl(
-    const TemplateTemplateParmDecl *D) {
+    TemplateTemplateParmDecl const *D) {
   OS << " depth " << D->getDepth() << " index " << D->getIndex();
   if (D->isParameterPack())
     OS << " ...";
   dumpName(D);
 }
 
-void TextNodeDumper::VisitUsingDecl(const UsingDecl *D) {
+void TextNodeDumper::VisitUsingDecl(UsingDecl const *D) {
   OS << ' ';
   if (D->getQualifier())
     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
   OS << D->getDeclName();
 }
 
-void TextNodeDumper::VisitUsingEnumDecl(const UsingEnumDecl *D) {
+void TextNodeDumper::VisitUsingEnumDecl(UsingEnumDecl const *D) {
   OS << ' ';
   dumpBareDeclRef(D->getEnumDecl());
 }
 
 void TextNodeDumper::VisitUnresolvedUsingTypenameDecl(
-    const UnresolvedUsingTypenameDecl *D) {
+    UnresolvedUsingTypenameDecl const *D) {
   OS << ' ';
   if (D->getQualifier())
     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
@@ -2119,7 +2133,7 @@
 }
 
 void TextNodeDumper::VisitUnresolvedUsingValueDecl(
-    const UnresolvedUsingValueDecl *D) {
+    UnresolvedUsingValueDecl const *D) {
   OS << ' ';
   if (D->getQualifier())
     D->getQualifier()->print(OS, D->getASTContext().getPrintingPolicy());
@@ -2127,13 +2141,13 @@
   dumpType(D->getType());
 }
 
-void TextNodeDumper::VisitUsingShadowDecl(const UsingShadowDecl *D) {
+void TextNodeDumper::VisitUsingShadowDecl(UsingShadowDecl const *D) {
   OS << ' ';
   dumpBareDeclRef(D->getTargetDecl());
 }
 
 void TextNodeDumper::VisitConstructorUsingShadowDecl(
-    const ConstructorUsingShadowDecl *D) {
+    ConstructorUsingShadowDecl const *D) {
   if (D->constructsVirtualBase())
     OS << " virtual";
 
@@ -2157,7 +2171,7 @@
   });
 }
 
-void TextNodeDumper::VisitLinkageSpecDecl(const LinkageSpecDecl *D) {
+void TextNodeDumper::VisitLinkageSpecDecl(LinkageSpecDecl const *D) {
   switch (D->getLanguage()) {
   case LinkageSpecDecl::lang_c:
     OS << " C";
@@ -2168,17 +2182,17 @@
   }
 }
 
-void TextNodeDumper::VisitAccessSpecDecl(const AccessSpecDecl *D) {
+void TextNodeDumper::VisitAccessSpecDecl(AccessSpecDecl const *D) {
   OS << ' ';
   dumpAccessSpecifier(D->getAccess());
 }
 
-void TextNodeDumper::VisitFriendDecl(const FriendDecl *D) {
+void TextNodeDumper::VisitFriendDecl(FriendDecl const *D) {
   if (TypeSourceInfo *T = D->getFriendType())
     dumpType(T->getType());
 }
 
-void TextNodeDumper::VisitObjCIvarDecl(const ObjCIvarDecl *D) {
+void TextNodeDumper::VisitObjCIvarDecl(ObjCIvarDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
   if (D->getSynthesize())
@@ -2203,7 +2217,7 @@
   }
 }
 
-void TextNodeDumper::VisitObjCMethodDecl(const ObjCMethodDecl *D) {
+void TextNodeDumper::VisitObjCMethodDecl(ObjCMethodDecl const *D) {
   if (D->isInstanceMethod())
     OS << " -";
   else
@@ -2215,7 +2229,7 @@
     OS << " variadic";
 }
 
-void TextNodeDumper::VisitObjCTypeParamDecl(const ObjCTypeParamDecl *D) {
+void TextNodeDumper::VisitObjCTypeParamDecl(ObjCTypeParamDecl const *D) {
   dumpName(D);
   switch (D->getVariance()) {
   case ObjCTypeParamVariance::Invariant:
@@ -2235,50 +2249,50 @@
   dumpType(D->getUnderlyingType());
 }
 
-void TextNodeDumper::VisitObjCCategoryDecl(const ObjCCategoryDecl *D) {
+void TextNodeDumper::VisitObjCCategoryDecl(ObjCCategoryDecl const *D) {
   dumpName(D);
   dumpDeclRef(D->getClassInterface());
   dumpDeclRef(D->getImplementation());
-  for (const auto *P : D->protocols())
+  for (auto const *P : D->protocols())
     dumpDeclRef(P);
 }
 
-void TextNodeDumper::VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *D) {
+void TextNodeDumper::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl const *D) {
   dumpName(D);
   dumpDeclRef(D->getClassInterface());
   dumpDeclRef(D->getCategoryDecl());
 }
 
-void TextNodeDumper::VisitObjCProtocolDecl(const ObjCProtocolDecl *D) {
+void TextNodeDumper::VisitObjCProtocolDecl(ObjCProtocolDecl const *D) {
   dumpName(D);
 
-  for (const auto *Child : D->protocols())
+  for (auto const *Child : D->protocols())
     dumpDeclRef(Child);
 }
 
-void TextNodeDumper::VisitObjCInterfaceDecl(const ObjCInterfaceDecl *D) {
+void TextNodeDumper::VisitObjCInterfaceDecl(ObjCInterfaceDecl const *D) {
   dumpName(D);
   dumpDeclRef(D->getSuperClass(), "super");
 
   dumpDeclRef(D->getImplementation());
-  for (const auto *Child : D->protocols())
+  for (auto const *Child : D->protocols())
     dumpDeclRef(Child);
 }
 
 void TextNodeDumper::VisitObjCImplementationDecl(
-    const ObjCImplementationDecl *D) {
+    ObjCImplementationDecl const *D) {
   dumpName(D);
   dumpDeclRef(D->getSuperClass(), "super");
   dumpDeclRef(D->getClassInterface());
 }
 
 void TextNodeDumper::VisitObjCCompatibleAliasDecl(
-    const ObjCCompatibleAliasDecl *D) {
+    ObjCCompatibleAliasDecl const *D) {
   dumpName(D);
   dumpDeclRef(D->getClassInterface());
 }
 
-void TextNodeDumper::VisitObjCPropertyDecl(const ObjCPropertyDecl *D) {
+void TextNodeDumper::VisitObjCPropertyDecl(ObjCPropertyDecl const *D) {
   dumpName(D);
   dumpType(D->getType());
 
@@ -2320,7 +2334,7 @@
   }
 }
 
-void TextNodeDumper::VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *D) {
+void TextNodeDumper::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl const *D) {
   dumpName(D->getPropertyDecl());
   if (D->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize)
     OS << " synthesize";
@@ -2330,7 +2344,7 @@
   dumpDeclRef(D->getPropertyIvarDecl());
 }
 
-void TextNodeDumper::VisitBlockDecl(const BlockDecl *D) {
+void TextNodeDumper::VisitBlockDecl(BlockDecl const *D) {
   if (D->isVariadic())
     OS << " variadic";
 
@@ -2338,6 +2352,4 @@
     OS << " captures_this";
 }
 
-void TextNodeDumper::VisitConceptDecl(const ConceptDecl *D) {
-  dumpName(D);
-}
+void TextNodeDumper::VisitConceptDecl(ConceptDecl const *D) { dumpName(D); }
Index: clang/lib/AST/Type.cpp
===================================================================
--- clang/lib/AST/Type.cpp
+++ clang/lib/AST/Type.cpp
@@ -57,21 +57,21 @@
 
 bool Qualifiers::isStrictSupersetOf(Qualifiers Other) const {
   return (*this != Other) &&
-    // CVR qualifiers superset
-    (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) &&
-    // ObjC GC qualifiers superset
-    ((getObjCGCAttr() == Other.getObjCGCAttr()) ||
-     (hasObjCGCAttr() && !Other.hasObjCGCAttr())) &&
-    // Address space superset.
-    ((getAddressSpace() == Other.getAddressSpace()) ||
-     (hasAddressSpace()&& !Other.hasAddressSpace())) &&
-    // Lifetime qualifier superset.
-    ((getObjCLifetime() == Other.getObjCLifetime()) ||
-     (hasObjCLifetime() && !Other.hasObjCLifetime()));
-}
-
-const IdentifierInfo* QualType::getBaseTypeIdentifier() const {
-  const Type* ty = getTypePtr();
+         // CVR qualifiers superset
+         (((Mask & CVRMask) | (Other.Mask & CVRMask)) == (Mask & CVRMask)) &&
+         // ObjC GC qualifiers superset
+         ((getObjCGCAttr() == Other.getObjCGCAttr()) ||
+          (hasObjCGCAttr() && !Other.hasObjCGCAttr())) &&
+         // Address space superset.
+         ((getAddressSpace() == Other.getAddressSpace()) ||
+          (hasAddressSpace() && !Other.hasAddressSpace())) &&
+         // Lifetime qualifier superset.
+         ((getObjCLifetime() == Other.getObjCLifetime()) ||
+          (hasObjCLifetime() && !Other.hasObjCLifetime()));
+}
+
+IdentifierInfo const *QualType::getBaseTypeIdentifier() const {
+  Type const *ty = getTypePtr();
   NamedDecl *ND = nullptr;
   if (ty->isPointerType() || ty->isReferenceType())
     return ty->getPointeeType().getBaseTypeIdentifier();
@@ -82,8 +82,9 @@
   else if (ty->getTypeClass() == Type::Typedef)
     ND = ty->castAs<TypedefType>()->getDecl();
   else if (ty->isArrayType())
-    return ty->castAsArrayTypeUnsafe()->
-        getElementType().getBaseTypeIdentifier();
+    return ty->castAsArrayTypeUnsafe()
+        ->getElementType()
+        .getBaseTypeIdentifier();
 
   if (ND)
     return ND->getIdentifier();
@@ -91,20 +92,20 @@
 }
 
 bool QualType::mayBeDynamicClass() const {
-  const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
+  auto const *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
   return ClassDecl && ClassDecl->mayBeDynamicClass();
 }
 
 bool QualType::mayBeNotDynamicClass() const {
-  const auto *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
+  auto const *ClassDecl = getTypePtr()->getPointeeCXXRecordDecl();
   return !ClassDecl || ClassDecl->mayBeNonDynamicClass();
 }
 
-bool QualType::isConstant(QualType T, const ASTContext &Ctx) {
+bool QualType::isConstant(QualType T, ASTContext const &Ctx) {
   if (T.isConstQualified())
     return true;
 
-  if (const ArrayType *AT = Ctx.getAsArrayType(T))
+  if (ArrayType const *AT = Ctx.getAsArrayType(T))
     return AT->getElementType().isConstant(Ctx);
 
   return T.getAddressSpace() == LangAS::opencl_constant;
@@ -116,7 +117,7 @@
 //       size is specified by a constant expression that is
 //       value-dependent,
 ArrayType::ArrayType(TypeClass tc, QualType et, QualType can,
-                     ArraySizeModifier sm, unsigned tq, const Expr *sz)
+                     ArraySizeModifier sm, unsigned tq, Expr const *sz)
     // Note, we need to check for DependentSizedArrayType explicitly here
     // because we use a DependentSizedArrayType with no size expression as the
     // type of a dependent array of unknown bound with a dependent braced
@@ -138,9 +139,10 @@
   ArrayTypeBits.SizeModifier = sm;
 }
 
-unsigned ConstantArrayType::getNumAddressingBits(const ASTContext &Context,
-                                                 QualType ElementType,
-                                               const llvm::APInt &NumElements) {
+unsigned
+ConstantArrayType::getNumAddressingBits(ASTContext const &Context,
+                                        QualType ElementType,
+                                        llvm::APInt const &NumElements) {
   uint64_t ElementSize = Context.getTypeSizeInChars(ElementType).getQuantity();
 
   // Fast path the common cases so we can avoid the conservative computation
@@ -164,8 +166,8 @@
   // Otherwise, use APSInt to handle arbitrary sized values.
   llvm::APSInt SizeExtended(NumElements, true);
   unsigned SizeTypeBits = Context.getTypeSize(Context.getSizeType());
-  SizeExtended = SizeExtended.extend(std::max(SizeTypeBits,
-                                              SizeExtended.getBitWidth()) * 2);
+  SizeExtended = SizeExtended.extend(
+      std::max(SizeTypeBits, SizeExtended.getBitWidth()) * 2);
 
   llvm::APSInt TotalSize(llvm::APInt(SizeExtended.getBitWidth(), ElementSize));
   TotalSize *= SizeExtended;
@@ -173,7 +175,7 @@
   return TotalSize.getActiveBits();
 }
 
-unsigned ConstantArrayType::getMaxSizeBits(const ASTContext &Context) {
+unsigned ConstantArrayType::getMaxSizeBits(ASTContext const &Context) {
   unsigned Bits = Context.getTypeSize(Context.getSizeType());
 
   // Limit the number of bits in size_t so that maximal bit size fits 64 bit
@@ -186,9 +188,9 @@
 }
 
 void ConstantArrayType::Profile(llvm::FoldingSetNodeID &ID,
-                                const ASTContext &Context, QualType ET,
-                                const llvm::APInt &ArraySize,
-                                const Expr *SizeExpr, ArraySizeModifier SizeMod,
+                                ASTContext const &Context, QualType ET,
+                                llvm::APInt const &ArraySize,
+                                Expr const *SizeExpr, ArraySizeModifier SizeMod,
                                 unsigned TypeQuals) {
   ID.AddPointer(ET.getAsOpaquePtr());
   ID.AddInteger(ArraySize.getZExtValue());
@@ -199,27 +201,25 @@
     SizeExpr->Profile(ID, Context, true);
 }
 
-DependentSizedArrayType::DependentSizedArrayType(const ASTContext &Context,
+DependentSizedArrayType::DependentSizedArrayType(ASTContext const &Context,
                                                  QualType et, QualType can,
                                                  Expr *e, ArraySizeModifier sm,
                                                  unsigned tq,
                                                  SourceRange brackets)
-    : ArrayType(DependentSizedArray, et, can, sm, tq, e),
-      Context(Context), SizeExpr((Stmt*) e), Brackets(brackets) {}
+    : ArrayType(DependentSizedArray, et, can, sm, tq, e), Context(Context),
+      SizeExpr((Stmt *)e), Brackets(brackets) {}
 
 void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID,
-                                      const ASTContext &Context,
-                                      QualType ET,
+                                      ASTContext const &Context, QualType ET,
                                       ArraySizeModifier SizeMod,
-                                      unsigned TypeQuals,
-                                      Expr *E) {
+                                      unsigned TypeQuals, Expr *E) {
   ID.AddPointer(ET.getAsOpaquePtr());
   ID.AddInteger(SizeMod);
   ID.AddInteger(TypeQuals);
   E->Profile(ID, Context, true);
 }
 
-DependentVectorType::DependentVectorType(const ASTContext &Context,
+DependentVectorType::DependentVectorType(ASTContext const &Context,
                                          QualType ElementType,
                                          QualType CanonType, Expr *SizeExpr,
                                          SourceLocation Loc,
@@ -234,8 +234,8 @@
 }
 
 void DependentVectorType::Profile(llvm::FoldingSetNodeID &ID,
-                                  const ASTContext &Context,
-                                  QualType ElementType, const Expr *SizeExpr,
+                                  ASTContext const &Context,
+                                  QualType ElementType, Expr const *SizeExpr,
                                   VectorType::VectorKind VecKind) {
   ID.AddPointer(ElementType.getAsOpaquePtr());
   ID.AddInteger(VecKind);
@@ -243,7 +243,7 @@
 }
 
 DependentSizedExtVectorType::DependentSizedExtVectorType(
-    const ASTContext &Context, QualType ElementType, QualType can,
+    ASTContext const &Context, QualType ElementType, QualType can,
     Expr *SizeExpr, SourceLocation loc)
     : Type(DependentSizedExtVector, can,
            TypeDependence::DependentInstantiation |
@@ -253,15 +253,15 @@
       Context(Context), SizeExpr(SizeExpr), ElementType(ElementType), loc(loc) {
 }
 
-void
-DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID,
-                                     const ASTContext &Context,
-                                     QualType ElementType, Expr *SizeExpr) {
+void DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID,
+                                          ASTContext const &Context,
+                                          QualType ElementType,
+                                          Expr *SizeExpr) {
   ID.AddPointer(ElementType.getAsOpaquePtr());
   SizeExpr->Profile(ID, Context, true);
 }
 
-DependentAddressSpaceType::DependentAddressSpaceType(const ASTContext &Context,
+DependentAddressSpaceType::DependentAddressSpaceType(ASTContext const &Context,
                                                      QualType PointeeType,
                                                      QualType can,
                                                      Expr *AddrSpaceExpr,
@@ -275,7 +275,7 @@
       loc(loc) {}
 
 void DependentAddressSpaceType::Profile(llvm::FoldingSetNodeID &ID,
-                                        const ASTContext &Context,
+                                        ASTContext const &Context,
                                         QualType PointeeType,
                                         Expr *AddrSpaceExpr) {
   ID.AddPointer(PointeeType.getAsOpaquePtr());
@@ -283,7 +283,7 @@
 }
 
 MatrixType::MatrixType(TypeClass tc, QualType matrixType, QualType canonType,
-                       const Expr *RowExpr, const Expr *ColumnExpr)
+                       Expr const *RowExpr, Expr const *ColumnExpr)
     : Type(tc, canonType,
            (RowExpr ? (matrixType->getDependence() | TypeDependence::Dependent |
                        TypeDependence::Instantiation |
@@ -312,14 +312,14 @@
       NumColumns(nColumns) {}
 
 DependentSizedMatrixType::DependentSizedMatrixType(
-    const ASTContext &CTX, QualType ElementType, QualType CanonicalType,
+    ASTContext const &CTX, QualType ElementType, QualType CanonicalType,
     Expr *RowExpr, Expr *ColumnExpr, SourceLocation loc)
     : MatrixType(DependentSizedMatrix, ElementType, CanonicalType, RowExpr,
                  ColumnExpr),
       Context(CTX), RowExpr(RowExpr), ColumnExpr(ColumnExpr), loc(loc) {}
 
 void DependentSizedMatrixType::Profile(llvm::FoldingSetNodeID &ID,
-                                       const ASTContext &CTX,
+                                       ASTContext const &CTX,
                                        QualType ElementType, Expr *RowExpr,
                                        Expr *ColumnExpr) {
   ID.AddPointer(ElementType.getAsOpaquePtr());
@@ -342,7 +342,7 @@
     : Type(ExtInt, QualType{}, TypeDependence::None), IsUnsigned(IsUnsigned),
       NumBits(NumBits) {}
 
-DependentExtIntType::DependentExtIntType(const ASTContext &Context,
+DependentExtIntType::DependentExtIntType(ASTContext const &Context,
                                          bool IsUnsigned, Expr *NumBitsExpr)
     : Type(DependentExtInt, QualType{},
            toTypeDependence(NumBitsExpr->getDependence())),
@@ -357,7 +357,7 @@
 }
 
 void DependentExtIntType::Profile(llvm::FoldingSetNodeID &ID,
-                                  const ASTContext &Context, bool IsUnsigned,
+                                  ASTContext const &Context, bool IsUnsigned,
                                   Expr *NumBitsExpr) {
   ID.AddBoolean(IsUnsigned);
   NumBitsExpr->Profile(ID, Context, true);
@@ -366,9 +366,9 @@
 /// getArrayElementTypeNoTypeQual - If this is an array type, return the
 /// element type of the array, potentially with type qualifiers missing.
 /// This method should never be used when type qualifiers are meaningful.
-const Type *Type::getArrayElementTypeNoTypeQual() const {
+Type const *Type::getArrayElementTypeNoTypeQual() const {
   // If this is directly an array type, return it.
-  if (const auto *ATy = dyn_cast<ArrayType>(this))
+  if (auto const *ATy = dyn_cast<ArrayType>(this))
     return ATy->getElementType().getTypePtr();
 
   // If the canonical form of this type isn't the right kind, reject it.
@@ -378,7 +378,8 @@
   // If this is a typedef for an array type, strip the typedef off without
   // losing all typedef information.
   return cast<ArrayType>(getUnqualifiedDesugaredType())
-    ->getElementType().getTypePtr();
+      ->getElementType()
+      .getTypePtr();
 }
 
 /// getDesugaredType - Return the specified type with any "sugar" removed from
@@ -387,13 +388,13 @@
 /// to getting the canonical type, but it doesn't remove *all* typedefs.  For
 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
 /// concrete.
-QualType QualType::getDesugaredType(QualType T, const ASTContext &Context) {
+QualType QualType::getDesugaredType(QualType T, ASTContext const &Context) {
   SplitQualType split = getSplitDesugaredType(T);
   return Context.getQualifiedType(split.Ty, split.Quals);
 }
 
 QualType QualType::getSingleStepDesugaredTypeImpl(QualType type,
-                                                  const ASTContext &Context) {
+                                                  ASTContext const &Context) {
   SplitQualType split = type.split();
   QualType desugar = split.Ty->getLocallyUnqualifiedSingleStepDesugaredType();
   return Context.getQualifiedType(desugar, split.Quals);
@@ -402,8 +403,8 @@
 // Check that no type class is polymorphic. LLVM style RTTI should be used
 // instead. If absolutely needed an exception can still be added here by
 // defining the appropriate macro (but please don't do this).
-#define TYPE(CLASS, BASE) \
-  static_assert(!std::is_polymorphic<CLASS##Type>::value, \
+#define TYPE(CLASS, BASE)                                                      \
+  static_assert(!std::is_polymorphic<CLASS##Type>::value,                      \
                 #CLASS "Type should not be polymorphic!");
 #include "clang/AST/TypeNodes.inc"
 
@@ -422,11 +423,12 @@
 QualType Type::getLocallyUnqualifiedSingleStepDesugaredType() const {
   switch (getTypeClass()) {
 #define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
-  case Type::Class: { \
-    const auto *ty = cast<Class##Type>(this); \
-    if (!ty->isSugared()) return QualType(ty, 0); \
-    return ty->desugar(); \
+#define TYPE(Class, Parent)                                                    \
+  case Type::Class: {                                                          \
+    auto const *ty = cast<Class##Type>(this);                                  \
+    if (!ty->isSugared())                                                      \
+      return QualType(ty, 0);                                                  \
+    return ty->desugar();                                                      \
   }
 #include "clang/AST/TypeNodes.inc"
   }
@@ -438,17 +440,17 @@
 
   QualType Cur = T;
   while (true) {
-    const Type *CurTy = Qs.strip(Cur);
+    Type const *CurTy = Qs.strip(Cur);
     switch (CurTy->getTypeClass()) {
 #define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
-    case Type::Class: { \
-      const auto *Ty = cast<Class##Type>(CurTy); \
-      if (!Ty->isSugared()) \
-        return SplitQualType(Ty, Qs); \
-      Cur = Ty->desugar(); \
-      break; \
-    }
+#define TYPE(Class, Parent)                                                    \
+  case Type::Class: {                                                          \
+    auto const *Ty = cast<Class##Type>(CurTy);                                 \
+    if (!Ty->isSugared())                                                      \
+      return SplitQualType(Ty, Qs);                                            \
+    Cur = Ty->desugar();                                                       \
+    break;                                                                     \
+  }
 #include "clang/AST/TypeNodes.inc"
     }
   }
@@ -461,7 +463,7 @@
   Qualifiers quals = split.Quals;
 
   // The last type node we saw with any nodes inside it.
-  const Type *lastTypeWithQuals = split.Ty;
+  Type const *lastTypeWithQuals = split.Ty;
 
   while (true) {
     QualType next;
@@ -470,13 +472,14 @@
     // sugared.
     switch (split.Ty->getTypeClass()) {
 #define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
-    case Type::Class: { \
-      const auto *ty = cast<Class##Type>(split.Ty); \
-      if (!ty->isSugared()) goto done; \
-      next = ty->desugar(); \
-      break; \
-    }
+#define TYPE(Class, Parent)                                                    \
+  case Type::Class: {                                                          \
+    auto const *ty = cast<Class##Type>(split.Ty);                              \
+    if (!ty->isSugared())                                                      \
+      goto done;                                                               \
+    next = ty->desugar();                                                      \
+    break;                                                                     \
+  }
 #include "clang/AST/TypeNodes.inc"
     }
 
@@ -489,13 +492,13 @@
     }
   }
 
- done:
+done:
   return SplitQualType(lastTypeWithQuals, quals);
 }
 
 QualType QualType::IgnoreParens(QualType T) {
   // FIXME: this seems inherently un-qualifiers-safe.
-  while (const auto *PT = T->getAs<ParenType>())
+  while (auto const *PT = T->getAs<ParenType>())
     T = PT->getInnerType();
   return T;
 }
@@ -503,83 +506,85 @@
 /// This will check for a T (which should be a Type which can act as
 /// sugar, such as a TypedefType) by removing any existing sugar until it
 /// reaches a T or a non-sugared type.
-template<typename T> static const T *getAsSugar(const Type *Cur) {
+template <typename T> static const T *getAsSugar(Type const *Cur) {
   while (true) {
-    if (const auto *Sugar = dyn_cast<T>(Cur))
+    if (auto const *Sugar = dyn_cast<T>(Cur))
       return Sugar;
     switch (Cur->getTypeClass()) {
 #define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
-    case Type::Class: { \
-      const auto *Ty = cast<Class##Type>(Cur); \
-      if (!Ty->isSugared()) return 0; \
-      Cur = Ty->desugar().getTypePtr(); \
-      break; \
-    }
+#define TYPE(Class, Parent)                                                    \
+  case Type::Class: {                                                          \
+    auto const *Ty = cast<Class##Type>(Cur);                                   \
+    if (!Ty->isSugared())                                                      \
+      return 0;                                                                \
+    Cur = Ty->desugar().getTypePtr();                                          \
+    break;                                                                     \
+  }
 #include "clang/AST/TypeNodes.inc"
     }
   }
 }
 
-template <> const TypedefType *Type::getAs() const {
+template <> TypedefType const *Type::getAs() const {
   return getAsSugar<TypedefType>(this);
 }
 
-template <> const TemplateSpecializationType *Type::getAs() const {
+template <> TemplateSpecializationType const *Type::getAs() const {
   return getAsSugar<TemplateSpecializationType>(this);
 }
 
-template <> const AttributedType *Type::getAs() const {
+template <> AttributedType const *Type::getAs() const {
   return getAsSugar<AttributedType>(this);
 }
 
 /// getUnqualifiedDesugaredType - Pull any qualifiers and syntactic
 /// sugar off the given type.  This should produce an object of the
 /// same dynamic type as the canonical type.
-const Type *Type::getUnqualifiedDesugaredType() const {
-  const Type *Cur = this;
+Type const *Type::getUnqualifiedDesugaredType() const {
+  Type const *Cur = this;
 
   while (true) {
     switch (Cur->getTypeClass()) {
 #define ABSTRACT_TYPE(Class, Parent)
-#define TYPE(Class, Parent) \
-    case Class: { \
-      const auto *Ty = cast<Class##Type>(Cur); \
-      if (!Ty->isSugared()) return Cur; \
-      Cur = Ty->desugar().getTypePtr(); \
-      break; \
-    }
+#define TYPE(Class, Parent)                                                    \
+  case Class: {                                                                \
+    auto const *Ty = cast<Class##Type>(Cur);                                   \
+    if (!Ty->isSugared())                                                      \
+      return Cur;                                                              \
+    Cur = Ty->desugar().getTypePtr();                                          \
+    break;                                                                     \
+  }
 #include "clang/AST/TypeNodes.inc"
     }
   }
 }
 
 bool Type::isClassType() const {
-  if (const auto *RT = getAs<RecordType>())
+  if (auto const *RT = getAs<RecordType>())
     return RT->getDecl()->isClass();
   return false;
 }
 
 bool Type::isStructureType() const {
-  if (const auto *RT = getAs<RecordType>())
+  if (auto const *RT = getAs<RecordType>())
     return RT->getDecl()->isStruct();
   return false;
 }
 
 bool Type::isObjCBoxableRecordType() const {
-  if (const auto *RT = getAs<RecordType>())
+  if (auto const *RT = getAs<RecordType>())
     return RT->getDecl()->hasAttr<ObjCBoxableAttr>();
   return false;
 }
 
 bool Type::isInterfaceType() const {
-  if (const auto *RT = getAs<RecordType>())
+  if (auto const *RT = getAs<RecordType>())
     return RT->getDecl()->isInterface();
   return false;
 }
 
 bool Type::isStructureOrClassType() const {
-  if (const auto *RT = getAs<RecordType>()) {
+  if (auto const *RT = getAs<RecordType>()) {
     RecordDecl *RD = RT->getDecl();
     return RD->isStruct() || RD->isClass() || RD->isInterface();
   }
@@ -587,19 +592,19 @@
 }
 
 bool Type::isVoidPointerType() const {
-  if (const auto *PT = getAs<PointerType>())
+  if (auto const *PT = getAs<PointerType>())
     return PT->getPointeeType()->isVoidType();
   return false;
 }
 
 bool Type::isUnionType() const {
-  if (const auto *RT = getAs<RecordType>())
+  if (auto const *RT = getAs<RecordType>())
     return RT->getDecl()->isUnion();
   return false;
 }
 
 bool Type::isComplexType() const {
-  if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
+  if (auto const *CT = dyn_cast<ComplexType>(CanonicalType))
     return CT->getElementType()->isFloatingType();
   return false;
 }
@@ -610,43 +615,43 @@
 }
 
 bool Type::isScopedEnumeralType() const {
-  if (const auto *ET = getAs<EnumType>())
+  if (auto const *ET = getAs<EnumType>())
     return ET->getDecl()->isScoped();
   return false;
 }
 
-const ComplexType *Type::getAsComplexIntegerType() const {
-  if (const auto *Complex = getAs<ComplexType>())
+ComplexType const *Type::getAsComplexIntegerType() const {
+  if (auto const *Complex = getAs<ComplexType>())
     if (Complex->getElementType()->isIntegerType())
       return Complex;
   return nullptr;
 }
 
 QualType Type::getPointeeType() const {
-  if (const auto *PT = getAs<PointerType>())
+  if (auto const *PT = getAs<PointerType>())
     return PT->getPointeeType();
-  if (const auto *OPT = getAs<ObjCObjectPointerType>())
+  if (auto const *OPT = getAs<ObjCObjectPointerType>())
     return OPT->getPointeeType();
-  if (const auto *BPT = getAs<BlockPointerType>())
+  if (auto const *BPT = getAs<BlockPointerType>())
     return BPT->getPointeeType();
-  if (const auto *RT = getAs<ReferenceType>())
+  if (auto const *RT = getAs<ReferenceType>())
     return RT->getPointeeType();
-  if (const auto *MPT = getAs<MemberPointerType>())
+  if (auto const *MPT = getAs<MemberPointerType>())
     return MPT->getPointeeType();
-  if (const auto *DT = getAs<DecayedType>())
+  if (auto const *DT = getAs<DecayedType>())
     return DT->getPointeeType();
   return {};
 }
 
-const RecordType *Type::getAsStructureType() const {
+RecordType const *Type::getAsStructureType() const {
   // If this is directly a structure type, return it.
-  if (const auto *RT = dyn_cast<RecordType>(this)) {
+  if (auto const *RT = dyn_cast<RecordType>(this)) {
     if (RT->getDecl()->isStruct())
       return RT;
   }
 
   // If the canonical form of this type isn't the right kind, reject it.
-  if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
+  if (auto const *RT = dyn_cast<RecordType>(CanonicalType)) {
     if (!RT->getDecl()->isStruct())
       return nullptr;
 
@@ -657,15 +662,15 @@
   return nullptr;
 }
 
-const RecordType *Type::getAsUnionType() const {
+RecordType const *Type::getAsUnionType() const {
   // If this is directly a union type, return it.
-  if (const auto *RT = dyn_cast<RecordType>(this)) {
+  if (auto const *RT = dyn_cast<RecordType>(this)) {
     if (RT->getDecl()->isUnion())
       return RT;
   }
 
   // If the canonical form of this type isn't the right kind, reject it.
-  if (const auto *RT = dyn_cast<RecordType>(CanonicalType)) {
+  if (auto const *RT = dyn_cast<RecordType>(CanonicalType)) {
     if (!RT->getDecl()->isUnion())
       return nullptr;
 
@@ -677,11 +682,11 @@
   return nullptr;
 }
 
-bool Type::isObjCIdOrObjectKindOfType(const ASTContext &ctx,
-                                      const ObjCObjectType *&bound) const {
+bool Type::isObjCIdOrObjectKindOfType(ASTContext const &ctx,
+                                      ObjCObjectType const *&bound) const {
   bound = nullptr;
 
-  const auto *OPT = getAs<ObjCObjectPointerType>();
+  auto const *OPT = getAs<ObjCObjectPointerType>();
   if (!OPT)
     return false;
 
@@ -698,13 +703,14 @@
     return false;
 
   // Figure out the type bound for the __kindof type.
-  bound = OPT->getObjectType()->stripObjCKindOfTypeAndQuals(ctx)
-            ->getAs<ObjCObjectType>();
+  bound = OPT->getObjectType()
+              ->stripObjCKindOfTypeAndQuals(ctx)
+              ->getAs<ObjCObjectType>();
   return true;
 }
 
 bool Type::isObjCClassOrClassKindOfType() const {
-  const auto *OPT = getAs<ObjCObjectPointerType>();
+  auto const *OPT = getAs<ObjCObjectPointerType>();
   if (!OPT)
     return false;
 
@@ -720,7 +726,7 @@
   return OPT->isObjCClassType() || OPT->isObjCQualifiedClassType();
 }
 
-ObjCTypeParamType::ObjCTypeParamType(const ObjCTypeParamDecl *D, QualType can,
+ObjCTypeParamType::ObjCTypeParamType(ObjCTypeParamDecl const *D, QualType can,
                                      ArrayRef<ObjCProtocolDecl *> protocols)
     : Type(ObjCTypeParam, can,
            can->getDependence() & ~TypeDependence::UnexpandedPack),
@@ -756,7 +762,7 @@
     return true;
 
   // Otherwise, check whether the base type is specialized.
-  if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
+  if (auto const objcObject = getBaseType()->getAs<ObjCObjectType>()) {
     // Terminate when we reach an interface type.
     if (isa<ObjCInterfaceType>(objcObject))
       return false;
@@ -774,7 +780,7 @@
     return getTypeArgsAsWritten();
 
   // Look at the base type, which might have type arguments.
-  if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
+  if (auto const objcObject = getBaseType()->getAs<ObjCObjectType>()) {
     // Terminate when we reach an interface type.
     if (isa<ObjCInterfaceType>(objcObject))
       return {};
@@ -791,7 +797,7 @@
     return true;
 
   // Look at the base type, which might have type arguments.
-  if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
+  if (auto const objcObject = getBaseType()->getAs<ObjCObjectType>()) {
     // Terminate when we reach an interface type.
     if (isa<ObjCInterfaceType>(objcObject))
       return false;
@@ -803,26 +809,26 @@
   return false;
 }
 
-QualType ObjCObjectType::stripObjCKindOfTypeAndQuals(
-           const ASTContext &ctx) const {
+QualType
+ObjCObjectType::stripObjCKindOfTypeAndQuals(ASTContext const &ctx) const {
   if (!isKindOfType() && qual_empty())
     return QualType(this, 0);
 
   // Recursively strip __kindof.
   SplitQualType splitBaseType = getBaseType().split();
   QualType baseType(splitBaseType.Ty, 0);
-  if (const auto *baseObj = splitBaseType.Ty->getAs<ObjCObjectType>())
+  if (auto const *baseObj = splitBaseType.Ty->getAs<ObjCObjectType>())
     baseType = baseObj->stripObjCKindOfTypeAndQuals(ctx);
 
-  return ctx.getObjCObjectType(ctx.getQualifiedType(baseType,
-                                                    splitBaseType.Quals),
-                               getTypeArgsAsWritten(),
-                               /*protocols=*/{},
-                               /*isKindOf=*/false);
+  return ctx.getObjCObjectType(
+      ctx.getQualifiedType(baseType, splitBaseType.Quals),
+      getTypeArgsAsWritten(),
+      /*protocols=*/{},
+      /*isKindOf=*/false);
 }
 
-const ObjCObjectPointerType *ObjCObjectPointerType::stripObjCKindOfTypeAndQuals(
-                               const ASTContext &ctx) const {
+ObjCObjectPointerType const *ObjCObjectPointerType::stripObjCKindOfTypeAndQuals(
+    ASTContext const &ctx) const {
   if (!isKindOfType() && qual_empty())
     return this;
 
@@ -858,27 +864,27 @@
   // None of the clients of this transformation can occur where
   // there are dependent types, so skip dependent types.
 #define TYPE(Class, Base)
-#define DEPENDENT_TYPE(Class, Base) \
+#define DEPENDENT_TYPE(Class, Base)                                            \
   QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
 #include "clang/AST/TypeNodes.inc"
 
-#define TRIVIAL_TYPE_CLASS(Class) \
+#define TRIVIAL_TYPE_CLASS(Class)                                              \
   QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
-#define SUGARED_TYPE_CLASS(Class) \
-  QualType Visit##Class##Type(const Class##Type *T) { \
-    if (!T->isSugared()) \
-      return QualType(T, 0); \
-    QualType desugaredType = recurse(T->desugar()); \
-    if (desugaredType.isNull()) \
-      return {}; \
-    if (desugaredType.getAsOpaquePtr() == T->desugar().getAsOpaquePtr()) \
-      return QualType(T, 0); \
-    return desugaredType; \
+#define SUGARED_TYPE_CLASS(Class)                                              \
+  QualType Visit##Class##Type(const Class##Type *T) {                          \
+    if (!T->isSugared())                                                       \
+      return QualType(T, 0);                                                   \
+    QualType desugaredType = recurse(T->desugar());                            \
+    if (desugaredType.isNull())                                                \
+      return {};                                                               \
+    if (desugaredType.getAsOpaquePtr() == T->desugar().getAsOpaquePtr())       \
+      return QualType(T, 0);                                                   \
+    return desugaredType;                                                      \
   }
 
   TRIVIAL_TYPE_CLASS(Builtin)
 
-  QualType VisitComplexType(const ComplexType *T) {
+  QualType VisitComplexType(ComplexType const *T) {
     QualType elementType = recurse(T->getElementType());
     if (elementType.isNull())
       return {};
@@ -889,7 +895,7 @@
     return Ctx.getComplexType(elementType);
   }
 
-  QualType VisitPointerType(const PointerType *T) {
+  QualType VisitPointerType(PointerType const *T) {
     QualType pointeeType = recurse(T->getPointeeType());
     if (pointeeType.isNull())
       return {};
@@ -900,7 +906,7 @@
     return Ctx.getPointerType(pointeeType);
   }
 
-  QualType VisitBlockPointerType(const BlockPointerType *T) {
+  QualType VisitBlockPointerType(BlockPointerType const *T) {
     QualType pointeeType = recurse(T->getPointeeType());
     if (pointeeType.isNull())
       return {};
@@ -911,31 +917,31 @@
     return Ctx.getBlockPointerType(pointeeType);
   }
 
-  QualType VisitLValueReferenceType(const LValueReferenceType *T) {
+  QualType VisitLValueReferenceType(LValueReferenceType const *T) {
     QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
     if (pointeeType.isNull())
       return {};
 
-    if (pointeeType.getAsOpaquePtr()
-          == T->getPointeeTypeAsWritten().getAsOpaquePtr())
+    if (pointeeType.getAsOpaquePtr() ==
+        T->getPointeeTypeAsWritten().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getLValueReferenceType(pointeeType, T->isSpelledAsLValue());
   }
 
-  QualType VisitRValueReferenceType(const RValueReferenceType *T) {
+  QualType VisitRValueReferenceType(RValueReferenceType const *T) {
     QualType pointeeType = recurse(T->getPointeeTypeAsWritten());
     if (pointeeType.isNull())
       return {};
 
-    if (pointeeType.getAsOpaquePtr()
-          == T->getPointeeTypeAsWritten().getAsOpaquePtr())
+    if (pointeeType.getAsOpaquePtr() ==
+        T->getPointeeTypeAsWritten().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getRValueReferenceType(pointeeType);
   }
 
-  QualType VisitMemberPointerType(const MemberPointerType *T) {
+  QualType VisitMemberPointerType(MemberPointerType const *T) {
     QualType pointeeType = recurse(T->getPointeeType());
     if (pointeeType.isNull())
       return {};
@@ -946,7 +952,7 @@
     return Ctx.getMemberPointerType(pointeeType, T->getClass());
   }
 
-  QualType VisitConstantArrayType(const ConstantArrayType *T) {
+  QualType VisitConstantArrayType(ConstantArrayType const *T) {
     QualType elementType = recurse(T->getElementType());
     if (elementType.isNull())
       return {};
@@ -959,7 +965,7 @@
                                     T->getIndexTypeCVRQualifiers());
   }
 
-  QualType VisitVariableArrayType(const VariableArrayType *T) {
+  QualType VisitVariableArrayType(VariableArrayType const *T) {
     QualType elementType = recurse(T->getElementType());
     if (elementType.isNull())
       return {};
@@ -967,13 +973,12 @@
     if (elementType.getAsOpaquePtr() == T->getElementType().getAsOpaquePtr())
       return QualType(T, 0);
 
-    return Ctx.getVariableArrayType(elementType, T->getSizeExpr(),
-                                    T->getSizeModifier(),
-                                    T->getIndexTypeCVRQualifiers(),
-                                    T->getBracketsRange());
+    return Ctx.getVariableArrayType(
+        elementType, T->getSizeExpr(), T->getSizeModifier(),
+        T->getIndexTypeCVRQualifiers(), T->getBracketsRange());
   }
 
-  QualType VisitIncompleteArrayType(const IncompleteArrayType *T) {
+  QualType VisitIncompleteArrayType(IncompleteArrayType const *T) {
     QualType elementType = recurse(T->getElementType());
     if (elementType.isNull())
       return {};
@@ -985,7 +990,7 @@
                                       T->getIndexTypeCVRQualifiers());
   }
 
-  QualType VisitVectorType(const VectorType *T) {
+  QualType VisitVectorType(VectorType const *T) {
     QualType elementType = recurse(T->getElementType());
     if (elementType.isNull())
       return {};
@@ -997,7 +1002,7 @@
                              T->getVectorKind());
   }
 
-  QualType VisitExtVectorType(const ExtVectorType *T) {
+  QualType VisitExtVectorType(ExtVectorType const *T) {
     QualType elementType = recurse(T->getElementType());
     if (elementType.isNull())
       return {};
@@ -1008,7 +1013,7 @@
     return Ctx.getExtVectorType(elementType, T->getNumElements());
   }
 
-  QualType VisitConstantMatrixType(const ConstantMatrixType *T) {
+  QualType VisitConstantMatrixType(ConstantMatrixType const *T) {
     QualType elementType = recurse(T->getElementType());
     if (elementType.isNull())
       return {};
@@ -1019,7 +1024,7 @@
                                      T->getNumColumns());
   }
 
-  QualType VisitFunctionNoProtoType(const FunctionNoProtoType *T) {
+  QualType VisitFunctionNoProtoType(FunctionNoProtoType const *T) {
     QualType returnType = recurse(T->getReturnType());
     if (returnType.isNull())
       return {};
@@ -1030,7 +1035,7 @@
     return Ctx.getFunctionNoProtoType(returnType, T->getExtInfo());
   }
 
-  QualType VisitFunctionProtoType(const FunctionProtoType *T) {
+  QualType VisitFunctionProtoType(FunctionProtoType const *T) {
     QualType returnType = recurse(T->getReturnType());
     if (returnType.isNull())
       return {};
@@ -1078,7 +1083,7 @@
     return Ctx.getFunctionType(returnType, paramTypes, info);
   }
 
-  QualType VisitParenType(const ParenType *T) {
+  QualType VisitParenType(ParenType const *T) {
     QualType innerType = recurse(T->getInnerType());
     if (innerType.isNull())
       return {};
@@ -1093,7 +1098,7 @@
   SUGARED_TYPE_CLASS(ObjCTypeParam)
   SUGARED_TYPE_CLASS(MacroQualified)
 
-  QualType VisitAdjustedType(const AdjustedType *T) {
+  QualType VisitAdjustedType(AdjustedType const *T) {
     QualType originalType = recurse(T->getOriginalType());
     if (originalType.isNull())
       return {};
@@ -1102,21 +1107,20 @@
     if (adjustedType.isNull())
       return {};
 
-    if (originalType.getAsOpaquePtr()
-          == T->getOriginalType().getAsOpaquePtr() &&
+    if (originalType.getAsOpaquePtr() ==
+            T->getOriginalType().getAsOpaquePtr() &&
         adjustedType.getAsOpaquePtr() == T->getAdjustedType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getAdjustedType(originalType, adjustedType);
   }
 
-  QualType VisitDecayedType(const DecayedType *T) {
+  QualType VisitDecayedType(DecayedType const *T) {
     QualType originalType = recurse(T->getOriginalType());
     if (originalType.isNull())
       return {};
 
-    if (originalType.getAsOpaquePtr()
-          == T->getOriginalType().getAsOpaquePtr())
+    if (originalType.getAsOpaquePtr() == T->getOriginalType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getDecayedType(originalType);
@@ -1132,7 +1136,7 @@
   // FIXME: Non-trivial to implement, but important for C++
   SUGARED_TYPE_CLASS(Elaborated)
 
-  QualType VisitAttributedType(const AttributedType *T) {
+  QualType VisitAttributedType(AttributedType const *T) {
     QualType modifiedType = recurse(T->getModifiedType());
     if (modifiedType.isNull())
       return {};
@@ -1141,23 +1145,23 @@
     if (equivalentType.isNull())
       return {};
 
-    if (modifiedType.getAsOpaquePtr()
-          == T->getModifiedType().getAsOpaquePtr() &&
-        equivalentType.getAsOpaquePtr()
-          == T->getEquivalentType().getAsOpaquePtr())
+    if (modifiedType.getAsOpaquePtr() ==
+            T->getModifiedType().getAsOpaquePtr() &&
+        equivalentType.getAsOpaquePtr() ==
+            T->getEquivalentType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getAttributedType(T->getAttrKind(), modifiedType,
                                  equivalentType);
   }
 
-  QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
+  QualType VisitSubstTemplateTypeParmType(SubstTemplateTypeParmType const *T) {
     QualType replacementType = recurse(T->getReplacementType());
     if (replacementType.isNull())
       return {};
 
-    if (replacementType.getAsOpaquePtr()
-          == T->getReplacementType().getAsOpaquePtr())
+    if (replacementType.getAsOpaquePtr() ==
+        T->getReplacementType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getSubstTemplateTypeParmType(T->getReplacedParameter(),
@@ -1167,7 +1171,7 @@
   // FIXME: Non-trivial to implement, but important for C++
   SUGARED_TYPE_CLASS(TemplateSpecialization)
 
-  QualType VisitAutoType(const AutoType *T) {
+  QualType VisitAutoType(AutoType const *T) {
     if (!T->isDeduced())
       return QualType(T, 0);
 
@@ -1175,17 +1179,15 @@
     if (deducedType.isNull())
       return {};
 
-    if (deducedType.getAsOpaquePtr()
-          == T->getDeducedType().getAsOpaquePtr())
+    if (deducedType.getAsOpaquePtr() == T->getDeducedType().getAsOpaquePtr())
       return QualType(T, 0);
 
-    return Ctx.getAutoType(deducedType, T->getKeyword(),
-                           T->isDependentType(), /*IsPack=*/false,
-                           T->getTypeConstraintConcept(),
+    return Ctx.getAutoType(deducedType, T->getKeyword(), T->isDependentType(),
+                           /*IsPack=*/false, T->getTypeConstraintConcept(),
                            T->getTypeConstraintArguments());
   }
 
-  QualType VisitObjCObjectType(const ObjCObjectType *T) {
+  QualType VisitObjCObjectType(ObjCObjectType const *T) {
     QualType baseType = recurse(T->getBaseType());
     if (baseType.isNull())
       return {};
@@ -1208,33 +1210,31 @@
         !typeArgChanged)
       return QualType(T, 0);
 
-    return Ctx.getObjCObjectType(baseType, typeArgs,
-                                 llvm::makeArrayRef(T->qual_begin(),
-                                                    T->getNumProtocols()),
-                                 T->isKindOfTypeAsWritten());
+    return Ctx.getObjCObjectType(
+        baseType, typeArgs,
+        llvm::makeArrayRef(T->qual_begin(), T->getNumProtocols()),
+        T->isKindOfTypeAsWritten());
   }
 
   TRIVIAL_TYPE_CLASS(ObjCInterface)
 
-  QualType VisitObjCObjectPointerType(const ObjCObjectPointerType *T) {
+  QualType VisitObjCObjectPointerType(ObjCObjectPointerType const *T) {
     QualType pointeeType = recurse(T->getPointeeType());
     if (pointeeType.isNull())
       return {};
 
-    if (pointeeType.getAsOpaquePtr()
-          == T->getPointeeType().getAsOpaquePtr())
+    if (pointeeType.getAsOpaquePtr() == T->getPointeeType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getObjCObjectPointerType(pointeeType);
   }
 
-  QualType VisitAtomicType(const AtomicType *T) {
+  QualType VisitAtomicType(AtomicType const *T) {
     QualType valueType = recurse(T->getValueType());
     if (valueType.isNull())
       return {};
 
-    if (valueType.getAsOpaquePtr()
-          == T->getValueType().getAsOpaquePtr())
+    if (valueType.getAsOpaquePtr() == T->getValueType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getAtomicType(valueType);
@@ -1255,7 +1255,7 @@
                            ObjCSubstitutionContext context)
       : BaseType(ctx), TypeArgs(typeArgs), SubstContext(context) {}
 
-  QualType VisitObjCTypeParamType(const ObjCTypeParamType *OTPTy) {
+  QualType VisitObjCTypeParamType(ObjCTypeParamType const *OTPTy) {
     // Replace an Objective-C type parameter reference with the corresponding
     // type argument.
     ObjCTypeParamDecl *typeParam = OTPTy->getDecl();
@@ -1271,7 +1271,7 @@
       protocolsVec.append(OTPTy->qual_begin(), OTPTy->qual_end());
       ArrayRef<ObjCProtocolDecl *> protocolsToApply = protocolsVec;
       return Ctx.applyObjCProtocolQualifiers(
-          argType, protocolsToApply, hasError, true/*allowOnPointerType*/);
+          argType, protocolsToApply, hasError, true /*allowOnPointerType*/);
     }
 
     switch (SubstContext) {
@@ -1284,7 +1284,7 @@
     case ObjCSubstitutionContext::Result:
     case ObjCSubstitutionContext::Property: {
       // Substitute the __kindof form of the underlying type.
-      const auto *objPtr =
+      auto const *objPtr =
           typeParam->getUnderlyingType()->castAs<ObjCObjectPointerType>();
 
       // __kindof types, id, and Class don't need an additional
@@ -1293,7 +1293,7 @@
         return typeParam->getUnderlyingType();
 
       // Add __kindof.
-      const auto *obj = objPtr->getObjectType();
+      auto const *obj = objPtr->getObjectType();
       QualType resultTy = Ctx.getObjCObjectType(
           obj->getBaseType(), obj->getTypeArgsAsWritten(), obj->getProtocols(),
           /*isKindOf=*/true);
@@ -1305,11 +1305,11 @@
     llvm_unreachable("Unexpected ObjCSubstitutionContext!");
   }
 
-  QualType VisitFunctionType(const FunctionType *funcType) {
+  QualType VisitFunctionType(FunctionType const *funcType) {
     // If we have a function type, update the substitution context
     // appropriately.
 
-    //Substitute result type.
+    // Substitute result type.
     QualType returnType = funcType->getReturnType().substObjCTypeArgs(
         Ctx, TypeArgs, ObjCSubstitutionContext::Result);
     if (returnType.isNull())
@@ -1327,7 +1327,7 @@
       return Ctx.getFunctionNoProtoType(returnType, funcType->getExtInfo());
     }
 
-    const auto *funcProtoType = cast<FunctionProtoType>(funcType);
+    auto const *funcProtoType = cast<FunctionProtoType>(funcType);
 
     // Transform parameter types.
     SmallVector<QualType, 4> paramTypes;
@@ -1375,7 +1375,7 @@
     return Ctx.getFunctionType(returnType, paramTypes, info);
   }
 
-  QualType VisitObjCObjectType(const ObjCObjectType *objcObjectType) {
+  QualType VisitObjCObjectType(ObjCObjectType const *objcObjectType) {
     // Substitute into the type arguments of a specialized Objective-C object
     // type.
     if (objcObjectType->isSpecializedAsWritten()) {
@@ -1417,20 +1417,20 @@
     return BaseType::VisitObjCObjectType(objcObjectType);
   }
 
-  QualType VisitAttributedType(const AttributedType *attrType) {
+  QualType VisitAttributedType(AttributedType const *attrType) {
     QualType newType = BaseType::VisitAttributedType(attrType);
     if (newType.isNull())
       return {};
 
-    const auto *newAttrType = dyn_cast<AttributedType>(newType.getTypePtr());
+    auto const *newAttrType = dyn_cast<AttributedType>(newType.getTypePtr());
     if (!newAttrType || newAttrType->getAttrKind() != attr::ObjCKindOf)
       return newType;
 
     // Find out if it's an Objective-C object or object pointer type;
     QualType newEquivType = newAttrType->getEquivalentType();
-    const ObjCObjectPointerType *ptrType =
+    ObjCObjectPointerType const *ptrType =
         newEquivType->getAs<ObjCObjectPointerType>();
-    const ObjCObjectType *objType = ptrType
+    ObjCObjectType const *objType = ptrType
                                         ? ptrType->getObjectType()
                                         : newEquivType->getAs<ObjCObjectType>();
     if (!objType)
@@ -1460,7 +1460,7 @@
 
   explicit StripObjCKindOfTypeVisitor(ASTContext &ctx) : BaseType(ctx) {}
 
-  QualType VisitObjCObjectType(const ObjCObjectType *objType) {
+  QualType VisitObjCObjectType(ObjCObjectType const *objType) {
     if (!objType->isKindOfType())
       return BaseType::VisitObjCObjectType(objType);
 
@@ -1483,7 +1483,7 @@
 }
 
 QualType QualType::substObjCMemberType(QualType objectType,
-                                       const DeclContext *dc,
+                                       DeclContext const *dc,
                                        ObjCSubstitutionContext context) const {
   if (auto subs = objectType->getObjCSubstitutions(dc))
     return substObjCTypeArgs(dc->getParentASTContext(), *subs, context);
@@ -1491,7 +1491,7 @@
   return *this;
 }
 
-QualType QualType::stripObjCKindOfType(const ASTContext &constCtx) const {
+QualType QualType::stripObjCKindOfType(ASTContext const &constCtx) const {
   // FIXME: Because ASTContext::getAttributedType() is non-const.
   auto &ctx = const_cast<ASTContext &>(constCtx);
   StripObjCKindOfTypeVisitor visitor(ctx);
@@ -1499,21 +1499,21 @@
 }
 
 QualType QualType::getAtomicUnqualifiedType() const {
-  if (const auto AT = getTypePtr()->getAs<AtomicType>())
+  if (auto const AT = getTypePtr()->getAs<AtomicType>())
     return AT->getValueType().getUnqualifiedType();
   return getUnqualifiedType();
 }
 
-Optional<ArrayRef<QualType>> Type::getObjCSubstitutions(
-                               const DeclContext *dc) const {
+Optional<ArrayRef<QualType>>
+Type::getObjCSubstitutions(DeclContext const *dc) const {
   // Look through method scopes.
-  if (const auto method = dyn_cast<ObjCMethodDecl>(dc))
+  if (auto const method = dyn_cast<ObjCMethodDecl>(dc))
     dc = method->getDeclContext();
 
   // Find the class or category in which the type we're substituting
   // was declared.
-  const auto *dcClassDecl = dyn_cast<ObjCInterfaceDecl>(dc);
-  const ObjCCategoryDecl *dcCategoryDecl = nullptr;
+  auto const *dcClassDecl = dyn_cast<ObjCInterfaceDecl>(dc);
+  ObjCCategoryDecl const *dcCategoryDecl = nullptr;
   ObjCTypeParamList *dcTypeParams = nullptr;
   if (dcClassDecl) {
     // If the class does not have any type parameters, there's no
@@ -1542,20 +1542,20 @@
   assert(dcClassDecl && "No class context");
 
   // Find the underlying object type.
-  const ObjCObjectType *objectType;
-  if (const auto *objectPointerType = getAs<ObjCObjectPointerType>()) {
+  ObjCObjectType const *objectType;
+  if (auto const *objectPointerType = getAs<ObjCObjectPointerType>()) {
     objectType = objectPointerType->getObjectType();
   } else if (getAs<BlockPointerType>()) {
     ASTContext &ctx = dc->getParentASTContext();
     objectType = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, {}, {})
-                   ->castAs<ObjCObjectType>();
+                     ->castAs<ObjCObjectType>();
   } else {
     objectType = getAs<ObjCObjectType>();
   }
 
   /// Extract the class from the receiver object type.
-  ObjCInterfaceDecl *curClassDecl = objectType ? objectType->getInterface()
-                                               : nullptr;
+  ObjCInterfaceDecl *curClassDecl =
+      objectType ? objectType->getInterface() : nullptr;
   if (!curClassDecl) {
     // If we don't have a context type (e.g., this is "id" or some
     // variant thereof), substitute the bounds.
@@ -1608,7 +1608,7 @@
   }
 
   // Extract the superclass type.
-  const ObjCObjectType *superClassObjTy = classDecl->getSuperClassType();
+  ObjCObjectType const *superClassObjTy = classDecl->getSuperClassType();
   if (!superClassObjTy) {
     CachedSuperClassType.setInt(true);
     return;
@@ -1626,7 +1626,7 @@
   ObjCTypeParamList *superClassTypeParams = superClassDecl->getTypeParamList();
   if (!superClassTypeParams) {
     CachedSuperClassType.setPointerAndInt(
-      superClassType->castAs<ObjCObjectType>(), true);
+        superClassType->castAs<ObjCObjectType>(), true);
     return;
   }
 
@@ -1641,19 +1641,18 @@
   ObjCTypeParamList *typeParams = classDecl->getTypeParamList();
   if (!typeParams) {
     CachedSuperClassType.setPointerAndInt(
-      superClassType->castAs<ObjCObjectType>(), true);
+        superClassType->castAs<ObjCObjectType>(), true);
     return;
   }
 
   // If the subclass type isn't specialized, return the unspecialized
   // superclass.
   if (isUnspecialized()) {
-    QualType unspecializedSuper
-      = classDecl->getASTContext().getObjCInterfaceType(
-          superClassObjTy->getInterface());
+    QualType unspecializedSuper =
+        classDecl->getASTContext().getObjCInterfaceType(
+            superClassObjTy->getInterface());
     CachedSuperClassType.setPointerAndInt(
-      unspecializedSuper->castAs<ObjCObjectType>(),
-      true);
+        unspecializedSuper->castAs<ObjCObjectType>(), true);
     return;
   }
 
@@ -1661,16 +1660,18 @@
   ArrayRef<QualType> typeArgs = getTypeArgs();
   assert(typeArgs.size() == typeParams->size());
   CachedSuperClassType.setPointerAndInt(
-    superClassType.substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
-                                     ObjCSubstitutionContext::Superclass)
-      ->castAs<ObjCObjectType>(),
-    true);
+      superClassType
+          .substObjCTypeArgs(classDecl->getASTContext(), typeArgs,
+                             ObjCSubstitutionContext::Superclass)
+          ->castAs<ObjCObjectType>(),
+      true);
 }
 
-const ObjCInterfaceType *ObjCObjectPointerType::getInterfaceType() const {
+ObjCInterfaceType const *ObjCObjectPointerType::getInterfaceType() const {
   if (auto interfaceDecl = getObjectType()->getInterface()) {
-    return interfaceDecl->getASTContext().getObjCInterfaceType(interfaceDecl)
-             ->castAs<ObjCInterfaceType>();
+    return interfaceDecl->getASTContext()
+        .getObjCInterfaceType(interfaceDecl)
+        ->castAs<ObjCInterfaceType>();
   }
 
   return nullptr;
@@ -1685,11 +1686,11 @@
   return ctx.getObjCObjectPointerType(superObjectType);
 }
 
-const ObjCObjectType *Type::getAsObjCQualifiedInterfaceType() const {
+ObjCObjectType const *Type::getAsObjCQualifiedInterfaceType() const {
   // There is no sugar for ObjCObjectType's, just return the canonical
   // type pointer if it is the right class.  There is no typedef information to
   // return and these cannot be Address-space qualified.
-  if (const auto *T = getAs<ObjCObjectType>())
+  if (auto const *T = getAs<ObjCObjectType>())
     if (T->getNumProtocols() && T->getInterface())
       return T;
   return nullptr;
@@ -1699,52 +1700,52 @@
   return getAsObjCQualifiedInterfaceType() != nullptr;
 }
 
-const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const {
+ObjCObjectPointerType const *Type::getAsObjCQualifiedIdType() const {
   // There is no sugar for ObjCQualifiedIdType's, just return the canonical
   // type pointer if it is the right class.
-  if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
+  if (auto const *OPT = getAs<ObjCObjectPointerType>()) {
     if (OPT->isObjCQualifiedIdType())
       return OPT;
   }
   return nullptr;
 }
 
-const ObjCObjectPointerType *Type::getAsObjCQualifiedClassType() const {
+ObjCObjectPointerType const *Type::getAsObjCQualifiedClassType() const {
   // There is no sugar for ObjCQualifiedClassType's, just return the canonical
   // type pointer if it is the right class.
-  if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
+  if (auto const *OPT = getAs<ObjCObjectPointerType>()) {
     if (OPT->isObjCQualifiedClassType())
       return OPT;
   }
   return nullptr;
 }
 
-const ObjCObjectType *Type::getAsObjCInterfaceType() const {
-  if (const auto *OT = getAs<ObjCObjectType>()) {
+ObjCObjectType const *Type::getAsObjCInterfaceType() const {
+  if (auto const *OT = getAs<ObjCObjectType>()) {
     if (OT->getInterface())
       return OT;
   }
   return nullptr;
 }
 
-const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const {
-  if (const auto *OPT = getAs<ObjCObjectPointerType>()) {
+ObjCObjectPointerType const *Type::getAsObjCInterfacePointerType() const {
+  if (auto const *OPT = getAs<ObjCObjectPointerType>()) {
     if (OPT->getInterfaceType())
       return OPT;
   }
   return nullptr;
 }
 
-const CXXRecordDecl *Type::getPointeeCXXRecordDecl() const {
+CXXRecordDecl const *Type::getPointeeCXXRecordDecl() const {
   QualType PointeeType;
-  if (const auto *PT = getAs<PointerType>())
+  if (auto const *PT = getAs<PointerType>())
     PointeeType = PT->getPointeeType();
-  else if (const auto *RT = getAs<ReferenceType>())
+  else if (auto const *RT = getAs<ReferenceType>())
     PointeeType = RT->getPointeeType();
   else
     return nullptr;
 
-  if (const auto *RT = PointeeType->getAs<RecordType>())
+  if (auto const *RT = PointeeType->getAs<RecordType>())
     return dyn_cast<CXXRecordDecl>(RT->getDecl());
 
   return nullptr;
@@ -1759,17 +1760,17 @@
 }
 
 TagDecl *Type::getAsTagDecl() const {
-  if (const auto *TT = getAs<TagType>())
+  if (auto const *TT = getAs<TagType>())
     return TT->getDecl();
-  if (const auto *Injected = getAs<InjectedClassNameType>())
+  if (auto const *Injected = getAs<InjectedClassNameType>())
     return Injected->getDecl();
 
   return nullptr;
 }
 
 bool Type::hasAttr(attr::Kind AK) const {
-  const Type *Cur = this;
-  while (const auto *AT = Cur->getAs<AttributedType>()) {
+  Type const *Cur = this;
+  while (auto const *AT = Cur->getAs<AttributedType>()) {
     if (AT->getAttrKind() == AK)
       return true;
     Cur = AT->getEquivalentType().getTypePtr();
@@ -1779,103 +1780,100 @@
 
 namespace {
 
-  class GetContainedDeducedTypeVisitor :
-    public TypeVisitor<GetContainedDeducedTypeVisitor, Type*> {
-    bool Syntactic;
+class GetContainedDeducedTypeVisitor
+    : public TypeVisitor<GetContainedDeducedTypeVisitor, Type *> {
+  bool Syntactic;
 
-  public:
-    GetContainedDeducedTypeVisitor(bool Syntactic = false)
-        : Syntactic(Syntactic) {}
+public:
+  GetContainedDeducedTypeVisitor(bool Syntactic = false)
+      : Syntactic(Syntactic) {}
 
-    using TypeVisitor<GetContainedDeducedTypeVisitor, Type*>::Visit;
+  using TypeVisitor<GetContainedDeducedTypeVisitor, Type *>::Visit;
 
-    Type *Visit(QualType T) {
-      if (T.isNull())
-        return nullptr;
-      return Visit(T.getTypePtr());
-    }
+  Type *Visit(QualType T) {
+    if (T.isNull())
+      return nullptr;
+    return Visit(T.getTypePtr());
+  }
 
-    // The deduced type itself.
-    Type *VisitDeducedType(const DeducedType *AT) {
-      return const_cast<DeducedType*>(AT);
-    }
+  // The deduced type itself.
+  Type *VisitDeducedType(DeducedType const *AT) {
+    return const_cast<DeducedType *>(AT);
+  }
 
-    // Only these types can contain the desired 'auto' type.
-    Type *VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
-      return Visit(T->getReplacementType());
-    }
+  // Only these types can contain the desired 'auto' type.
+  Type *VisitSubstTemplateTypeParmType(SubstTemplateTypeParmType const *T) {
+    return Visit(T->getReplacementType());
+  }
 
-    Type *VisitElaboratedType(const ElaboratedType *T) {
-      return Visit(T->getNamedType());
-    }
+  Type *VisitElaboratedType(ElaboratedType const *T) {
+    return Visit(T->getNamedType());
+  }
 
-    Type *VisitPointerType(const PointerType *T) {
-      return Visit(T->getPointeeType());
-    }
+  Type *VisitPointerType(PointerType const *T) {
+    return Visit(T->getPointeeType());
+  }
 
-    Type *VisitBlockPointerType(const BlockPointerType *T) {
-      return Visit(T->getPointeeType());
-    }
+  Type *VisitBlockPointerType(BlockPointerType const *T) {
+    return Visit(T->getPointeeType());
+  }
 
-    Type *VisitReferenceType(const ReferenceType *T) {
-      return Visit(T->getPointeeTypeAsWritten());
-    }
+  Type *VisitReferenceType(ReferenceType const *T) {
+    return Visit(T->getPointeeTypeAsWritten());
+  }
 
-    Type *VisitMemberPointerType(const MemberPointerType *T) {
-      return Visit(T->getPointeeType());
-    }
+  Type *VisitMemberPointerType(MemberPointerType const *T) {
+    return Visit(T->getPointeeType());
+  }
 
-    Type *VisitArrayType(const ArrayType *T) {
-      return Visit(T->getElementType());
-    }
+  Type *VisitArrayType(ArrayType const *T) {
+    return Visit(T->getElementType());
+  }
 
-    Type *VisitDependentSizedExtVectorType(
-      const DependentSizedExtVectorType *T) {
-      return Visit(T->getElementType());
-    }
+  Type *VisitDependentSizedExtVectorType(DependentSizedExtVectorType const *T) {
+    return Visit(T->getElementType());
+  }
 
-    Type *VisitVectorType(const VectorType *T) {
-      return Visit(T->getElementType());
-    }
+  Type *VisitVectorType(VectorType const *T) {
+    return Visit(T->getElementType());
+  }
 
-    Type *VisitDependentSizedMatrixType(const DependentSizedMatrixType *T) {
-      return Visit(T->getElementType());
-    }
+  Type *VisitDependentSizedMatrixType(DependentSizedMatrixType const *T) {
+    return Visit(T->getElementType());
+  }
 
-    Type *VisitConstantMatrixType(const ConstantMatrixType *T) {
-      return Visit(T->getElementType());
-    }
+  Type *VisitConstantMatrixType(ConstantMatrixType const *T) {
+    return Visit(T->getElementType());
+  }
 
-    Type *VisitFunctionProtoType(const FunctionProtoType *T) {
-      if (Syntactic && T->hasTrailingReturn())
-        return const_cast<FunctionProtoType*>(T);
-      return VisitFunctionType(T);
-    }
+  Type *VisitFunctionProtoType(FunctionProtoType const *T) {
+    if (Syntactic && T->hasTrailingReturn())
+      return const_cast<FunctionProtoType *>(T);
+    return VisitFunctionType(T);
+  }
 
-    Type *VisitFunctionType(const FunctionType *T) {
-      return Visit(T->getReturnType());
-    }
+  Type *VisitFunctionType(FunctionType const *T) {
+    return Visit(T->getReturnType());
+  }
 
-    Type *VisitParenType(const ParenType *T) {
-      return Visit(T->getInnerType());
-    }
+  Type *VisitParenType(ParenType const *T) { return Visit(T->getInnerType()); }
 
-    Type *VisitAttributedType(const AttributedType *T) {
-      return Visit(T->getModifiedType());
-    }
+  Type *VisitAttributedType(AttributedType const *T) {
+    return Visit(T->getModifiedType());
+  }
 
-    Type *VisitMacroQualifiedType(const MacroQualifiedType *T) {
-      return Visit(T->getUnderlyingType());
-    }
+  Type *VisitMacroQualifiedType(MacroQualifiedType const *T) {
+    return Visit(T->getUnderlyingType());
+  }
 
-    Type *VisitAdjustedType(const AdjustedType *T) {
-      return Visit(T->getOriginalType());
-    }
+  Type *VisitAdjustedType(AdjustedType const *T) {
+    return Visit(T->getOriginalType());
+  }
 
-    Type *VisitPackExpansionType(const PackExpansionType *T) {
-      return Visit(T->getPattern());
-    }
-  };
+  Type *VisitPackExpansionType(PackExpansionType const *T) {
+    return Visit(T->getPattern());
+  }
+};
 
 } // namespace
 
@@ -1890,7 +1888,7 @@
 }
 
 bool Type::hasIntegerRepresentation() const {
-  if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
+  if (auto const *VT = dyn_cast<VectorType>(CanonicalType))
     return VT->getElementType()->isIntegerType();
   else
     return isIntegerType();
@@ -1915,21 +1913,21 @@
 /// \param Ctx The context in which this type occurs.
 ///
 /// \returns true if the type is considered an integral type, false otherwise.
-bool Type::isIntegralType(const ASTContext &Ctx) const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+bool Type::isIntegralType(ASTContext const &Ctx) const {
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
            BT->getKind() <= BuiltinType::Int128;
 
   // Complete enum types are integral in C.
   if (!Ctx.getLangOpts().CPlusPlus)
-    if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
+    if (auto const *ET = dyn_cast<EnumType>(CanonicalType))
       return ET->getDecl()->isComplete();
 
   return isExtIntType();
 }
 
 bool Type::isIntegralOrUnscopedEnumerationType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
            BT->getKind() <= BuiltinType::Int128;
 
@@ -1940,14 +1938,14 @@
 }
 
 bool Type::isUnscopedEnumerationType() const {
-  if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
+  if (auto const *ET = dyn_cast<EnumType>(CanonicalType))
     return !ET->getDecl()->isScoped();
 
   return false;
 }
 
 bool Type::isCharType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() == BuiltinType::Char_U ||
            BT->getKind() == BuiltinType::UChar ||
            BT->getKind() == BuiltinType::Char_S ||
@@ -1956,26 +1954,26 @@
 }
 
 bool Type::isWideCharType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() == BuiltinType::WChar_S ||
            BT->getKind() == BuiltinType::WChar_U;
   return false;
 }
 
 bool Type::isChar8Type() const {
-  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (BuiltinType const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() == BuiltinType::Char8;
   return false;
 }
 
 bool Type::isChar16Type() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() == BuiltinType::Char16;
   return false;
 }
 
 bool Type::isChar32Type() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() == BuiltinType::Char32;
   return false;
 }
@@ -1983,10 +1981,12 @@
 /// Determine whether this type is any of the built-in character
 /// types.
 bool Type::isAnyCharacterType() const {
-  const auto *BT = dyn_cast<BuiltinType>(CanonicalType);
-  if (!BT) return false;
+  auto const *BT = dyn_cast<BuiltinType>(CanonicalType);
+  if (!BT)
+    return false;
   switch (BT->getKind()) {
-  default: return false;
+  default:
+    return false;
   case BuiltinType::Char_U:
   case BuiltinType::UChar:
   case BuiltinType::WChar_U:
@@ -2004,44 +2004,43 @@
 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
 /// an enum decl which has a signed representation
 bool Type::isSignedIntegerType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType)) {
     return BT->getKind() >= BuiltinType::Char_S &&
            BT->getKind() <= BuiltinType::Int128;
   }
 
-  if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
+  if (EnumType const *ET = dyn_cast<EnumType>(CanonicalType)) {
     // Incomplete enum types are not treated as integer types.
     // FIXME: In C++, enum types are never integer types.
     if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
       return ET->getDecl()->getIntegerType()->isSignedIntegerType();
   }
 
-  if (const ExtIntType *IT = dyn_cast<ExtIntType>(CanonicalType))
+  if (ExtIntType const *IT = dyn_cast<ExtIntType>(CanonicalType))
     return IT->isSigned();
 
   return false;
 }
 
 bool Type::isSignedIntegerOrEnumerationType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType)) {
     return BT->getKind() >= BuiltinType::Char_S &&
            BT->getKind() <= BuiltinType::Int128;
   }
 
-  if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
+  if (auto const *ET = dyn_cast<EnumType>(CanonicalType)) {
     if (ET->getDecl()->isComplete())
       return ET->getDecl()->getIntegerType()->isSignedIntegerType();
   }
 
-  if (const ExtIntType *IT = dyn_cast<ExtIntType>(CanonicalType))
+  if (ExtIntType const *IT = dyn_cast<ExtIntType>(CanonicalType))
     return IT->isSigned();
 
-
   return false;
 }
 
 bool Type::hasSignedIntegerRepresentation() const {
-  if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
+  if (auto const *VT = dyn_cast<VectorType>(CanonicalType))
     return VT->getElementType()->isSignedIntegerOrEnumerationType();
   else
     return isSignedIntegerOrEnumerationType();
@@ -2051,86 +2050,86 @@
 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum
 /// decl which has an unsigned representation
 bool Type::isUnsignedIntegerType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType)) {
     return BT->getKind() >= BuiltinType::Bool &&
            BT->getKind() <= BuiltinType::UInt128;
   }
 
-  if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
+  if (auto const *ET = dyn_cast<EnumType>(CanonicalType)) {
     // Incomplete enum types are not treated as integer types.
     // FIXME: In C++, enum types are never integer types.
     if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
       return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
   }
 
-  if (const ExtIntType *IT = dyn_cast<ExtIntType>(CanonicalType))
+  if (ExtIntType const *IT = dyn_cast<ExtIntType>(CanonicalType))
     return IT->isUnsigned();
 
   return false;
 }
 
 bool Type::isUnsignedIntegerOrEnumerationType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType)) {
     return BT->getKind() >= BuiltinType::Bool &&
-    BT->getKind() <= BuiltinType::UInt128;
+           BT->getKind() <= BuiltinType::UInt128;
   }
 
-  if (const auto *ET = dyn_cast<EnumType>(CanonicalType)) {
+  if (auto const *ET = dyn_cast<EnumType>(CanonicalType)) {
     if (ET->getDecl()->isComplete())
       return ET->getDecl()->getIntegerType()->isUnsignedIntegerType();
   }
 
-  if (const ExtIntType *IT = dyn_cast<ExtIntType>(CanonicalType))
+  if (ExtIntType const *IT = dyn_cast<ExtIntType>(CanonicalType))
     return IT->isUnsigned();
 
   return false;
 }
 
 bool Type::hasUnsignedIntegerRepresentation() const {
-  if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
+  if (auto const *VT = dyn_cast<VectorType>(CanonicalType))
     return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
-  if (const auto *VT = dyn_cast<MatrixType>(CanonicalType))
+  if (auto const *VT = dyn_cast<MatrixType>(CanonicalType))
     return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
   return isUnsignedIntegerOrEnumerationType();
 }
 
 bool Type::isFloatingType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Half &&
            BT->getKind() <= BuiltinType::Ibm128;
-  if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
+  if (auto const *CT = dyn_cast<ComplexType>(CanonicalType))
     return CT->getElementType()->isFloatingType();
   return false;
 }
 
 bool Type::hasFloatingRepresentation() const {
-  if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
+  if (auto const *VT = dyn_cast<VectorType>(CanonicalType))
     return VT->getElementType()->isFloatingType();
   else
     return isFloatingType();
 }
 
 bool Type::isRealFloatingType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->isFloatingPoint();
   return false;
 }
 
 bool Type::isRealType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
            BT->getKind() <= BuiltinType::Ibm128;
-  if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
-      return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
+  if (auto const *ET = dyn_cast<EnumType>(CanonicalType))
+    return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
   return isExtIntType();
 }
 
 bool Type::isArithmeticType() const {
-  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+  if (auto const *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
            BT->getKind() <= BuiltinType::Ibm128 &&
            BT->getKind() != BuiltinType::BFloat16;
-  if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
+  if (auto const *ET = dyn_cast<EnumType>(CanonicalType))
     // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
     // If a body isn't seen by the time we get here, return false.
     //
@@ -2144,13 +2143,18 @@
 Type::ScalarTypeKind Type::getScalarTypeKind() const {
   assert(isScalarType());
 
-  const Type *T = CanonicalType.getTypePtr();
-  if (const auto *BT = dyn_cast<BuiltinType>(T)) {
-    if (BT->getKind() == BuiltinType::Bool) return STK_Bool;
-    if (BT->getKind() == BuiltinType::NullPtr) return STK_CPointer;
-    if (BT->isInteger()) return STK_Integral;
-    if (BT->isFloatingPoint()) return STK_Floating;
-    if (BT->isFixedPointType()) return STK_FixedPoint;
+  Type const *T = CanonicalType.getTypePtr();
+  if (auto const *BT = dyn_cast<BuiltinType>(T)) {
+    if (BT->getKind() == BuiltinType::Bool)
+      return STK_Bool;
+    if (BT->getKind() == BuiltinType::NullPtr)
+      return STK_CPointer;
+    if (BT->isInteger())
+      return STK_Integral;
+    if (BT->isFloatingPoint())
+      return STK_Floating;
+    if (BT->isFixedPointType())
+      return STK_FixedPoint;
     llvm_unreachable("unknown scalar builtin type");
   } else if (isa<PointerType>(T)) {
     return STK_CPointer;
@@ -2163,7 +2167,7 @@
   } else if (isa<EnumType>(T)) {
     assert(cast<EnumType>(T)->getDecl()->isComplete());
     return STK_Integral;
-  } else if (const auto *CT = dyn_cast<ComplexType>(T)) {
+  } else if (auto const *CT = dyn_cast<ComplexType>(T)) {
     if (CT->getElementType()->isRealFloatingType())
       return STK_FloatingComplex;
     return STK_IntegralComplex;
@@ -2184,8 +2188,8 @@
 /// subsumes the notion of C aggregates (C99 6.2.5p21) because it also
 /// includes union types.
 bool Type::isAggregateType() const {
-  if (const auto *Record = dyn_cast<RecordType>(CanonicalType)) {
-    if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl()))
+  if (auto const *Record = dyn_cast<RecordType>(CanonicalType)) {
+    if (auto const *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl()))
       return ClassDecl->isAggregate();
 
     return true;
@@ -2212,7 +2216,8 @@
     *Def = nullptr;
 
   switch (CanonicalType->getTypeClass()) {
-  default: return false;
+  default:
+    return false;
   case Builtin:
     // Void is the only incomplete builtin type.  Per C99 6.2.5p19, it can never
     // be completed.
@@ -2237,8 +2242,9 @@
     // (C++ [dcl.array]p1).
     // We don't handle dependent-sized arrays (dependent types are never treated
     // as incomplete).
-    return cast<ArrayType>(CanonicalType)->getElementType()
-             ->isIncompleteType(Def);
+    return cast<ArrayType>(CanonicalType)
+        ->getElementType()
+        ->isIncompleteType(Def);
   case IncompleteArray:
     // An array of unknown size is an incomplete type (C99 6.2.5p22).
     return true;
@@ -2247,11 +2253,11 @@
     // RequireCompleteType: they attach a MSInheritanceAttr to the CXXRecordDecl
     // to indicate which inheritance model to use.
     auto *MPTy = cast<MemberPointerType>(CanonicalType);
-    const Type *ClassTy = MPTy->getClass();
+    Type const *ClassTy = MPTy->getClass();
     // Member pointers with dependent class types don't get special treatment.
     if (ClassTy->isDependentType())
       return false;
-    const CXXRecordDecl *RD = ClassTy->getAsCXXRecordDecl();
+    CXXRecordDecl const *RD = ClassTy->getAsCXXRecordDecl();
     ASTContext &Context = RD->getASTContext();
     // Member pointers not in the MS ABI don't get special treatment.
     if (!Context.getTargetInfo().getCXXABI().isMicrosoft())
@@ -2265,12 +2271,13 @@
     return true;
   }
   case ObjCObject:
-    return cast<ObjCObjectType>(CanonicalType)->getBaseType()
-             ->isIncompleteType(Def);
+    return cast<ObjCObjectType>(CanonicalType)
+        ->getBaseType()
+        ->isIncompleteType(Def);
   case ObjCInterface: {
     // ObjC interfaces are incomplete if they are @class, not @interface.
-    ObjCInterfaceDecl *Interface
-      = cast<ObjCInterfaceType>(CanonicalType)->getDecl();
+    ObjCInterfaceDecl *Interface =
+        cast<ObjCInterfaceType>(CanonicalType)->getDecl();
     if (Def)
       *Def = Interface;
     return !Interface->hasDefinition();
@@ -2279,7 +2286,7 @@
 }
 
 bool Type::isSizelessBuiltinType() const {
-  if (const BuiltinType *BT = getAs<BuiltinType>()) {
+  if (BuiltinType const *BT = getAs<BuiltinType>()) {
     switch (BT->getKind()) {
       // SVE Types
 #define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
@@ -2297,7 +2304,7 @@
 bool Type::isSizelessType() const { return isSizelessBuiltinType(); }
 
 bool Type::isVLSTBuiltinType() const {
-  if (const BuiltinType *BT = getAs<BuiltinType>()) {
+  if (BuiltinType const *BT = getAs<BuiltinType>()) {
     switch (BT->getKind()) {
     case BuiltinType::SveInt8:
     case BuiltinType::SveInt16:
@@ -2320,10 +2327,10 @@
   return false;
 }
 
-QualType Type::getSveEltType(const ASTContext &Ctx) const {
+QualType Type::getSveEltType(ASTContext const &Ctx) const {
   assert(isVLSTBuiltinType() && "unsupported type!");
 
-  const BuiltinType *BTy = getAs<BuiltinType>();
+  BuiltinType const *BTy = getAs<BuiltinType>();
   if (BTy->getKind() == BuiltinType::SveBool)
     // Represent predicates as i8 rather than i1 to avoid any layout issues.
     // The type is bitcasted to a scalable predicate type when casting between
@@ -2333,7 +2340,7 @@
     return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType;
 }
 
-bool QualType::isPODType(const ASTContext &Context) const {
+bool QualType::isPODType(ASTContext const &Context) const {
   // C++11 has a more relaxed definition of POD.
   if (Context.getLangOpts().CPlusPlus11)
     return isCXX11PODType(Context);
@@ -2341,7 +2348,7 @@
   return isCXX98PODType(Context);
 }
 
-bool QualType::isCXX98PODType(const ASTContext &Context) const {
+bool QualType::isCXX98PODType(ASTContext const &Context) const {
   // The compiler shouldn't query this for incomplete types, but the user might.
   // We return false for that case. Except for incomplete arrays of PODs, which
   // are PODs according to the standard.
@@ -2360,7 +2367,8 @@
   QualType CanonicalType = getTypePtr()->CanonicalType;
   switch (CanonicalType->getTypeClass()) {
     // Everything not explicitly mentioned is not POD.
-  default: return false;
+  default:
+    return false;
   case Type::VariableArray:
   case Type::ConstantArray:
     // IncompleteArray is handled above.
@@ -2381,7 +2389,7 @@
     return true;
 
   case Type::Record:
-    if (const auto *ClassDecl =
+    if (auto const *ClassDecl =
             dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl()))
       return ClassDecl->isPOD();
 
@@ -2390,7 +2398,7 @@
   }
 }
 
-bool QualType::isTrivialType(const ASTContext &Context) const {
+bool QualType::isTrivialType(ASTContext const &Context) const {
   // The compiler shouldn't query this for incomplete types, but the user might.
   // We return false for that case. Except for incomplete arrays of PODs, which
   // are PODs according to the standard.
@@ -2423,8 +2431,8 @@
   // As an extension, Clang treats vector types as Scalar types.
   if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
     return true;
-  if (const auto *RT = CanonicalType->getAs<RecordType>()) {
-    if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
+  if (auto const *RT = CanonicalType->getAs<RecordType>()) {
+    if (auto const *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
       // C++11 [class]p6:
       //   A trivial class is a class that has a default constructor,
       //   has no non-trivial default constructors, and is trivially
@@ -2441,7 +2449,7 @@
   return false;
 }
 
-bool QualType::isTriviallyCopyableType(const ASTContext &Context) const {
+bool QualType::isTriviallyCopyableType(ASTContext const &Context) const {
   if ((*this)->isArrayType())
     return Context.getBaseElementType(*this).isTriviallyCopyableType(Context);
 
@@ -2469,9 +2477,10 @@
   if (CanonicalType->isScalarType() || CanonicalType->isVectorType())
     return true;
 
-  if (const auto *RT = CanonicalType->getAs<RecordType>()) {
-    if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
-      if (!ClassDecl->isTriviallyCopyable()) return false;
+  if (auto const *RT = CanonicalType->getAs<RecordType>()) {
+    if (auto const *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
+      if (!ClassDecl->isTriviallyCopyable())
+        return false;
     }
 
     return true;
@@ -2481,27 +2490,28 @@
   return false;
 }
 
-bool QualType::isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const {
+bool QualType::isNonWeakInMRRWithObjCWeak(ASTContext const &Context) const {
   return !Context.getLangOpts().ObjCAutoRefCount &&
          Context.getLangOpts().ObjCWeak &&
          getObjCLifetime() != Qualifiers::OCL_Weak;
 }
 
-bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD) {
+bool QualType::hasNonTrivialToPrimitiveDefaultInitializeCUnion(
+    RecordDecl const *RD) {
   return RD->hasNonTrivialToPrimitiveDefaultInitializeCUnion();
 }
 
-bool QualType::hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD) {
+bool QualType::hasNonTrivialToPrimitiveDestructCUnion(RecordDecl const *RD) {
   return RD->hasNonTrivialToPrimitiveDestructCUnion();
 }
 
-bool QualType::hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD) {
+bool QualType::hasNonTrivialToPrimitiveCopyCUnion(RecordDecl const *RD) {
   return RD->hasNonTrivialToPrimitiveCopyCUnion();
 }
 
 QualType::PrimitiveDefaultInitializeKind
 QualType::isNonTrivialToPrimitiveDefaultInitialize() const {
-  if (const auto *RT =
+  if (auto const *RT =
           getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
     if (RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize())
       return PDIK_Struct;
@@ -2517,7 +2527,7 @@
 }
 
 QualType::PrimitiveCopyKind QualType::isNonTrivialToPrimitiveCopy() const {
-  if (const auto *RT =
+  if (auto const *RT =
           getTypePtr()->getBaseElementTypeUnsafe()->getAs<RecordType>())
     if (RT->getDecl()->isNonTrivialToPrimitiveCopy())
       return PCK_Struct;
@@ -2538,7 +2548,7 @@
   return isNonTrivialToPrimitiveCopy();
 }
 
-bool Type::isLiteralType(const ASTContext &Ctx) const {
+bool Type::isLiteralType(ASTContext const &Ctx) const {
   if (isDependentType())
     return false;
 
@@ -2554,7 +2564,7 @@
   //   -- an array of literal type other than an array of runtime bound; or
   if (isVariableArrayType())
     return false;
-  const Type *BaseTy = getBaseElementTypeUnsafe();
+  Type const *BaseTy = getBaseElementTypeUnsafe();
   assert(BaseTy && "NULL element type");
 
   // Return false for incomplete types after skipping any incomplete array
@@ -2574,7 +2584,7 @@
   if (BaseTy->isReferenceType())
     return true;
   //    -- a class type that has all of the following properties:
-  if (const auto *RT = BaseTy->getAs<RecordType>()) {
+  if (auto const *RT = BaseTy->getAs<RecordType>()) {
     //    -- a trivial destructor,
     //    -- every constructor call and full-expression in the
     //       brace-or-equal-initializers for non-static data members (if any)
@@ -2585,14 +2595,14 @@
     //    -- all non-static data members and base classes of literal types
     //
     // We resolve DR1361 by ignoring the second bullet.
-    if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
+    if (auto const *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
       return ClassDecl->isLiteral();
 
     return true;
   }
 
   // We treat _Atomic T as a literal type if T is a literal type.
-  if (const auto *AT = BaseTy->getAs<AtomicType>())
+  if (auto const *AT = BaseTy->getAs<AtomicType>())
     return AT->getValueType()->isLiteralType(Ctx);
 
   // If this type hasn't been deduced yet, then conservatively assume that
@@ -2614,7 +2624,7 @@
   if (isLValueReferenceType())
     return true;
   //  -- a literal class type [...under some conditions]
-  if (const CXXRecordDecl *RD = getAsCXXRecordDecl())
+  if (CXXRecordDecl const *RD = getAsCXXRecordDecl())
     return RD->isStructural();
   return false;
 }
@@ -2627,7 +2637,7 @@
   //   Scalar types, standard-layout class types, arrays of such types, and
   //   cv-qualified versions of these types are collectively called
   //   standard-layout types.
-  const Type *BaseTy = getBaseElementTypeUnsafe();
+  Type const *BaseTy = getBaseElementTypeUnsafe();
   assert(BaseTy && "NULL element type");
 
   // Return false for incomplete types after skipping any incomplete array
@@ -2636,9 +2646,10 @@
     return false;
 
   // As an extension, Clang treats vector types as Scalar types.
-  if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
-  if (const auto *RT = BaseTy->getAs<RecordType>()) {
-    if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
+  if (BaseTy->isScalarType() || BaseTy->isVectorType())
+    return true;
+  if (auto const *RT = BaseTy->getAs<RecordType>()) {
+    if (auto const *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl()))
       if (!ClassDecl->isStandardLayout())
         return false;
 
@@ -2655,8 +2666,8 @@
 // This is effectively the intersection of isTrivialType and
 // isStandardLayoutType. We implement it directly to avoid redundant
 // conversions from a type to a CXXRecordDecl.
-bool QualType::isCXX11PODType(const ASTContext &Context) const {
-  const Type *ty = getTypePtr();
+bool QualType::isCXX11PODType(ASTContext const &Context) const {
+  Type const *ty = getTypePtr();
   if (ty->isDependentType())
     return false;
 
@@ -2666,7 +2677,7 @@
   // C++11 [basic.types]p9:
   //   Scalar types, POD classes, arrays of such types, and cv-qualified
   //   versions of these types are collectively called trivial types.
-  const Type *BaseTy = ty->getBaseElementTypeUnsafe();
+  Type const *BaseTy = ty->getBaseElementTypeUnsafe();
   assert(BaseTy && "NULL element type");
 
   if (BaseTy->isSizelessBuiltinType())
@@ -2678,17 +2689,20 @@
     return false;
 
   // As an extension, Clang treats vector types as Scalar types.
-  if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
-  if (const auto *RT = BaseTy->getAs<RecordType>()) {
-    if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
+  if (BaseTy->isScalarType() || BaseTy->isVectorType())
+    return true;
+  if (auto const *RT = BaseTy->getAs<RecordType>()) {
+    if (auto const *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
       // C++11 [class]p10:
       //   A POD struct is a non-union class that is both a trivial class [...]
-      if (!ClassDecl->isTrivial()) return false;
+      if (!ClassDecl->isTrivial())
+        return false;
 
       // C++11 [class]p10:
       //   A POD struct is a non-union class that is both a trivial class and
       //   a standard-layout class [...]
-      if (!ClassDecl->isStandardLayout()) return false;
+      if (!ClassDecl->isStandardLayout())
+        return false;
 
       // C++11 [class]p10:
       //   A POD struct is a non-union class that is both a trivial class and
@@ -2708,7 +2722,7 @@
 }
 
 bool Type::isNothrowT() const {
-  if (const auto *RD = getAsCXXRecordDecl()) {
+  if (auto const *RD = getAsCXXRecordDecl()) {
     IdentifierInfo *II = RD->getIdentifier();
     if (II && II->isStr("nothrow_t") && RD->isInStdNamespace())
       return true;
@@ -2717,7 +2731,7 @@
 }
 
 bool Type::isAlignValT() const {
-  if (const auto *ET = getAs<EnumType>()) {
+  if (auto const *ET = getAs<EnumType>()) {
     IdentifierInfo *II = ET->getDecl()->getIdentifier();
     if (II && II->isStr("align_val_t") && ET->getDecl()->isInStdNamespace())
       return true;
@@ -2726,7 +2740,7 @@
 }
 
 bool Type::isStdByteType() const {
-  if (const auto *ET = getAs<EnumType>()) {
+  if (auto const *ET = getAs<EnumType>()) {
     IdentifierInfo *II = ET->getDecl()->getIdentifier();
     if (II && II->isStr("byte") && ET->getDecl()->isInStdNamespace())
       return true;
@@ -2735,7 +2749,7 @@
 }
 
 bool Type::isPromotableIntegerType() const {
-  if (const auto *BT = getAs<BuiltinType>())
+  if (auto const *BT = getAs<BuiltinType>())
     switch (BT->getKind()) {
     case BuiltinType::Bool:
     case BuiltinType::Char_S:
@@ -2756,9 +2770,9 @@
 
   // Enumerated types are promotable to their compatible integer types
   // (C99 6.3.1.1) a.k.a. its underlying type (C++ [conv.prom]p2).
-  if (const auto *ET = getAs<EnumType>()){
-    if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull()
-        || ET->getDecl()->isScoped())
+  if (auto const *ET = getAs<EnumType>()) {
+    if (this->isDependentType() || ET->getDecl()->getPromotionType().isNull() ||
+        ET->getDecl()->isScoped())
       return false;
 
     return true;
@@ -2795,24 +2809,35 @@
 ElaboratedTypeKeyword
 TypeWithKeyword::getKeywordForTypeSpec(unsigned TypeSpec) {
   switch (TypeSpec) {
-  default: return ETK_None;
-  case TST_typename: return ETK_Typename;
-  case TST_class: return ETK_Class;
-  case TST_struct: return ETK_Struct;
-  case TST_interface: return ETK_Interface;
-  case TST_union: return ETK_Union;
-  case TST_enum: return ETK_Enum;
-  }
-}
-
-TagTypeKind
-TypeWithKeyword::getTagTypeKindForTypeSpec(unsigned TypeSpec) {
-  switch(TypeSpec) {
-  case TST_class: return TTK_Class;
-  case TST_struct: return TTK_Struct;
-  case TST_interface: return TTK_Interface;
-  case TST_union: return TTK_Union;
-  case TST_enum: return TTK_Enum;
+  default:
+    return ETK_None;
+  case TST_typename:
+    return ETK_Typename;
+  case TST_class:
+    return ETK_Class;
+  case TST_struct:
+    return ETK_Struct;
+  case TST_interface:
+    return ETK_Interface;
+  case TST_union:
+    return ETK_Union;
+  case TST_enum:
+    return ETK_Enum;
+  }
+}
+
+TagTypeKind TypeWithKeyword::getTagTypeKindForTypeSpec(unsigned TypeSpec) {
+  switch (TypeSpec) {
+  case TST_class:
+    return TTK_Class;
+  case TST_struct:
+    return TTK_Struct;
+  case TST_interface:
+    return TTK_Interface;
+  case TST_union:
+    return TTK_Union;
+  case TST_enum:
+    return TTK_Enum;
   }
 
   llvm_unreachable("Type specifier is not a tag type kind.");
@@ -2821,11 +2846,16 @@
 ElaboratedTypeKeyword
 TypeWithKeyword::getKeywordForTagTypeKind(TagTypeKind Kind) {
   switch (Kind) {
-  case TTK_Class: return ETK_Class;
-  case TTK_Struct: return ETK_Struct;
-  case TTK_Interface: return ETK_Interface;
-  case TTK_Union: return ETK_Union;
-  case TTK_Enum: return ETK_Enum;
+  case TTK_Class:
+    return ETK_Class;
+  case TTK_Struct:
+    return ETK_Struct;
+  case TTK_Interface:
+    return ETK_Interface;
+  case TTK_Union:
+    return ETK_Union;
+  case TTK_Enum:
+    return ETK_Enum;
   }
   llvm_unreachable("Unknown tag type kind.");
 }
@@ -2833,11 +2863,16 @@
 TagTypeKind
 TypeWithKeyword::getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword) {
   switch (Keyword) {
-  case ETK_Class: return TTK_Class;
-  case ETK_Struct: return TTK_Struct;
-  case ETK_Interface: return TTK_Interface;
-  case ETK_Union: return TTK_Union;
-  case ETK_Enum: return TTK_Enum;
+  case ETK_Class:
+    return TTK_Class;
+  case ETK_Struct:
+    return TTK_Struct;
+  case ETK_Interface:
+    return TTK_Interface;
+  case ETK_Union:
+    return TTK_Union;
+  case ETK_Enum:
+    return TTK_Enum;
   case ETK_None: // Fall through.
   case ETK_Typename:
     llvm_unreachable("Elaborated type keyword is not a tag type kind.");
@@ -2845,8 +2880,7 @@
   llvm_unreachable("Unknown elaborated type keyword.");
 }
 
-bool
-TypeWithKeyword::KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword) {
+bool TypeWithKeyword::KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword) {
   switch (Keyword) {
   case ETK_None:
   case ETK_Typename:
@@ -2863,13 +2897,20 @@
 
 StringRef TypeWithKeyword::getKeywordName(ElaboratedTypeKeyword Keyword) {
   switch (Keyword) {
-  case ETK_None: return {};
-  case ETK_Typename: return "typename";
-  case ETK_Class:  return "class";
-  case ETK_Struct: return "struct";
-  case ETK_Interface: return "__interface";
-  case ETK_Union:  return "union";
-  case ETK_Enum:   return "enum";
+  case ETK_None:
+    return {};
+  case ETK_Typename:
+    return "typename";
+  case ETK_Class:
+    return "class";
+  case ETK_Struct:
+    return "struct";
+  case ETK_Interface:
+    return "__interface";
+  case ETK_Union:
+    return "union";
+  case ETK_Enum:
+    return "enum";
   }
 
   llvm_unreachable("Unknown elaborated type keyword.");
@@ -2877,7 +2918,7 @@
 
 DependentTemplateSpecializationType::DependentTemplateSpecializationType(
     ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS,
-    const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args, QualType Canon)
+    IdentifierInfo const *Name, ArrayRef<TemplateArgument> Args, QualType Canon)
     : TypeWithKeyword(Keyword, DependentTemplateSpecialization, Canon,
                       TypeDependence::DependentInstantiation |
                           (NNS ? toTypeDependence(NNS->getDependence())
@@ -2887,7 +2928,7 @@
   assert((!NNS || NNS->isDependent()) &&
          "DependentTemplateSpecializatonType requires dependent qualifier");
   TemplateArgument *ArgBuffer = getArgBuffer();
-  for (const TemplateArgument &Arg : Args) {
+  for (TemplateArgument const &Arg : Args) {
     addDependence(toTypeDependence(Arg.getDependence() &
                                    TemplateArgumentDependence::UnexpandedPack));
 
@@ -2895,27 +2936,24 @@
   }
 }
 
-void
-DependentTemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
-                                             const ASTContext &Context,
-                                             ElaboratedTypeKeyword Keyword,
-                                             NestedNameSpecifier *Qualifier,
-                                             const IdentifierInfo *Name,
-                                             ArrayRef<TemplateArgument> Args) {
+void DependentTemplateSpecializationType::Profile(
+    llvm::FoldingSetNodeID &ID, ASTContext const &Context,
+    ElaboratedTypeKeyword Keyword, NestedNameSpecifier *Qualifier,
+    IdentifierInfo const *Name, ArrayRef<TemplateArgument> Args) {
   ID.AddInteger(Keyword);
   ID.AddPointer(Qualifier);
   ID.AddPointer(Name);
-  for (const TemplateArgument &Arg : Args)
+  for (TemplateArgument const &Arg : Args)
     Arg.Profile(ID, Context);
 }
 
 bool Type::isElaboratedTypeSpecifier() const {
   ElaboratedTypeKeyword Keyword;
-  if (const auto *Elab = dyn_cast<ElaboratedType>(this))
+  if (auto const *Elab = dyn_cast<ElaboratedType>(this))
     Keyword = Elab->getKeyword();
-  else if (const auto *DepName = dyn_cast<DependentNameType>(this))
+  else if (auto const *DepName = dyn_cast<DependentNameType>(this))
     Keyword = DepName->getKeyword();
-  else if (const auto *DepTST =
+  else if (auto const *DepTST =
                dyn_cast<DependentTemplateSpecializationType>(this))
     Keyword = DepTST->getKeyword();
   else
@@ -2924,17 +2962,19 @@
   return TypeWithKeyword::KeywordIsTagTypeKind(Keyword);
 }
 
-const char *Type::getTypeClassName() const {
+char const *Type::getTypeClassName() const {
   switch (TypeBits.TC) {
 #define ABSTRACT_TYPE(Derived, Base)
-#define TYPE(Derived, Base) case Derived: return #Derived;
+#define TYPE(Derived, Base)                                                    \
+  case Derived:                                                                \
+    return #Derived;
 #include "clang/AST/TypeNodes.inc"
   }
 
   llvm_unreachable("Invalid type class.");
 }
 
-StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
+StringRef BuiltinType::getName(PrintingPolicy const &Policy) const {
   switch (getKind()) {
   case Void:
     return "void";
@@ -3063,8 +3103,8 @@
     return "Class";
   case ObjCSel:
     return "SEL";
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-  case Id: \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
+  case Id:                                                                     \
     return "__" #Access " " #ImgType "_t";
 #include "clang/Basic/OpenCLImageTypes.def"
   case OCLSampler:
@@ -3085,16 +3125,16 @@
     return "<OpenMP array shaping type>";
   case OMPIterator:
     return "<OpenMP iterator type>";
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-  case Id: \
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext)                                      \
+  case Id:                                                                     \
     return #ExtType;
 #include "clang/Basic/OpenCLExtensionTypes.def"
-#define SVE_TYPE(Name, Id, SingletonId) \
-  case Id: \
+#define SVE_TYPE(Name, Id, SingletonId)                                        \
+  case Id:                                                                     \
     return Name;
 #include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-  case Id: \
+#define PPC_VECTOR_TYPE(Name, Id, Size)                                        \
+  case Id:                                                                     \
     return #Name;
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId)                                        \
@@ -3113,8 +3153,8 @@
   return *this;
 }
 
-QualType QualType::getNonLValueExprType(const ASTContext &Context) const {
-  if (const auto *RefType = getTypePtr()->getAs<ReferenceType>())
+QualType QualType::getNonLValueExprType(ASTContext const &Context) const {
+  if (auto const *RefType = getTypePtr()->getAs<ReferenceType>())
     return RefType->getPointeeType();
 
   // C++0x [basic.lval]:
@@ -3131,25 +3171,44 @@
 
 StringRef FunctionType::getNameForCallConv(CallingConv CC) {
   switch (CC) {
-  case CC_C: return "cdecl";
-  case CC_X86StdCall: return "stdcall";
-  case CC_X86FastCall: return "fastcall";
-  case CC_X86ThisCall: return "thiscall";
-  case CC_X86Pascal: return "pascal";
-  case CC_X86VectorCall: return "vectorcall";
-  case CC_Win64: return "ms_abi";
-  case CC_X86_64SysV: return "sysv_abi";
-  case CC_X86RegCall : return "regcall";
-  case CC_AAPCS: return "aapcs";
-  case CC_AAPCS_VFP: return "aapcs-vfp";
-  case CC_AArch64VectorCall: return "aarch64_vector_pcs";
-  case CC_IntelOclBicc: return "intel_ocl_bicc";
-  case CC_SpirFunction: return "spir_function";
-  case CC_OpenCLKernel: return "opencl_kernel";
-  case CC_Swift: return "swiftcall";
-  case CC_SwiftAsync: return "swiftasynccall";
-  case CC_PreserveMost: return "preserve_most";
-  case CC_PreserveAll: return "preserve_all";
+  case CC_C:
+    return "cdecl";
+  case CC_X86StdCall:
+    return "stdcall";
+  case CC_X86FastCall:
+    return "fastcall";
+  case CC_X86ThisCall:
+    return "thiscall";
+  case CC_X86Pascal:
+    return "pascal";
+  case CC_X86VectorCall:
+    return "vectorcall";
+  case CC_Win64:
+    return "ms_abi";
+  case CC_X86_64SysV:
+    return "sysv_abi";
+  case CC_X86RegCall:
+    return "regcall";
+  case CC_AAPCS:
+    return "aapcs";
+  case CC_AAPCS_VFP:
+    return "aapcs-vfp";
+  case CC_AArch64VectorCall:
+    return "aarch64_vector_pcs";
+  case CC_IntelOclBicc:
+    return "intel_ocl_bicc";
+  case CC_SpirFunction:
+    return "spir_function";
+  case CC_OpenCLKernel:
+    return "opencl_kernel";
+  case CC_Swift:
+    return "swiftcall";
+  case CC_SwiftAsync:
+    return "swiftasynccall";
+  case CC_PreserveMost:
+    return "preserve_most";
+  case CC_PreserveAll:
+    return "preserve_all";
   }
 
   llvm_unreachable("Invalid calling convention.");
@@ -3157,7 +3216,7 @@
 
 FunctionProtoType::FunctionProtoType(QualType result, ArrayRef<QualType> params,
                                      QualType canonical,
-                                     const ExtProtoInfo &epi)
+                                     ExtProtoInfo const &epi)
     : FunctionType(FunctionProto, result, canonical, result->getDependence(),
                    epi.ExtInfo) {
   FunctionTypeBits.FastTypeQuals = epi.TypeQuals.getFastQualifiers();
@@ -3326,9 +3385,9 @@
 }
 
 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result,
-                                const QualType *ArgTys, unsigned NumParams,
-                                const ExtProtoInfo &epi,
-                                const ASTContext &Context, bool Canonical) {
+                                QualType const *ArgTys, unsigned NumParams,
+                                ExtProtoInfo const &epi,
+                                ASTContext const &Context, bool Canonical) {
   // We have to be careful not to get ambiguous profile encodings.
   // Note that valid type pointers are never ambiguous with anything else.
   //
@@ -3352,12 +3411,10 @@
   // This method is relatively performance sensitive, so as a performance
   // shortcut, use one AddInteger call instead of four for the next four
   // fields.
-  assert(!(unsigned(epi.Variadic) & ~1) &&
-         !(unsigned(epi.RefQualifier) & ~3) &&
+  assert(!(unsigned(epi.Variadic) & ~1) && !(unsigned(epi.RefQualifier) & ~3) &&
          !(unsigned(epi.ExceptionSpec.Type) & ~15) &&
          "Values larger than expected.");
-  ID.AddInteger(unsigned(epi.Variadic) +
-                (epi.RefQualifier << 1) +
+  ID.AddInteger(unsigned(epi.Variadic) + (epi.RefQualifier << 1) +
                 (epi.ExceptionSpec.Type << 3));
   ID.Add(epi.TypeQuals);
   if (epi.ExceptionSpec.Type == EST_Dynamic) {
@@ -3378,21 +3435,19 @@
 }
 
 void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID,
-                                const ASTContext &Ctx) {
+                                ASTContext const &Ctx) {
   Profile(ID, getReturnType(), param_type_begin(), getNumParams(),
           getExtProtoInfo(), Ctx, isCanonicalUnqualified());
 }
 
-TypedefType::TypedefType(TypeClass tc, const TypedefNameDecl *D,
+TypedefType::TypedefType(TypeClass tc, TypedefNameDecl const *D,
                          QualType underlying, QualType can)
     : Type(tc, can, underlying->getDependence()),
       Decl(const_cast<TypedefNameDecl *>(D)) {
   assert(!isa<TypedefType>(can) && "Invalid canonical type");
 }
 
-QualType TypedefType::desugar() const {
-  return getDecl()->getUnderlyingType();
-}
+QualType TypedefType::desugar() const { return getDecl()->getUnderlyingType(); }
 
 QualType MacroQualifiedType::desugar() const { return getUnderlyingType(); }
 
@@ -3415,9 +3470,7 @@
                 TypeDependence::VariablyModified)),
       TOExpr(E) {}
 
-bool TypeOfExprType::isSugared() const {
-  return !TOExpr->isTypeDependent();
-}
+bool TypeOfExprType::isSugared() const { return !TOExpr->isTypeDependent(); }
 
 QualType TypeOfExprType::desugar() const {
   if (isSugared())
@@ -3427,7 +3480,7 @@
 }
 
 void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
-                                      const ASTContext &Context, Expr *E) {
+                                      ASTContext const &Context, Expr *E) {
   E->Profile(ID, Context, true);
 }
 
@@ -3452,11 +3505,11 @@
   return QualType(this, 0);
 }
 
-DependentDecltypeType::DependentDecltypeType(const ASTContext &Context, Expr *E)
+DependentDecltypeType::DependentDecltypeType(ASTContext const &Context, Expr *E)
     : DecltypeType(E, Context.DependentTy), Context(Context) {}
 
 void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
-                                    const ASTContext &Context, Expr *E) {
+                                    ASTContext const &Context, Expr *E) {
   E->Profile(ID, Context, true);
 }
 
@@ -3466,12 +3519,12 @@
     : Type(UnaryTransform, CanonicalType, BaseType->getDependence()),
       BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) {}
 
-DependentUnaryTransformType::DependentUnaryTransformType(const ASTContext &C,
+DependentUnaryTransformType::DependentUnaryTransformType(ASTContext const &C,
                                                          QualType BaseType,
                                                          UTTKind UKind)
-     : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) {}
+    : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) {}
 
-TagType::TagType(TypeClass TC, const TagDecl *D, QualType can)
+TagType::TagType(TypeClass TC, TagDecl const *D, QualType can)
     : Type(TC, can,
            D->isDependentType() ? TypeDependence::DependentInstantiation
                                 : TypeDependence::None),
@@ -3486,16 +3539,12 @@
   return decl;
 }
 
-TagDecl *TagType::getDecl() const {
-  return getInterestingTagDecl(decl);
-}
+TagDecl *TagType::getDecl() const { return getInterestingTagDecl(decl); }
 
-bool TagType::isBeingDefined() const {
-  return getDecl()->isBeingDefined();
-}
+bool TagType::isBeingDefined() const { return getDecl()->isBeingDefined(); }
 
 bool RecordType::hasConstFields() const {
-  std::vector<const RecordType*> RecordTypeList;
+  std::vector<RecordType const *> RecordTypeList;
   RecordTypeList.push_back(this);
   unsigned NextToCheckIndex = 0;
 
@@ -3506,7 +3555,7 @@
       if (FieldTy.isConstQualified())
         return true;
       FieldTy = FieldTy.getCanonicalType();
-      if (const auto *FieldRecTy = FieldTy->getAs<RecordType>()) {
+      if (auto const *FieldRecTy = FieldTy->getAs<RecordType>()) {
         if (llvm::find(RecordTypeList, FieldRecTy) == RecordTypeList.end())
           RecordTypeList.push_back(FieldRecTy);
       }
@@ -3543,7 +3592,8 @@
 bool AttributedType::isMSTypeSpec() const {
   // FIXME: Generate this with TableGen?
   switch (getAttrKind()) {
-  default: return false;
+  default:
+    return false;
   case attr::Ptr32:
   case attr::Ptr64:
   case attr::SPtr:
@@ -3556,7 +3606,8 @@
 bool AttributedType::isCallingConv() const {
   // FIXME: Generate this with TableGen.
   switch (getAttrKind()) {
-  default: return false;
+  default:
+    return false;
   case attr::Pcs:
   case attr::CDecl:
   case attr::FastCall:
@@ -3587,8 +3638,8 @@
 }
 
 SubstTemplateTypeParmPackType::SubstTemplateTypeParmPackType(
-    const TemplateTypeParmType *Param, QualType Canon,
-    const TemplateArgument &ArgPack)
+    TemplateTypeParmType const *Param, QualType Canon,
+    TemplateArgument const &ArgPack)
     : Type(SubstTemplateTypeParmPack, Canon,
            TypeDependence::DependentInstantiation |
                TypeDependence::UnexpandedPack),
@@ -3604,31 +3655,32 @@
   Profile(ID, getReplacedParameter(), getArgumentPack());
 }
 
-void SubstTemplateTypeParmPackType::Profile(llvm::FoldingSetNodeID &ID,
-                                           const TemplateTypeParmType *Replaced,
-                                            const TemplateArgument &ArgPack) {
+void SubstTemplateTypeParmPackType::Profile(
+    llvm::FoldingSetNodeID &ID, TemplateTypeParmType const *Replaced,
+    TemplateArgument const &ArgPack) {
   ID.AddPointer(Replaced);
   ID.AddInteger(ArgPack.pack_size());
-  for (const auto &P : ArgPack.pack_elements())
+  for (auto const &P : ArgPack.pack_elements())
     ID.AddPointer(P.getAsType().getAsOpaquePtr());
 }
 
 bool TemplateSpecializationType::anyDependentTemplateArguments(
-    const TemplateArgumentListInfo &Args, ArrayRef<TemplateArgument> Converted) {
+    TemplateArgumentListInfo const &Args,
+    ArrayRef<TemplateArgument> Converted) {
   return anyDependentTemplateArguments(Args.arguments(), Converted);
 }
 
 bool TemplateSpecializationType::anyDependentTemplateArguments(
     ArrayRef<TemplateArgumentLoc> Args, ArrayRef<TemplateArgument> Converted) {
-  for (const TemplateArgument &Arg : Converted)
+  for (TemplateArgument const &Arg : Converted)
     if (Arg.isDependent())
       return true;
   return false;
 }
 
 bool TemplateSpecializationType::anyInstantiationDependentTemplateArguments(
-      ArrayRef<TemplateArgumentLoc> Args) {
-  for (const TemplateArgumentLoc &ArgLoc : Args) {
+    ArrayRef<TemplateArgumentLoc> Args) {
+  for (TemplateArgumentLoc const &ArgLoc : Args) {
     if (ArgLoc.getArgument().isInstantiationDependent())
       return true;
   }
@@ -3657,7 +3709,7 @@
          "Unexpected template name for TemplateSpecializationType");
 
   auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
-  for (const TemplateArgument &Arg : Args) {
+  for (TemplateArgument const &Arg : Args) {
     // Update instantiation-dependent, variably-modified, and error bits.
     // If the canonical type exists and is non-dependent, the template
     // specialization type can be non-dependent even if one of the type
@@ -3677,38 +3729,36 @@
   // Store the aliased type if this is a type alias template specialization.
   if (isTypeAlias()) {
     auto *Begin = reinterpret_cast<TemplateArgument *>(this + 1);
-    *reinterpret_cast<QualType*>(Begin + getNumArgs()) = AliasedType;
+    *reinterpret_cast<QualType *>(Begin + getNumArgs()) = AliasedType;
   }
 }
 
-void
-TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
-                                    TemplateName T,
-                                    ArrayRef<TemplateArgument> Args,
-                                    const ASTContext &Context) {
+void TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID,
+                                         TemplateName T,
+                                         ArrayRef<TemplateArgument> Args,
+                                         ASTContext const &Context) {
   T.Profile(ID);
-  for (const TemplateArgument &Arg : Args)
+  for (TemplateArgument const &Arg : Args)
     Arg.Profile(ID, Context);
 }
 
-QualType
-QualifierCollector::apply(const ASTContext &Context, QualType QT) const {
+QualType QualifierCollector::apply(ASTContext const &Context,
+                                   QualType QT) const {
   if (!hasNonFastQualifiers())
     return QT.withFastQualifiers(getFastQualifiers());
 
   return Context.getQualifiedType(QT, *this);
 }
 
-QualType
-QualifierCollector::apply(const ASTContext &Context, const Type *T) const {
+QualType QualifierCollector::apply(ASTContext const &Context,
+                                   Type const *T) const {
   if (!hasNonFastQualifiers())
     return QualType(T, getFastQualifiers());
 
   return Context.getQualifiedType(T, *this);
 }
 
-void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
-                                 QualType BaseType,
+void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
                                  ArrayRef<QualType> typeArgs,
                                  ArrayRef<ObjCProtocolDecl *> protocols,
                                  bool isKindOf) {
@@ -3729,7 +3779,7 @@
 }
 
 void ObjCTypeParamType::Profile(llvm::FoldingSetNodeID &ID,
-                                const ObjCTypeParamDecl *OTPDecl,
+                                ObjCTypeParamDecl const *OTPDecl,
                                 QualType CanonicalType,
                                 ArrayRef<ObjCProtocolDecl *> protocols) {
   ID.AddPointer(OTPDecl);
@@ -3759,14 +3809,14 @@
 
   friend CachedProperties merge(CachedProperties L, CachedProperties R) {
     Linkage MergedLinkage = minLinkage(L.L, R.L);
-    return CachedProperties(MergedLinkage,
-                         L.hasLocalOrUnnamedType() | R.hasLocalOrUnnamedType());
+    return CachedProperties(MergedLinkage, L.hasLocalOrUnnamedType() |
+                                               R.hasLocalOrUnnamedType());
   }
 };
 
 } // namespace
 
-static CachedProperties computeCachedProperties(const Type *T);
+static CachedProperties computeCachedProperties(Type const *T);
 
 namespace clang {
 
@@ -3775,24 +3825,23 @@
 /// leakage.
 template <class Private> class TypePropertyCache {
 public:
-  static CachedProperties get(QualType T) {
-    return get(T.getTypePtr());
-  }
+  static CachedProperties get(QualType T) { return get(T.getTypePtr()); }
 
-  static CachedProperties get(const Type *T) {
+  static CachedProperties get(Type const *T) {
     ensure(T);
     return CachedProperties(T->TypeBits.getLinkage(),
                             T->TypeBits.hasLocalOrUnnamedType());
   }
 
-  static void ensure(const Type *T) {
+  static void ensure(Type const *T) {
     // If the cache is valid, we're okay.
-    if (T->TypeBits.isCacheValid()) return;
+    if (T->TypeBits.isCacheValid())
+      return;
 
     // If this type is non-canonical, ask its canonical type for the
     // relevant information.
     if (!T->isCanonicalUnqualified()) {
-      const Type *CT = T->getCanonicalTypeInternal().getTypePtr();
+      Type const *CT = T->getCanonicalTypeInternal().getTypePtr();
       ensure(CT);
       T->TypeBits.CacheValid = true;
       T->TypeBits.CachedLinkage = CT->TypeBits.CachedLinkage;
@@ -3821,19 +3870,20 @@
 
 using Cache = TypePropertyCache<Private>;
 
-static CachedProperties computeCachedProperties(const Type *T) {
+static CachedProperties computeCachedProperties(Type const *T) {
   switch (T->getTypeClass()) {
-#define TYPE(Class,Base)
-#define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
+#define TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
 #include "clang/AST/TypeNodes.inc"
     llvm_unreachable("didn't expect a non-canonical type here");
 
-#define TYPE(Class,Base)
-#define DEPENDENT_TYPE(Class,Base) case Type::Class:
-#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
+#define TYPE(Class, Base)
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
 #include "clang/AST/TypeNodes.inc"
     // Treat instantiation-dependent types as external.
-    if (!T->isInstantiationDependentType()) T->dump();
+    if (!T->isInstantiationDependentType())
+      T->dump();
     assert(T->isInstantiationDependentType());
     return CachedProperties(ExternalLinkage, false);
 
@@ -3852,16 +3902,15 @@
 
   case Type::Record:
   case Type::Enum: {
-    const TagDecl *Tag = cast<TagType>(T)->getDecl();
+    TagDecl const *Tag = cast<TagType>(T)->getDecl();
 
     // C++ [basic.link]p8:
     //     - it is a class or enumeration type that is named (or has a name
     //       for linkage purposes (7.1.3)) and the name has linkage; or
     //     -  it is a specialization of a class template (14); or
     Linkage L = Tag->getLinkageInternal();
-    bool IsLocalOrUnnamed =
-      Tag->getDeclContext()->isFunctionOrMethod() ||
-      !Tag->hasNameForLinkage();
+    bool IsLocalOrUnnamed = Tag->getDeclContext()->isFunctionOrMethod() ||
+                            !Tag->hasNameForLinkage();
     return CachedProperties(L, IsLocalOrUnnamed);
   }
 
@@ -3878,7 +3927,7 @@
   case Type::RValueReference:
     return Cache::get(cast<ReferenceType>(T)->getPointeeType());
   case Type::MemberPointer: {
-    const auto *MPT = cast<MemberPointerType>(T);
+    auto const *MPT = cast<MemberPointerType>(T);
     return merge(Cache::get(MPT->getClass()),
                  Cache::get(MPT->getPointeeType()));
   }
@@ -3894,9 +3943,9 @@
   case Type::FunctionNoProto:
     return Cache::get(cast<FunctionType>(T)->getReturnType());
   case Type::FunctionProto: {
-    const auto *FPT = cast<FunctionProtoType>(T);
+    auto const *FPT = cast<FunctionProtoType>(T);
     CachedProperties result = Cache::get(FPT->getReturnType());
-    for (const auto &ai : FPT->param_types())
+    for (auto const &ai : FPT->param_types())
       result = merge(result, Cache::get(ai));
     return result;
   }
@@ -3928,16 +3977,16 @@
   return TypeBits.hasLocalOrUnnamedType();
 }
 
-LinkageInfo LinkageComputer::computeTypeLinkageInfo(const Type *T) {
+LinkageInfo LinkageComputer::computeTypeLinkageInfo(Type const *T) {
   switch (T->getTypeClass()) {
-#define TYPE(Class,Base)
-#define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
+#define TYPE(Class, Base)
+#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
 #include "clang/AST/TypeNodes.inc"
     llvm_unreachable("didn't expect a non-canonical type here");
 
-#define TYPE(Class,Base)
-#define DEPENDENT_TYPE(Class,Base) case Type::Class:
-#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
+#define TYPE(Class, Base)
+#define DEPENDENT_TYPE(Class, Base) case Type::Class:
+#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
 #include "clang/AST/TypeNodes.inc"
     // Treat instantiation-dependent types as external.
     assert(T->isInstantiationDependentType());
@@ -3965,7 +4014,7 @@
   case Type::RValueReference:
     return computeTypeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
   case Type::MemberPointer: {
-    const auto *MPT = cast<MemberPointerType>(T);
+    auto const *MPT = cast<MemberPointerType>(T);
     LinkageInfo LV = computeTypeLinkageInfo(MPT->getClass());
     LV.merge(computeTypeLinkageInfo(MPT->getPointeeType()));
     return LV;
@@ -3983,9 +4032,9 @@
   case Type::FunctionNoProto:
     return computeTypeLinkageInfo(cast<FunctionType>(T)->getReturnType());
   case Type::FunctionProto: {
-    const auto *FPT = cast<FunctionProtoType>(T);
+    auto const *FPT = cast<FunctionProtoType>(T);
     LinkageInfo LV = computeTypeLinkageInfo(FPT->getReturnType());
-    for (const auto &ai : FPT->param_types())
+    for (auto const &ai : FPT->param_types())
       LV.merge(computeTypeLinkageInfo(ai));
     return LV;
   }
@@ -4015,7 +4064,7 @@
   return L == TypeBits.getLinkage();
 }
 
-LinkageInfo LinkageComputer::getTypeLinkageAndVisibility(const Type *T) {
+LinkageInfo LinkageComputer::getTypeLinkageAndVisibility(Type const *T) {
   if (!T->isCanonicalUnqualified())
     return computeTypeLinkageInfo(T->getCanonicalTypeInternal());
 
@@ -4029,9 +4078,9 @@
 }
 
 Optional<NullabilityKind>
-Type::getNullability(const ASTContext &Context) const {
+Type::getNullability(ASTContext const &Context) const {
   QualType Type(this, 0);
-  while (const auto *AT = Type->getAs<AttributedType>()) {
+  while (auto const *AT = Type->getAs<AttributedType>()) {
     // Check whether this is an attributed type with nullability
     // information.
     if (auto Nullability = AT->getImmediateNullability())
@@ -4046,9 +4095,9 @@
   QualType type = getCanonicalTypeInternal();
 
   switch (type->getTypeClass()) {
-  // We'll only see canonical types here.
-#define NON_CANONICAL_TYPE(Class, Parent)       \
-  case Type::Class:                             \
+    // We'll only see canonical types here.
+#define NON_CANONICAL_TYPE(Class, Parent)                                      \
+  case Type::Class:                                                            \
     llvm_unreachable("non-canonical type");
 #define TYPE(Class, Parent)
 #include "clang/AST/TypeNodes.inc"
@@ -4077,9 +4126,10 @@
   // types unless they're known to be specializations of a class
   // template.
   case Type::TemplateSpecialization:
-    if (TemplateDecl *templateDecl
-          = cast<TemplateSpecializationType>(type.getTypePtr())
-              ->getTemplateName().getAsTemplateDecl()) {
+    if (TemplateDecl *templateDecl =
+            cast<TemplateSpecializationType>(type.getTypePtr())
+                ->getTemplateName()
+                .getAsTemplateDecl()) {
       if (isa<ClassTemplateDecl>(templateDecl))
         return false;
     }
@@ -4108,22 +4158,19 @@
     case BuiltinType::ObjCId:
     case BuiltinType::ObjCClass:
     case BuiltinType::ObjCSel:
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
-    case BuiltinType::Id:
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
+  case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-    case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
 #include "clang/Basic/OpenCLExtensionTypes.def"
     case BuiltinType::OCLSampler:
     case BuiltinType::OCLEvent:
     case BuiltinType::OCLClkEvent:
     case BuiltinType::OCLQueue:
     case BuiltinType::OCLReserveID:
-#define SVE_TYPE(Name, Id, SingletonId) \
-    case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-    case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
@@ -4199,7 +4246,7 @@
 }
 
 bool Type::isBlockCompatibleObjCPointerType(ASTContext &ctx) const {
-  const auto *objcPtr = getAs<ObjCObjectPointerType>();
+  auto const *objcPtr = getAs<ObjCObjectPointerType>();
   if (!objcPtr)
     return false;
 
@@ -4241,13 +4288,13 @@
   assert(isObjCLifetimeType() &&
          "cannot query implicit lifetime for non-inferrable type");
 
-  const Type *canon = getCanonicalTypeInternal().getTypePtr();
+  Type const *canon = getCanonicalTypeInternal().getTypePtr();
 
   // Walk down to the base type.  We don't care about qualifiers for this.
-  while (const auto *array = dyn_cast<ArrayType>(canon))
+  while (auto const *array = dyn_cast<ArrayType>(canon))
     canon = array->getElementType().getTypePtr();
 
-  if (const auto *opt = dyn_cast<ObjCObjectPointerType>(canon)) {
+  if (auto const *opt = dyn_cast<ObjCObjectPointerType>(canon)) {
     // Class and Class<Protocol> don't require retention.
     if (opt->getObjectType()->isObjCClass())
       return true;
@@ -4257,38 +4304,38 @@
 }
 
 bool Type::isObjCNSObjectType() const {
-  const Type *cur = this;
+  Type const *cur = this;
   while (true) {
-    if (const auto *typedefType = dyn_cast<TypedefType>(cur))
+    if (auto const *typedefType = dyn_cast<TypedefType>(cur))
       return typedefType->getDecl()->hasAttr<ObjCNSObjectAttr>();
 
     // Single-step desugar until we run out of sugar.
     QualType next = cur->getLocallyUnqualifiedSingleStepDesugaredType();
-    if (next.getTypePtr() == cur) return false;
+    if (next.getTypePtr() == cur)
+      return false;
     cur = next.getTypePtr();
   }
 }
 
 bool Type::isObjCIndependentClassType() const {
-  if (const auto *typedefType = dyn_cast<TypedefType>(this))
+  if (auto const *typedefType = dyn_cast<TypedefType>(this))
     return typedefType->getDecl()->hasAttr<ObjCIndependentClassAttr>();
   return false;
 }
 
 bool Type::isObjCRetainableType() const {
-  return isObjCObjectPointerType() ||
-         isBlockPointerType() ||
+  return isObjCObjectPointerType() || isBlockPointerType() ||
          isObjCNSObjectType();
 }
 
 bool Type::isObjCIndirectLifetimeType() const {
   if (isObjCLifetimeType())
     return true;
-  if (const auto *OPT = getAs<PointerType>())
+  if (auto const *OPT = getAs<PointerType>())
     return OPT->getPointeeType()->isObjCIndirectLifetimeType();
-  if (const auto *Ref = getAs<ReferenceType>())
+  if (auto const *Ref = getAs<ReferenceType>())
     return Ref->getPointeeType()->isObjCIndirectLifetimeType();
-  if (const auto *MemPtr = getAs<MemberPointerType>())
+  if (auto const *MemPtr = getAs<MemberPointerType>())
     return MemPtr->getPointeeType()->isObjCIndirectLifetimeType();
   return false;
 }
@@ -4296,8 +4343,8 @@
 /// Returns true if objects of this type have lifetime semantics under
 /// ARC.
 bool Type::isObjCLifetimeType() const {
-  const Type *type = this;
-  while (const ArrayType *array = type->getAsArrayTypeUnsafe())
+  Type const *type = this;
+  while (ArrayType const *array = type->getAsArrayTypeUnsafe())
     type = array->getElementType().getTypePtr();
   return type->isObjCRetainableType();
 }
@@ -4310,7 +4357,7 @@
 
 /// Determine whether the given type T is a "bridgeable" C type.
 bool Type::isCARCBridgableType() const {
-  const auto *Pointer = getAs<PointerType>();
+  auto const *Pointer = getAs<PointerType>();
   if (!Pointer)
     return false;
 
@@ -4320,26 +4367,27 @@
 
 /// Check if the specified type is the CUDA device builtin surface type.
 bool Type::isCUDADeviceBuiltinSurfaceType() const {
-  if (const auto *RT = getAs<RecordType>())
+  if (auto const *RT = getAs<RecordType>())
     return RT->getDecl()->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>();
   return false;
 }
 
 /// Check if the specified type is the CUDA device builtin texture type.
 bool Type::isCUDADeviceBuiltinTextureType() const {
-  if (const auto *RT = getAs<RecordType>())
+  if (auto const *RT = getAs<RecordType>())
     return RT->getDecl()->hasAttr<CUDADeviceBuiltinTextureTypeAttr>();
   return false;
 }
 
 bool Type::hasSizedVLAType() const {
-  if (!isVariablyModifiedType()) return false;
+  if (!isVariablyModifiedType())
+    return false;
 
-  if (const auto *ptr = getAs<PointerType>())
+  if (auto const *ptr = getAs<PointerType>())
     return ptr->getPointeeType()->hasSizedVLAType();
-  if (const auto *ref = getAs<ReferenceType>())
+  if (auto const *ref = getAs<ReferenceType>())
     return ref->getPointeeType()->hasSizedVLAType();
-  if (const ArrayType *arr = getAsArrayTypeUnsafe()) {
+  if (ArrayType const *arr = getAsArrayTypeUnsafe()) {
     if (isa<VariableArrayType>(arr) &&
         cast<VariableArrayType>(arr)->getSizeExpr())
       return true;
@@ -4363,10 +4411,9 @@
     return DK_objc_weak_lifetime;
   }
 
-  if (const auto *RT =
-          type->getBaseElementTypeUnsafe()->getAs<RecordType>()) {
-    const RecordDecl *RD = RT->getDecl();
-    if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
+  if (auto const *RT = type->getBaseElementTypeUnsafe()->getAs<RecordType>()) {
+    RecordDecl const *RD = RT->getDecl();
+    if (auto const *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
       /// Check if this is a C++ object with a non-trivial destructor.
       if (CXXRD->hasDefinition() && !CXXRD->hasTrivialDestructor())
         return DK_cxx_destructor;
@@ -4403,7 +4450,7 @@
   this->TypeConstraintConcept = TypeConstraintConcept;
   if (TypeConstraintConcept) {
     TemplateArgument *ArgBuffer = getArgBuffer();
-    for (const TemplateArgument &Arg : TypeConstraintArgs) {
+    for (TemplateArgument const &Arg : TypeConstraintArgs) {
       addDependence(
           toSyntacticDependence(toTypeDependence(Arg.getDependence())));
 
@@ -4412,14 +4459,14 @@
   }
 }
 
-void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
-                      QualType Deduced, AutoTypeKeyword Keyword,
-                      bool IsDependent, ConceptDecl *CD,
-                      ArrayRef<TemplateArgument> Arguments) {
+void AutoType::Profile(llvm::FoldingSetNodeID &ID, ASTContext const &Context,
+                       QualType Deduced, AutoTypeKeyword Keyword,
+                       bool IsDependent, ConceptDecl *CD,
+                       ArrayRef<TemplateArgument> Arguments) {
   ID.AddPointer(Deduced.getAsOpaquePtr());
   ID.AddInteger((unsigned)Keyword);
   ID.AddBoolean(IsDependent);
   ID.AddPointer(CD);
-  for (const TemplateArgument &Arg : Arguments)
+  for (TemplateArgument const &Arg : Arguments)
     Arg.Profile(ID, Context);
 }
Index: clang/lib/AST/TypeLoc.cpp
===================================================================
--- clang/lib/AST/TypeLoc.cpp
+++ clang/lib/AST/TypeLoc.cpp
@@ -11,9 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/TypeLoc.h"
-#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
+#include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/TemplateBase.h"
@@ -30,7 +30,7 @@
 
 using namespace clang;
 
-static const unsigned TypeLocMaxDataAlign = alignof(void *);
+static unsigned const TypeLocMaxDataAlign = alignof(void *);
 
 //===----------------------------------------------------------------------===//
 // TypeLoc Implementation
@@ -41,9 +41,9 @@
 class TypeLocRanger : public TypeLocVisitor<TypeLocRanger, SourceRange> {
 public:
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
-#define TYPELOC(CLASS, PARENT) \
-  SourceRange Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
-    return TyLoc.getLocalSourceRange(); \
+#define TYPELOC(CLASS, PARENT)                                                 \
+  SourceRange Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) {                    \
+    return TyLoc.getLocalSourceRange();                                        \
   }
 #include "clang/AST/TypeLocNodes.def"
 };
@@ -51,7 +51,8 @@
 } // namespace
 
 SourceRange TypeLoc::getLocalSourceRangeImpl(TypeLoc TL) {
-  if (TL.isNull()) return SourceRange();
+  if (TL.isNull())
+    return SourceRange();
   return TypeLocRanger().Visit(TL);
 }
 
@@ -60,9 +61,9 @@
 class TypeAligner : public TypeLocVisitor<TypeAligner, unsigned> {
 public:
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
-#define TYPELOC(CLASS, PARENT) \
-  unsigned Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
-    return TyLoc.getLocalDataAlignment(); \
+#define TYPELOC(CLASS, PARENT)                                                 \
+  unsigned Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) {                       \
+    return TyLoc.getLocalDataAlignment();                                      \
   }
 #include "clang/AST/TypeLocNodes.def"
 };
@@ -71,7 +72,8 @@
 
 /// Returns the alignment of the type source info data block.
 unsigned TypeLoc::getLocalAlignmentForType(QualType Ty) {
-  if (Ty.isNull()) return 1;
+  if (Ty.isNull())
+    return 1;
   return TypeAligner().Visit(TypeLoc(Ty, nullptr));
 }
 
@@ -80,9 +82,9 @@
 class TypeSizer : public TypeLocVisitor<TypeSizer, unsigned> {
 public:
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
-#define TYPELOC(CLASS, PARENT) \
-  unsigned Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
-    return TyLoc.getLocalDataSize(); \
+#define TYPELOC(CLASS, PARENT)                                                 \
+  unsigned Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) {                       \
+    return TyLoc.getLocalDataSize();                                           \
   }
 #include "clang/AST/TypeLocNodes.def"
 };
@@ -110,9 +112,9 @@
 class NextLoc : public TypeLocVisitor<NextLoc, TypeLoc> {
 public:
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
-#define TYPELOC(CLASS, PARENT) \
-  TypeLoc Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
-    return TyLoc.getNextTypeLoc(); \
+#define TYPELOC(CLASS, PARENT)                                                 \
+  TypeLoc Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) {                        \
+    return TyLoc.getNextTypeLoc();                                             \
   }
 #include "clang/AST/TypeLocNodes.def"
 };
@@ -121,9 +123,7 @@
 
 /// Get the next TypeLoc pointed by this TypeLoc, e.g for "int*" the
 /// TypeLoc is a PointerLoc and next TypeLoc is for "int".
-TypeLoc TypeLoc::getNextTypeLocImpl(TypeLoc TL) {
-  return NextLoc().Visit(TL);
-}
+TypeLoc TypeLoc::getNextTypeLocImpl(TypeLoc TL) { return NextLoc().Visit(TL); }
 
 /// Initializes a type location, and all of its children
 /// recursively, as if the entire tree had been written in the
@@ -133,14 +133,15 @@
   while (true) {
     switch (TL.getTypeLocClass()) {
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
-#define TYPELOC(CLASS, PARENT)        \
-    case CLASS: {                     \
-      CLASS##TypeLoc TLCasted = TL.castAs<CLASS##TypeLoc>(); \
-      TLCasted.initializeLocal(Context, Loc);  \
-      TL = TLCasted.getNextTypeLoc(); \
-      if (!TL) return;                \
-      continue;                       \
-    }
+#define TYPELOC(CLASS, PARENT)                                                 \
+  case CLASS: {                                                                \
+    CLASS##TypeLoc TLCasted = TL.castAs<CLASS##TypeLoc>();                     \
+    TLCasted.initializeLocal(Context, Loc);                                    \
+    TL = TLCasted.getNextTypeLoc();                                            \
+    if (!TL)                                                                   \
+      return;                                                                  \
+    continue;                                                                  \
+  }
 #include "clang/AST/TypeLocNodes.def"
     }
   }
@@ -155,9 +156,9 @@
   TypeLocCopier(TypeLoc source) : Source(source) {}
 
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
-#define TYPELOC(CLASS, PARENT)                          \
-  void Visit##CLASS##TypeLoc(CLASS##TypeLoc dest) {   \
-    dest.copyLocal(Source.castAs<CLASS##TypeLoc>());  \
+#define TYPELOC(CLASS, PARENT)                                                 \
+  void Visit##CLASS##TypeLoc(CLASS##TypeLoc dest) {                            \
+    dest.copyLocal(Source.castAs<CLASS##TypeLoc>());                           \
   }
 #include "clang/AST/TypeLocNodes.def"
 };
@@ -197,7 +198,8 @@
       LeftMost = Cur;
       break;
     case FunctionProto:
-      if (Cur.castAs<FunctionProtoTypeLoc>().getTypePtr()
+      if (Cur.castAs<FunctionProtoTypeLoc>()
+              .getTypePtr()
               ->hasTrailingReturn()) {
         LeftMost = Cur;
         break;
@@ -273,10 +275,8 @@
   static bool isTypeSpec(TypeLoc _) { return false; }
 
 #define ABSTRACT_TYPELOC(CLASS, PARENT)
-#define TYPELOC(CLASS, PARENT) \
-  bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
-    return isTypeSpec(TyLoc); \
-  }
+#define TYPELOC(CLASS, PARENT)                                                 \
+  bool Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { return isTypeSpec(TyLoc); }
 #include "clang/AST/TypeLocNodes.def"
 };
 
@@ -290,8 +290,9 @@
 /// because it's a convenient base class.  Ideally we would not accept
 /// those here, but ideally we would have better implementations for
 /// them.
-bool TypeSpecTypeLoc::isKind(const TypeLoc &TL) {
-  if (TL.getType().hasLocalQualifiers()) return false;
+bool TypeSpecTypeLoc::isKind(TypeLoc const &TL) {
+  if (TL.getType().hasLocalQualifiers())
+    return false;
   return TSTChecker().Visit(TL);
 }
 
@@ -312,7 +313,6 @@
                        getUnderlyingExpr()->getSourceRange().getEnd());
 }
 
-
 TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
   if (needsExtraLocalData())
     return static_cast<TypeSpecifierType>(getWrittenBuiltinSpecs().Type);
@@ -390,22 +390,19 @@
   case BuiltinType::ObjCId:
   case BuiltinType::ObjCClass:
   case BuiltinType::ObjCSel:
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
   case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
-  case BuiltinType::Id:
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
 #include "clang/Basic/OpenCLExtensionTypes.def"
   case BuiltinType::OCLSampler:
   case BuiltinType::OCLEvent:
   case BuiltinType::OCLClkEvent:
   case BuiltinType::OCLQueue:
   case BuiltinType::OCLReserveID:
-#define SVE_TYPE(Name, Id, SingletonId) \
-  case BuiltinType::Id:
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/AArch64SVEACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
-  case BuiltinType::Id:
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
 #include "clang/Basic/PPCTypes.def"
 #define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
 #include "clang/Basic/RISCVVTypes.def"
@@ -428,7 +425,7 @@
 
 SourceLocation TypeLoc::findNullabilityLoc() const {
   if (auto ATL = getAs<AttributedTypeLoc>()) {
-    const Attr *A = ATL.getAttr();
+    Attr const *A = ATL.getAttr();
     if (A && (isa<TypeNullableAttr>(A) || isa<TypeNonNullAttr>(A) ||
               isa<TypeNullUnspecifiedAttr>(A)))
       return A->getLocation();
@@ -446,7 +443,8 @@
 
   // Attributed types.
   if (auto attr = loc.getAs<AttributedTypeLoc>()) {
-    if (attr.isQualifier()) return attr;
+    if (attr.isQualifier())
+      return attr;
     return attr.getModifiedLoc().findExplicitQualifierLoc();
   }
 
@@ -461,7 +459,8 @@
 void ObjCTypeParamTypeLoc::initializeLocal(ASTContext &Context,
                                            SourceLocation Loc) {
   setNameLoc(Loc);
-  if (!getNumProtocols()) return;
+  if (!getNumProtocols())
+    return;
 
   setProtocolLAngleLoc(Loc);
   setProtocolRAngleLoc(Loc);
@@ -475,9 +474,8 @@
   setTypeArgsLAngleLoc(Loc);
   setTypeArgsRAngleLoc(Loc);
   for (unsigned i = 0, e = getNumTypeArgs(); i != e; ++i) {
-    setTypeArgTInfo(i,
-                   Context.getTrivialTypeSourceInfo(
-                     getTypePtr()->getTypeArgsAsWritten()[i], Loc));
+    setTypeArgTInfo(i, Context.getTrivialTypeSourceInfo(
+                           getTypePtr()->getTypeArgsAsWritten()[i], Loc));
   }
   setProtocolLAngleLoc(Loc);
   setProtocolRAngleLoc(Loc);
@@ -498,21 +496,20 @@
   return getAttr() ? getAttr()->getRange() : SourceRange();
 }
 
-void TypeOfTypeLoc::initializeLocal(ASTContext &Context,
-                                       SourceLocation Loc) {
-  TypeofLikeTypeLoc<TypeOfTypeLoc, TypeOfType, TypeOfTypeLocInfo>
-      ::initializeLocal(Context, Loc);
-  this->getLocalData()->UnderlyingTInfo = Context.getTrivialTypeSourceInfo(
-      getUnderlyingType(), Loc);
+void TypeOfTypeLoc::initializeLocal(ASTContext &Context, SourceLocation Loc) {
+  TypeofLikeTypeLoc<TypeOfTypeLoc, TypeOfType,
+                    TypeOfTypeLocInfo>::initializeLocal(Context, Loc);
+  this->getLocalData()->UnderlyingTInfo =
+      Context.getTrivialTypeSourceInfo(getUnderlyingType(), Loc);
 }
 
 void UnaryTransformTypeLoc::initializeLocal(ASTContext &Context,
-                                       SourceLocation Loc) {
-    setKWLoc(Loc);
-    setRParenLoc(Loc);
-    setLParenLoc(Loc);
-    this->setUnderlyingTInfo(
-        Context.getTrivialTypeSourceInfo(getTypePtr()->getBaseType(), Loc));
+                                            SourceLocation Loc) {
+  setKWLoc(Loc);
+  setRParenLoc(Loc);
+  setLParenLoc(Loc);
+  this->setUnderlyingTInfo(
+      Context.getTrivialTypeSourceInfo(getTypePtr()->getBaseType(), Loc));
 }
 
 void ElaboratedTypeLoc::initializeLocal(ASTContext &Context,
@@ -532,9 +529,8 @@
   setNameLoc(Loc);
 }
 
-void
-DependentTemplateSpecializationTypeLoc::initializeLocal(ASTContext &Context,
-                                                        SourceLocation Loc) {
+void DependentTemplateSpecializationTypeLoc::initializeLocal(
+    ASTContext &Context, SourceLocation Loc) {
   setElaboratedKeywordLoc(Loc);
   if (getTypePtr()->getQualifier()) {
     NestedNameSpecifierLocBuilder Builder;
@@ -547,16 +543,13 @@
   setTemplateNameLoc(Loc);
   setLAngleLoc(Loc);
   setRAngleLoc(Loc);
-  TemplateSpecializationTypeLoc::initializeArgLocs(Context, getNumArgs(),
-                                                   getTypePtr()->getArgs(),
-                                                   getArgInfos(), Loc);
+  TemplateSpecializationTypeLoc::initializeArgLocs(
+      Context, getNumArgs(), getTypePtr()->getArgs(), getArgInfos(), Loc);
 }
 
-void TemplateSpecializationTypeLoc::initializeArgLocs(ASTContext &Context,
-                                                      unsigned NumArgs,
-                                                  const TemplateArgument *Args,
-                                              TemplateArgumentLocInfo *ArgInfos,
-                                                      SourceLocation Loc) {
+void TemplateSpecializationTypeLoc::initializeArgLocs(
+    ASTContext &Context, unsigned NumArgs, TemplateArgument const *Args,
+    TemplateArgumentLocInfo *ArgInfos, SourceLocation Loc) {
   for (unsigned i = 0, e = NumArgs; i != e; ++i) {
     switch (Args[i].getKind()) {
     case TemplateArgument::Null:
@@ -574,8 +567,7 @@
 
     case TemplateArgument::Type:
       ArgInfos[i] = TemplateArgumentLocInfo(
-                          Context.getTrivialTypeSourceInfo(Args[i].getAsType(),
-                                                           Loc));
+          Context.getTrivialTypeSourceInfo(Args[i].getAsType(), Loc));
       break;
 
     case TemplateArgument::Template:
@@ -584,7 +576,8 @@
       TemplateName Template = Args[i].getAsTemplateOrTemplatePattern();
       if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
         Builder.MakeTrivial(Context, DTN->getQualifier(), Loc);
-      else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
+      else if (QualifiedTemplateName *QTN =
+                   Template.getAsQualifiedTemplateName())
         Builder.MakeTrivial(Context, QTN->getQualifier(), Loc);
 
       ArgInfos[i] = TemplateArgumentLocInfo(
@@ -613,78 +606,70 @@
   setFoundDecl(nullptr);
   setRAngleLoc(Loc);
   setLAngleLoc(Loc);
-  TemplateSpecializationTypeLoc::initializeArgLocs(Context, getNumArgs(),
-                                                   getTypePtr()->getArgs(),
-                                                   getArgInfos(), Loc);
+  TemplateSpecializationTypeLoc::initializeArgLocs(
+      Context, getNumArgs(), getTypePtr()->getArgs(), getArgInfos(), Loc);
   setNameLoc(Loc);
 }
 
-
 namespace {
 
-  class GetContainedAutoTypeLocVisitor :
-    public TypeLocVisitor<GetContainedAutoTypeLocVisitor, TypeLoc> {
-  public:
-    using TypeLocVisitor<GetContainedAutoTypeLocVisitor, TypeLoc>::Visit;
+class GetContainedAutoTypeLocVisitor
+    : public TypeLocVisitor<GetContainedAutoTypeLocVisitor, TypeLoc> {
+public:
+  using TypeLocVisitor<GetContainedAutoTypeLocVisitor, TypeLoc>::Visit;
 
-    TypeLoc VisitAutoTypeLoc(AutoTypeLoc TL) {
-      return TL;
-    }
+  TypeLoc VisitAutoTypeLoc(AutoTypeLoc TL) { return TL; }
 
-    // Only these types can contain the desired 'auto' type.
+  // Only these types can contain the desired 'auto' type.
 
-    TypeLoc VisitElaboratedTypeLoc(ElaboratedTypeLoc T) {
-      return Visit(T.getNamedTypeLoc());
-    }
+  TypeLoc VisitElaboratedTypeLoc(ElaboratedTypeLoc T) {
+    return Visit(T.getNamedTypeLoc());
+  }
 
-    TypeLoc VisitQualifiedTypeLoc(QualifiedTypeLoc T) {
-      return Visit(T.getUnqualifiedLoc());
-    }
+  TypeLoc VisitQualifiedTypeLoc(QualifiedTypeLoc T) {
+    return Visit(T.getUnqualifiedLoc());
+  }
 
-    TypeLoc VisitPointerTypeLoc(PointerTypeLoc T) {
-      return Visit(T.getPointeeLoc());
-    }
+  TypeLoc VisitPointerTypeLoc(PointerTypeLoc T) {
+    return Visit(T.getPointeeLoc());
+  }
 
-    TypeLoc VisitBlockPointerTypeLoc(BlockPointerTypeLoc T) {
-      return Visit(T.getPointeeLoc());
-    }
+  TypeLoc VisitBlockPointerTypeLoc(BlockPointerTypeLoc T) {
+    return Visit(T.getPointeeLoc());
+  }
 
-    TypeLoc VisitReferenceTypeLoc(ReferenceTypeLoc T) {
-      return Visit(T.getPointeeLoc());
-    }
+  TypeLoc VisitReferenceTypeLoc(ReferenceTypeLoc T) {
+    return Visit(T.getPointeeLoc());
+  }
 
-    TypeLoc VisitMemberPointerTypeLoc(MemberPointerTypeLoc T) {
-      return Visit(T.getPointeeLoc());
-    }
+  TypeLoc VisitMemberPointerTypeLoc(MemberPointerTypeLoc T) {
+    return Visit(T.getPointeeLoc());
+  }
 
-    TypeLoc VisitArrayTypeLoc(ArrayTypeLoc T) {
-      return Visit(T.getElementLoc());
-    }
+  TypeLoc VisitArrayTypeLoc(ArrayTypeLoc T) { return Visit(T.getElementLoc()); }
 
-    TypeLoc VisitFunctionTypeLoc(FunctionTypeLoc T) {
-      return Visit(T.getReturnLoc());
-    }
+  TypeLoc VisitFunctionTypeLoc(FunctionTypeLoc T) {
+    return Visit(T.getReturnLoc());
+  }
 
-    TypeLoc VisitParenTypeLoc(ParenTypeLoc T) {
-      return Visit(T.getInnerLoc());
-    }
+  TypeLoc VisitParenTypeLoc(ParenTypeLoc T) { return Visit(T.getInnerLoc()); }
 
-    TypeLoc VisitAttributedTypeLoc(AttributedTypeLoc T) {
-      return Visit(T.getModifiedLoc());
-    }
+  TypeLoc VisitAttributedTypeLoc(AttributedTypeLoc T) {
+    return Visit(T.getModifiedLoc());
+  }
 
-    TypeLoc VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc T) {
-      return Visit(T.getInnerLoc());
-    }
+  TypeLoc VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc T) {
+    return Visit(T.getInnerLoc());
+  }
 
-    TypeLoc VisitAdjustedTypeLoc(AdjustedTypeLoc T) {
-      return Visit(T.getOriginalLoc());
-    }
+  TypeLoc VisitAdjustedTypeLoc(AdjustedTypeLoc T) {
+    return Visit(T.getOriginalLoc());
+  }
 
-    TypeLoc VisitPackExpansionTypeLoc(PackExpansionTypeLoc T) {
-      return Visit(T.getPatternLoc());
-    }
-  };
+  TypeLoc VisitPackExpansionTypeLoc(PackExpansionTypeLoc T) {
+    return Visit(T.getPatternLoc());
+  }
+};
 
 } // namespace
 
Index: clang/lib/AST/TypePrinter.cpp
===================================================================
--- clang/lib/AST/TypePrinter.cpp
+++ clang/lib/AST/TypePrinter.cpp
@@ -47,94 +47,90 @@
 
 namespace {
 
-  /// RAII object that enables printing of the ARC __strong lifetime
-  /// qualifier.
-  class IncludeStrongLifetimeRAII {
-    PrintingPolicy &Policy;
-    bool Old;
-
-  public:
-    explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy)
-        : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
-        if (!Policy.SuppressLifetimeQualifiers)
-          Policy.SuppressStrongLifetime = false;
-    }
+/// RAII object that enables printing of the ARC __strong lifetime
+/// qualifier.
+class IncludeStrongLifetimeRAII {
+  PrintingPolicy &Policy;
+  bool Old;
+
+public:
+  explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy)
+      : Policy(Policy), Old(Policy.SuppressStrongLifetime) {
+    if (!Policy.SuppressLifetimeQualifiers)
+      Policy.SuppressStrongLifetime = false;
+  }
 
-    ~IncludeStrongLifetimeRAII() {
-      Policy.SuppressStrongLifetime = Old;
-    }
-  };
+  ~IncludeStrongLifetimeRAII() { Policy.SuppressStrongLifetime = Old; }
+};
 
-  class ParamPolicyRAII {
-    PrintingPolicy &Policy;
-    bool Old;
+class ParamPolicyRAII {
+  PrintingPolicy &Policy;
+  bool Old;
 
-  public:
-    explicit ParamPolicyRAII(PrintingPolicy &Policy)
-        : Policy(Policy), Old(Policy.SuppressSpecifiers) {
-      Policy.SuppressSpecifiers = false;
-    }
+public:
+  explicit ParamPolicyRAII(PrintingPolicy &Policy)
+      : Policy(Policy), Old(Policy.SuppressSpecifiers) {
+    Policy.SuppressSpecifiers = false;
+  }
 
-    ~ParamPolicyRAII() {
-      Policy.SuppressSpecifiers = Old;
-    }
-  };
-
-  class ElaboratedTypePolicyRAII {
-    PrintingPolicy &Policy;
-    bool SuppressTagKeyword;
-    bool SuppressScope;
-
-  public:
-    explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) {
-      SuppressTagKeyword = Policy.SuppressTagKeyword;
-      SuppressScope = Policy.SuppressScope;
-      Policy.SuppressTagKeyword = true;
-      Policy.SuppressScope = true;
-    }
+  ~ParamPolicyRAII() { Policy.SuppressSpecifiers = Old; }
+};
 
-    ~ElaboratedTypePolicyRAII() {
-      Policy.SuppressTagKeyword = SuppressTagKeyword;
-      Policy.SuppressScope = SuppressScope;
-    }
-  };
-
-  class TypePrinter {
-    PrintingPolicy Policy;
-    unsigned Indentation;
-    bool HasEmptyPlaceHolder = false;
-    bool InsideCCAttribute = false;
-
-  public:
-    explicit TypePrinter(const PrintingPolicy &Policy, unsigned Indentation = 0)
-        : Policy(Policy), Indentation(Indentation) {}
-
-    void print(const Type *ty, Qualifiers qs, raw_ostream &OS,
-               StringRef PlaceHolder);
-    void print(QualType T, raw_ostream &OS, StringRef PlaceHolder);
-
-    static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier);
-    void spaceBeforePlaceHolder(raw_ostream &OS);
-    void printTypeSpec(NamedDecl *D, raw_ostream &OS);
-    void printTemplateId(const TemplateSpecializationType *T, raw_ostream &OS,
-                         bool FullyQualify);
-
-    void printBefore(QualType T, raw_ostream &OS);
-    void printAfter(QualType T, raw_ostream &OS);
-    void AppendScope(DeclContext *DC, raw_ostream &OS,
-                     DeclarationName NameInScope);
-    void printTag(TagDecl *T, raw_ostream &OS);
-    void printFunctionAfter(const FunctionType::ExtInfo &Info, raw_ostream &OS);
+class ElaboratedTypePolicyRAII {
+  PrintingPolicy &Policy;
+  bool SuppressTagKeyword;
+  bool SuppressScope;
+
+public:
+  explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) {
+    SuppressTagKeyword = Policy.SuppressTagKeyword;
+    SuppressScope = Policy.SuppressScope;
+    Policy.SuppressTagKeyword = true;
+    Policy.SuppressScope = true;
+  }
+
+  ~ElaboratedTypePolicyRAII() {
+    Policy.SuppressTagKeyword = SuppressTagKeyword;
+    Policy.SuppressScope = SuppressScope;
+  }
+};
+
+class TypePrinter {
+  PrintingPolicy Policy;
+  unsigned Indentation;
+  bool HasEmptyPlaceHolder = false;
+  bool InsideCCAttribute = false;
+
+public:
+  explicit TypePrinter(PrintingPolicy const &Policy, unsigned Indentation = 0)
+      : Policy(Policy), Indentation(Indentation) {}
+
+  void print(Type const *ty, Qualifiers qs, raw_ostream &OS,
+             StringRef PlaceHolder);
+  void print(QualType T, raw_ostream &OS, StringRef PlaceHolder);
+
+  static bool canPrefixQualifiers(Type const *T, bool &NeedARCStrongQualifier);
+  void spaceBeforePlaceHolder(raw_ostream &OS);
+  void printTypeSpec(NamedDecl *D, raw_ostream &OS);
+  void printTemplateId(TemplateSpecializationType const *T, raw_ostream &OS,
+                       bool FullyQualify);
+
+  void printBefore(QualType T, raw_ostream &OS);
+  void printAfter(QualType T, raw_ostream &OS);
+  void AppendScope(DeclContext *DC, raw_ostream &OS,
+                   DeclarationName NameInScope);
+  void printTag(TagDecl *T, raw_ostream &OS);
+  void printFunctionAfter(FunctionType::ExtInfo const &Info, raw_ostream &OS);
 #define ABSTRACT_TYPE(CLASS, PARENT)
-#define TYPE(CLASS, PARENT) \
-    void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \
-    void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS);
+#define TYPE(CLASS, PARENT)                                                    \
+  void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS);            \
+  void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS);
 #include "clang/AST/TypeNodes.inc"
 
-  private:
-    void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS);
-    void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS);
-  };
+private:
+  void printBefore(Type const *ty, Qualifiers qs, raw_ostream &OS);
+  void printAfter(Type const *ty, Qualifiers qs, raw_ostream &OS);
+};
 
 } // namespace
 
@@ -146,12 +142,14 @@
     appendSpace = true;
   }
   if (TypeQuals & Qualifiers::Volatile) {
-    if (appendSpace) OS << ' ';
+    if (appendSpace)
+      OS << ' ';
     OS << "volatile";
     appendSpace = true;
   }
   if (TypeQuals & Qualifiers::Restrict) {
-    if (appendSpace) OS << ' ';
+    if (appendSpace)
+      OS << ' ';
     if (HasRestrictKeyword) {
       OS << "restrict";
     } else {
@@ -166,7 +164,7 @@
 }
 
 static SplitQualType splitAccordingToPolicy(QualType QT,
-                                            const PrintingPolicy &Policy) {
+                                            PrintingPolicy const &Policy) {
   if (Policy.PrintCanonicalTypes)
     QT = QT.getCanonicalType();
   return QT.split();
@@ -177,7 +175,7 @@
   print(split.Ty, split.Quals, OS, PlaceHolder);
 }
 
-void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
+void TypePrinter::print(Type const *T, Qualifiers Quals, raw_ostream &OS,
                         StringRef PlaceHolder) {
   if (!T) {
     OS << "NULL TYPE";
@@ -191,7 +189,7 @@
   printAfter(T, Quals, OS);
 }
 
-bool TypePrinter::canPrefixQualifiers(const Type *T,
+bool TypePrinter::canPrefixQualifiers(Type const *T,
                                       bool &NeedARCStrongQualifier) {
   // CanPrefixQualifiers - We prefer to print type qualifiers before the type,
   // so that we get "const int" instead of "int const", but we can't do this if
@@ -200,87 +198,88 @@
   // type expands to a simple string.
   bool CanPrefixQualifiers = false;
   NeedARCStrongQualifier = false;
-  const Type *UnderlyingType = T;
-  if (const auto *AT = dyn_cast<AutoType>(T))
+  Type const *UnderlyingType = T;
+  if (auto const *AT = dyn_cast<AutoType>(T))
     UnderlyingType = AT->desugar().getTypePtr();
-  if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(T))
+  if (auto const *Subst = dyn_cast<SubstTemplateTypeParmType>(T))
     UnderlyingType = Subst->getReplacementType().getTypePtr();
   Type::TypeClass TC = UnderlyingType->getTypeClass();
 
   switch (TC) {
-    case Type::Auto:
-    case Type::Builtin:
-    case Type::Complex:
-    case Type::UnresolvedUsing:
-    case Type::Typedef:
-    case Type::TypeOfExpr:
-    case Type::TypeOf:
-    case Type::Decltype:
-    case Type::UnaryTransform:
-    case Type::Record:
-    case Type::Enum:
-    case Type::Elaborated:
-    case Type::TemplateTypeParm:
-    case Type::SubstTemplateTypeParmPack:
-    case Type::DeducedTemplateSpecialization:
-    case Type::TemplateSpecialization:
-    case Type::InjectedClassName:
-    case Type::DependentName:
-    case Type::DependentTemplateSpecialization:
-    case Type::ObjCObject:
-    case Type::ObjCTypeParam:
-    case Type::ObjCInterface:
-    case Type::Atomic:
-    case Type::Pipe:
-    case Type::ExtInt:
-    case Type::DependentExtInt:
-      CanPrefixQualifiers = true;
-      break;
+  case Type::Auto:
+  case Type::Builtin:
+  case Type::Complex:
+  case Type::UnresolvedUsing:
+  case Type::Typedef:
+  case Type::TypeOfExpr:
+  case Type::TypeOf:
+  case Type::Decltype:
+  case Type::UnaryTransform:
+  case Type::Record:
+  case Type::Enum:
+  case Type::Elaborated:
+  case Type::TemplateTypeParm:
+  case Type::SubstTemplateTypeParmPack:
+  case Type::DeducedTemplateSpecialization:
+  case Type::TemplateSpecialization:
+  case Type::InjectedClassName:
+  case Type::DependentName:
+  case Type::DependentTemplateSpecialization:
+  case Type::ObjCObject:
+  case Type::ObjCTypeParam:
+  case Type::ObjCInterface:
+  case Type::Atomic:
+  case Type::Pipe:
+  case Type::ExtInt:
+  case Type::DependentExtInt:
+    CanPrefixQualifiers = true;
+    break;
 
-    case Type::ObjCObjectPointer:
-      CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
-        T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType();
-      break;
+  case Type::ObjCObjectPointer:
+    CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() ||
+                          T->isObjCQualifiedIdType() ||
+                          T->isObjCQualifiedClassType();
+    break;
 
-    case Type::ConstantArray:
-    case Type::IncompleteArray:
-      return canPrefixQualifiers(
-          cast<ArrayType>(UnderlyingType)->getElementType().getTypePtr(),
-          NeedARCStrongQualifier);
-    case Type::VariableArray:
-    case Type::DependentSizedArray:
-      NeedARCStrongQualifier = true;
-      LLVM_FALLTHROUGH;
-
-    case Type::Adjusted:
-    case Type::Decayed:
-    case Type::Pointer:
-    case Type::BlockPointer:
-    case Type::LValueReference:
-    case Type::RValueReference:
-    case Type::MemberPointer:
-    case Type::DependentAddressSpace:
-    case Type::DependentVector:
-    case Type::DependentSizedExtVector:
-    case Type::Vector:
-    case Type::ExtVector:
-    case Type::ConstantMatrix:
-    case Type::DependentSizedMatrix:
-    case Type::FunctionProto:
-    case Type::FunctionNoProto:
-    case Type::Paren:
-    case Type::PackExpansion:
-    case Type::SubstTemplateTypeParm:
-    case Type::MacroQualified:
-      CanPrefixQualifiers = false;
-      break;
+  case Type::ConstantArray:
+  case Type::IncompleteArray:
+    return canPrefixQualifiers(
+        cast<ArrayType>(UnderlyingType)->getElementType().getTypePtr(),
+        NeedARCStrongQualifier);
+  case Type::VariableArray:
+  case Type::DependentSizedArray:
+    NeedARCStrongQualifier = true;
+    LLVM_FALLTHROUGH;
+
+  case Type::Adjusted:
+  case Type::Decayed:
+  case Type::Pointer:
+  case Type::BlockPointer:
+  case Type::LValueReference:
+  case Type::RValueReference:
+  case Type::MemberPointer:
+  case Type::DependentAddressSpace:
+  case Type::DependentVector:
+  case Type::DependentSizedExtVector:
+  case Type::Vector:
+  case Type::ExtVector:
+  case Type::ConstantMatrix:
+  case Type::DependentSizedMatrix:
+  case Type::FunctionProto:
+  case Type::FunctionNoProto:
+  case Type::Paren:
+  case Type::PackExpansion:
+  case Type::SubstTemplateTypeParm:
+  case Type::MacroQualified:
+    CanPrefixQualifiers = false;
+    break;
 
-    case Type::Attributed: {
-      // We still want to print the address_space before the type if it is an
-      // address_space attribute.
-      const auto *AttrTy = cast<AttributedType>(T);
-      CanPrefixQualifiers = AttrTy->getAttrKind() == attr::AddressSpace;
-    }
+  case Type::Attributed: {
+    // We still want to print the address_space before the type if it is an
+    // address_space attribute.
+    auto const *AttrTy = cast<AttributedType>(T);
+    CanPrefixQualifiers = AttrTy->getAttrKind() == attr::AddressSpace;
+  }
   }
 
   return CanPrefixQualifiers;
@@ -292,7 +291,7 @@
   // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2
   // at this level.
   Qualifiers Quals = Split.Quals;
-  if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(Split.Ty))
+  if (auto const *Subst = dyn_cast<SubstTemplateTypeParmType>(Split.Ty))
     Quals -= QualType(Subst, 0).getQualifiers();
 
   printBefore(Split.Ty, Quals, OS);
@@ -300,7 +299,8 @@
 
 /// Prints the part of the type string before an identifier, e.g. for
 /// "int foo[10]" it prints "int ".
-void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) {
+void TypePrinter::printBefore(Type const *T, Qualifiers Quals,
+                              raw_ostream &OS) {
   if (Policy.SuppressSpecifiers && T->isSpecifierType())
     return;
 
@@ -330,8 +330,9 @@
 
   switch (T->getTypeClass()) {
 #define ABSTRACT_TYPE(CLASS, PARENT)
-#define TYPE(CLASS, PARENT) case Type::CLASS: \
-    print##CLASS##Before(cast<CLASS##Type>(T), OS); \
+#define TYPE(CLASS, PARENT)                                                    \
+  case Type::CLASS:                                                            \
+    print##CLASS##Before(cast<CLASS##Type>(T), OS);                            \
     break;
 #include "clang/AST/TypeNodes.inc"
   }
@@ -353,33 +354,34 @@
 
 /// Prints the part of the type string after an identifier, e.g. for
 /// "int foo[10]" it prints "[10]".
-void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) {
+void TypePrinter::printAfter(Type const *T, Qualifiers Quals, raw_ostream &OS) {
   switch (T->getTypeClass()) {
 #define ABSTRACT_TYPE(CLASS, PARENT)
-#define TYPE(CLASS, PARENT) case Type::CLASS: \
-    print##CLASS##After(cast<CLASS##Type>(T), OS); \
+#define TYPE(CLASS, PARENT)                                                    \
+  case Type::CLASS:                                                            \
+    print##CLASS##After(cast<CLASS##Type>(T), OS);                             \
     break;
 #include "clang/AST/TypeNodes.inc"
   }
 }
 
-void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) {
+void TypePrinter::printBuiltinBefore(BuiltinType const *T, raw_ostream &OS) {
   OS << T->getName(Policy);
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {}
+void TypePrinter::printBuiltinAfter(BuiltinType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) {
+void TypePrinter::printComplexBefore(ComplexType const *T, raw_ostream &OS) {
   OS << "_Complex ";
   printBefore(T->getElementType(), OS);
 }
 
-void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) {
+void TypePrinter::printComplexAfter(ComplexType const *T, raw_ostream &OS) {
   printAfter(T->getElementType(), OS);
 }
 
-void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) {
+void TypePrinter::printPointerBefore(PointerType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
   printBefore(T->getPointeeType(), OS);
@@ -390,7 +392,7 @@
   OS << '*';
 }
 
-void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) {
+void TypePrinter::printPointerAfter(PointerType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
   // Handle things like 'int (*A)[4];' correctly.
@@ -400,15 +402,15 @@
   printAfter(T->getPointeeType(), OS);
 }
 
-void TypePrinter::printBlockPointerBefore(const BlockPointerType *T,
+void TypePrinter::printBlockPointerBefore(BlockPointerType const *T,
                                           raw_ostream &OS) {
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
   printBefore(T->getPointeeType(), OS);
   OS << '^';
 }
 
-void TypePrinter::printBlockPointerAfter(const BlockPointerType *T,
-                                          raw_ostream &OS) {
+void TypePrinter::printBlockPointerAfter(BlockPointerType const *T,
+                                         raw_ostream &OS) {
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
   printAfter(T->getPointeeType(), OS);
 }
@@ -421,7 +423,7 @@
   return T;
 }
 
-void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T,
+void TypePrinter::printLValueReferenceBefore(LValueReferenceType const *T,
                                              raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
@@ -434,7 +436,7 @@
   OS << '&';
 }
 
-void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T,
+void TypePrinter::printLValueReferenceAfter(LValueReferenceType const *T,
                                             raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
@@ -446,7 +448,7 @@
   printAfter(Inner, OS);
 }
 
-void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T,
+void TypePrinter::printRValueReferenceBefore(RValueReferenceType const *T,
                                              raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
@@ -459,7 +461,7 @@
   OS << "&&";
 }
 
-void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T,
+void TypePrinter::printRValueReferenceAfter(RValueReferenceType const *T,
                                             raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
@@ -471,7 +473,7 @@
   printAfter(Inner, OS);
 }
 
-void TypePrinter::printMemberPointerBefore(const MemberPointerType *T,
+void TypePrinter::printMemberPointerBefore(MemberPointerType const *T,
                                            raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
@@ -488,7 +490,7 @@
   OS << "::*";
 }
 
-void TypePrinter::printMemberPointerAfter(const MemberPointerType *T,
+void TypePrinter::printMemberPointerAfter(MemberPointerType const *T,
                                           raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
@@ -499,19 +501,18 @@
   printAfter(T->getPointeeType(), OS);
 }
 
-void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T,
+void TypePrinter::printConstantArrayBefore(ConstantArrayType const *T,
                                            raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
   printBefore(T->getElementType(), OS);
 }
 
-void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T,
+void TypePrinter::printConstantArrayAfter(ConstantArrayType const *T,
                                           raw_ostream &OS) {
   OS << '[';
   if (T->getIndexTypeQualifiers().hasQualifiers()) {
-    AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(),
-                       Policy.Restrict);
+    AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.Restrict);
     OS << ' ';
   }
 
@@ -522,27 +523,27 @@
   printAfter(T->getElementType(), OS);
 }
 
-void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T,
+void TypePrinter::printIncompleteArrayBefore(IncompleteArrayType const *T,
                                              raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
   printBefore(T->getElementType(), OS);
 }
 
-void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T,
+void TypePrinter::printIncompleteArrayAfter(IncompleteArrayType const *T,
                                             raw_ostream &OS) {
   OS << "[]";
   printAfter(T->getElementType(), OS);
 }
 
-void TypePrinter::printVariableArrayBefore(const VariableArrayType *T,
+void TypePrinter::printVariableArrayBefore(VariableArrayType const *T,
                                            raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
   printBefore(T->getElementType(), OS);
 }
 
-void TypePrinter::printVariableArrayAfter(const VariableArrayType *T,
+void TypePrinter::printVariableArrayAfter(VariableArrayType const *T,
                                           raw_ostream &OS) {
   OS << '[';
   if (T->getIndexTypeQualifiers().hasQualifiers()) {
@@ -562,36 +563,34 @@
   printAfter(T->getElementType(), OS);
 }
 
-void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) {
+void TypePrinter::printAdjustedBefore(AdjustedType const *T, raw_ostream &OS) {
   // Print the adjusted representation, otherwise the adjustment will be
   // invisible.
   printBefore(T->getAdjustedType(), OS);
 }
 
-void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) {
+void TypePrinter::printAdjustedAfter(AdjustedType const *T, raw_ostream &OS) {
   printAfter(T->getAdjustedType(), OS);
 }
 
-void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) {
+void TypePrinter::printDecayedBefore(DecayedType const *T, raw_ostream &OS) {
   // Print as though it's a pointer.
   printAdjustedBefore(T, OS);
 }
 
-void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) {
+void TypePrinter::printDecayedAfter(DecayedType const *T, raw_ostream &OS) {
   printAdjustedAfter(T, OS);
 }
 
 void TypePrinter::printDependentSizedArrayBefore(
-                                               const DependentSizedArrayType *T,
-                                               raw_ostream &OS) {
+    DependentSizedArrayType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false);
   printBefore(T->getElementType(), OS);
 }
 
 void TypePrinter::printDependentSizedArrayAfter(
-                                               const DependentSizedArrayType *T,
-                                               raw_ostream &OS) {
+    DependentSizedArrayType const *T, raw_ostream &OS) {
   OS << '[';
   if (T->getSizeExpr())
     T->getSizeExpr()->printPretty(OS, nullptr, Policy);
@@ -600,12 +599,12 @@
 }
 
 void TypePrinter::printDependentAddressSpaceBefore(
-    const DependentAddressSpaceType *T, raw_ostream &OS) {
+    DependentAddressSpaceType const *T, raw_ostream &OS) {
   printBefore(T->getPointeeType(), OS);
 }
 
 void TypePrinter::printDependentAddressSpaceAfter(
-    const DependentAddressSpaceType *T, raw_ostream &OS) {
+    DependentAddressSpaceType const *T, raw_ostream &OS) {
   OS << " __attribute__((address_space(";
   if (T->getAddrSpaceExpr())
     T->getAddrSpaceExpr()->printPretty(OS, nullptr, Policy);
@@ -614,14 +613,12 @@
 }
 
 void TypePrinter::printDependentSizedExtVectorBefore(
-                                          const DependentSizedExtVectorType *T,
-                                          raw_ostream &OS) {
+    DependentSizedExtVectorType const *T, raw_ostream &OS) {
   printBefore(T->getElementType(), OS);
 }
 
 void TypePrinter::printDependentSizedExtVectorAfter(
-                                          const DependentSizedExtVectorType *T,
-                                          raw_ostream &OS) {
+    DependentSizedExtVectorType const *T, raw_ostream &OS) {
   OS << " __attribute__((ext_vector_type(";
   if (T->getSizeExpr())
     T->getSizeExpr()->printPretty(OS, nullptr, Policy);
@@ -629,7 +626,7 @@
   printAfter(T->getElementType(), OS);
 }
 
-void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) {
+void TypePrinter::printVectorBefore(VectorType const *T, raw_ostream &OS) {
   switch (T->getVectorKind()) {
   case VectorType::AltiVecPixel:
     OS << "__vector __pixel ";
@@ -643,20 +640,18 @@
     printBefore(T->getElementType(), OS);
     break;
   case VectorType::NeonVector:
-    OS << "__attribute__((neon_vector_type("
-       << T->getNumElements() << "))) ";
+    OS << "__attribute__((neon_vector_type(" << T->getNumElements() << "))) ";
     printBefore(T->getElementType(), OS);
     break;
   case VectorType::NeonPolyVector:
-    OS << "__attribute__((neon_polyvector_type(" <<
-          T->getNumElements() << "))) ";
+    OS << "__attribute__((neon_polyvector_type(" << T->getNumElements()
+       << "))) ";
     printBefore(T->getElementType(), OS);
     break;
   case VectorType::GenericVector: {
     // FIXME: We prefer to print the size directly here, but have no way
     // to get the size of the type.
-    OS << "__attribute__((__vector_size__("
-       << T->getNumElements()
+    OS << "__attribute__((__vector_size__(" << T->getNumElements()
        << " * sizeof(";
     print(T->getElementType(), OS, StringRef());
     OS << ")))) ";
@@ -684,12 +679,12 @@
   }
 }
 
-void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) {
+void TypePrinter::printVectorAfter(VectorType const *T, raw_ostream &OS) {
   printAfter(T->getElementType(), OS);
 }
 
-void TypePrinter::printDependentVectorBefore(
-    const DependentVectorType *T, raw_ostream &OS) {
+void TypePrinter::printDependentVectorBefore(DependentVectorType const *T,
+                                             raw_ostream &OS) {
   switch (T->getVectorKind()) {
   case VectorType::AltiVecPixel:
     OS << "__vector __pixel ";
@@ -749,24 +744,24 @@
   }
 }
 
-void TypePrinter::printDependentVectorAfter(
-    const DependentVectorType *T, raw_ostream &OS) {
+void TypePrinter::printDependentVectorAfter(DependentVectorType const *T,
+                                            raw_ostream &OS) {
   printAfter(T->getElementType(), OS);
 }
 
-void TypePrinter::printExtVectorBefore(const ExtVectorType *T,
+void TypePrinter::printExtVectorBefore(ExtVectorType const *T,
                                        raw_ostream &OS) {
   printBefore(T->getElementType(), OS);
 }
 
-void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) {
+void TypePrinter::printExtVectorAfter(ExtVectorType const *T, raw_ostream &OS) {
   printAfter(T->getElementType(), OS);
   OS << " __attribute__((ext_vector_type(";
   OS << T->getNumElements();
   OS << ")))";
 }
 
-void TypePrinter::printConstantMatrixBefore(const ConstantMatrixType *T,
+void TypePrinter::printConstantMatrixBefore(ConstantMatrixType const *T,
                                             raw_ostream &OS) {
   printBefore(T->getElementType(), OS);
   OS << " __attribute__((matrix_type(";
@@ -774,13 +769,13 @@
   OS << ")))";
 }
 
-void TypePrinter::printConstantMatrixAfter(const ConstantMatrixType *T,
+void TypePrinter::printConstantMatrixAfter(ConstantMatrixType const *T,
                                            raw_ostream &OS) {
   printAfter(T->getElementType(), OS);
 }
 
 void TypePrinter::printDependentSizedMatrixBefore(
-    const DependentSizedMatrixType *T, raw_ostream &OS) {
+    DependentSizedMatrixType const *T, raw_ostream &OS) {
   printBefore(T->getElementType(), OS);
   OS << " __attribute__((matrix_type(";
   if (T->getRowExpr()) {
@@ -794,14 +789,12 @@
 }
 
 void TypePrinter::printDependentSizedMatrixAfter(
-    const DependentSizedMatrixType *T, raw_ostream &OS) {
+    DependentSizedMatrixType const *T, raw_ostream &OS) {
   printAfter(T->getElementType(), OS);
 }
 
-void
-FunctionProtoType::printExceptionSpecification(raw_ostream &OS,
-                                               const PrintingPolicy &Policy)
-                                                                         const {
+void FunctionProtoType::printExceptionSpecification(
+    raw_ostream &OS, PrintingPolicy const &Policy) const {
   if (hasDynamicExceptionSpec()) {
     OS << " throw(";
     if (getExceptionSpecType() == EST_MSAny)
@@ -829,7 +822,7 @@
   }
 }
 
-void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T,
+void TypePrinter::printFunctionProtoBefore(FunctionProtoType const *T,
                                            raw_ostream &OS) {
   if (T->hasTrailingReturn()) {
     OS << "auto ";
@@ -860,7 +853,7 @@
   llvm_unreachable("bad parameter ABI kind");
 }
 
-void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T,
+void TypePrinter::printFunctionProtoAfter(FunctionProtoType const *T,
                                           raw_ostream &OS) {
   // If needed for precedence reasons, wrap the inner part in grouping parens.
   if (!HasEmptyPlaceHolder)
@@ -871,10 +864,12 @@
   {
     ParamPolicyRAII ParamPolicy(Policy);
     for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) {
-      if (i) OS << ", ";
+      if (i)
+        OS << ", ";
 
       auto EPI = T->getExtParameterInfo(i);
-      if (EPI.isConsumed()) OS << "__attribute__((ns_consumed)) ";
+      if (EPI.isConsumed())
+        OS << "__attribute__((ns_consumed)) ";
       if (EPI.isNoEscape())
         OS << "__attribute__((noescape)) ";
       auto ABI = EPI.getABI();
@@ -924,15 +919,16 @@
     printAfter(T->getReturnType(), OS);
 }
 
-void TypePrinter::printFunctionAfter(const FunctionType::ExtInfo &Info,
+void TypePrinter::printFunctionAfter(FunctionType::ExtInfo const &Info,
                                      raw_ostream &OS) {
   if (!InsideCCAttribute) {
     switch (Info.getCC()) {
     case CC_C:
-      // The C calling convention is the default on the vast majority of platforms
-      // we support.  If the user wrote it explicitly, it will usually be printed
-      // while traversing the AttributedType.  If the type has been desugared, let
-      // the canonical spelling be the implicit calling convention.
+      // The C calling convention is the default on the vast majority of
+      // platforms we support.  If the user wrote it explicitly, it will usually
+      // be printed while traversing the AttributedType.  If the type has been
+      // desugared, let the canonical spelling be the implicit calling
+      // convention.
       // FIXME: It would be better to be explicit in certain contexts, such as a
       // cdecl function typedef used to declare a member function with the
       // Microsoft C++ ABI.
@@ -999,15 +995,14 @@
   if (Info.getProducesResult())
     OS << " __attribute__((ns_returns_retained))";
   if (Info.getRegParm())
-    OS << " __attribute__((regparm ("
-       << Info.getRegParm() << ")))";
+    OS << " __attribute__((regparm (" << Info.getRegParm() << ")))";
   if (Info.getNoCallerSavedRegs())
     OS << " __attribute__((no_caller_saved_registers))";
   if (Info.getNoCfCheck())
     OS << " __attribute__((nocf_check))";
 }
 
-void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T,
+void TypePrinter::printFunctionNoProtoBefore(FunctionNoProtoType const *T,
                                              raw_ostream &OS) {
   // If needed for precedence reasons, wrap the inner part in grouping parens.
   SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false);
@@ -1016,7 +1011,7 @@
     OS << '(';
 }
 
-void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T,
+void TypePrinter::printFunctionNoProtoAfter(FunctionNoProtoType const *T,
                                             raw_ostream &OS) {
   // If needed for precedence reasons, wrap the inner part in grouping parens.
   if (!HasEmptyPlaceHolder)
@@ -1041,19 +1036,19 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T,
+void TypePrinter::printUnresolvedUsingBefore(UnresolvedUsingType const *T,
                                              raw_ostream &OS) {
   printTypeSpec(T->getDecl(), OS);
 }
 
-void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T,
+void TypePrinter::printUnresolvedUsingAfter(UnresolvedUsingType const *T,
                                             raw_ostream &OS) {}
 
-void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) {
+void TypePrinter::printTypedefBefore(TypedefType const *T, raw_ostream &OS) {
   printTypeSpec(T->getDecl(), OS);
 }
 
-void TypePrinter::printMacroQualifiedBefore(const MacroQualifiedType *T,
+void TypePrinter::printMacroQualifiedBefore(MacroQualifiedType const *T,
                                             raw_ostream &OS) {
   StringRef MacroName = T->getMacroIdentifier()->getName();
   OS << MacroName << " ";
@@ -1063,14 +1058,14 @@
   printBefore(T->getModifiedType(), OS);
 }
 
-void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T,
+void TypePrinter::printMacroQualifiedAfter(MacroQualifiedType const *T,
                                            raw_ostream &OS) {
   printAfter(T->getModifiedType(), OS);
 }
 
-void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {}
+void TypePrinter::printTypedefAfter(TypedefType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T,
+void TypePrinter::printTypeOfExprBefore(TypeOfExprType const *T,
                                         raw_ostream &OS) {
   OS << "typeof ";
   if (T->getUnderlyingExpr())
@@ -1078,19 +1073,19 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T,
+void TypePrinter::printTypeOfExprAfter(TypeOfExprType const *T,
                                        raw_ostream &OS) {}
 
-void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) {
+void TypePrinter::printTypeOfBefore(TypeOfType const *T, raw_ostream &OS) {
   OS << "typeof(";
   print(T->getUnderlyingType(), OS, StringRef());
   OS << ')';
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {}
+void TypePrinter::printTypeOfAfter(TypeOfType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
+void TypePrinter::printDecltypeBefore(DecltypeType const *T, raw_ostream &OS) {
   OS << "decltype(";
   if (T->getUnderlyingExpr())
     T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
@@ -1098,37 +1093,37 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}
+void TypePrinter::printDecltypeAfter(DecltypeType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
+void TypePrinter::printUnaryTransformBefore(UnaryTransformType const *T,
                                             raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   switch (T->getUTTKind()) {
-    case UnaryTransformType::EnumUnderlyingType:
-      OS << "__underlying_type(";
-      print(T->getBaseType(), OS, StringRef());
-      OS << ')';
-      spaceBeforePlaceHolder(OS);
-      return;
+  case UnaryTransformType::EnumUnderlyingType:
+    OS << "__underlying_type(";
+    print(T->getBaseType(), OS, StringRef());
+    OS << ')';
+    spaceBeforePlaceHolder(OS);
+    return;
   }
 
   printBefore(T->getBaseType(), OS);
 }
 
-void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
+void TypePrinter::printUnaryTransformAfter(UnaryTransformType const *T,
                                            raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   switch (T->getUTTKind()) {
-    case UnaryTransformType::EnumUnderlyingType:
-      return;
+  case UnaryTransformType::EnumUnderlyingType:
+    return;
   }
 
   printAfter(T->getBaseType(), OS);
 }
 
-void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
+void TypePrinter::printAutoBefore(AutoType const *T, raw_ostream &OS) {
   // If the type has been deduced, do not print 'auto'.
   if (!T->getDeducedType().isNull()) {
     printBefore(T->getDeducedType(), OS);
@@ -1145,22 +1140,28 @@
       OS << ' ';
     }
     switch (T->getKeyword()) {
-    case AutoTypeKeyword::Auto: OS << "auto"; break;
-    case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break;
-    case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break;
+    case AutoTypeKeyword::Auto:
+      OS << "auto";
+      break;
+    case AutoTypeKeyword::DecltypeAuto:
+      OS << "decltype(auto)";
+      break;
+    case AutoTypeKeyword::GNUAutoType:
+      OS << "__auto_type";
+      break;
     }
     spaceBeforePlaceHolder(OS);
   }
 }
 
-void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) {
+void TypePrinter::printAutoAfter(AutoType const *T, raw_ostream &OS) {
   // If the type has been deduced, do not print 'auto'.
   if (!T->getDeducedType().isNull())
     printAfter(T->getDeducedType(), OS);
 }
 
 void TypePrinter::printDeducedTemplateSpecializationBefore(
-    const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
+    DeducedTemplateSpecializationType const *T, raw_ostream &OS) {
   // If the type has been deduced, print the deduced type.
   if (!T->getDeducedType().isNull()) {
     printBefore(T->getDeducedType(), OS);
@@ -1172,13 +1173,13 @@
 }
 
 void TypePrinter::printDeducedTemplateSpecializationAfter(
-    const DeducedTemplateSpecializationType *T, raw_ostream &OS) {
+    DeducedTemplateSpecializationType const *T, raw_ostream &OS) {
   // If the type has been deduced, print the deduced type.
   if (!T->getDeducedType().isNull())
     printAfter(T->getDeducedType(), OS);
 }
 
-void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) {
+void TypePrinter::printAtomicBefore(AtomicType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   OS << "_Atomic(";
@@ -1187,9 +1188,9 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {}
+void TypePrinter::printAtomicAfter(AtomicType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) {
+void TypePrinter::printPipeBefore(PipeType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   if (T->isReadOnly())
@@ -1201,18 +1202,18 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {}
+void TypePrinter::printPipeAfter(PipeType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printExtIntBefore(const ExtIntType *T, raw_ostream &OS) {
+void TypePrinter::printExtIntBefore(ExtIntType const *T, raw_ostream &OS) {
   if (T->isUnsigned())
     OS << "unsigned ";
   OS << "_ExtInt(" << T->getNumBits() << ")";
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printExtIntAfter(const ExtIntType *T, raw_ostream &OS) {}
+void TypePrinter::printExtIntAfter(ExtIntType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printDependentExtIntBefore(const DependentExtIntType *T,
+void TypePrinter::printDependentExtIntBefore(DependentExtIntType const *T,
                                              raw_ostream &OS) {
   if (T->isUnsigned())
     OS << "unsigned ";
@@ -1222,7 +1223,7 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printDependentExtIntAfter(const DependentExtIntType *T,
+void TypePrinter::printDependentExtIntAfter(DependentExtIntType const *T,
                                             raw_ostream &OS) {}
 
 /// Appends the given scope to the end of a string.
@@ -1239,7 +1240,7 @@
   if (Policy.Callbacks && Policy.Callbacks->isScopeVisible(DC))
     return;
 
-  if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
+  if (auto const *NS = dyn_cast<NamespaceDecl>(DC)) {
     if (Policy.SuppressUnwrittenScope && NS->isAnonymousNamespace())
       return AppendScope(DC->getParent(), OS, NameInScope);
 
@@ -1254,16 +1255,16 @@
       OS << NS->getName() << "::";
     else
       OS << "(anonymous namespace)::";
-  } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
+  } else if (auto const *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
     AppendScope(DC->getParent(), OS, Spec->getDeclName());
     IncludeStrongLifetimeRAII Strong(Policy);
     OS << Spec->getIdentifier()->getName();
-    const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
+    TemplateArgumentList const &TemplateArgs = Spec->getTemplateArgs();
     printTemplateArgumentList(
         OS, TemplateArgs.asArray(), Policy,
         Spec->getSpecializedTemplate()->getTemplateParameters());
     OS << "::";
-  } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) {
+  } else if (auto const *Tag = dyn_cast<TagDecl>(DC)) {
     AppendScope(DC->getParent(), OS, Tag->getDeclName());
     if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl())
       OS << Typedef->getIdentifier()->getName() << "::";
@@ -1301,7 +1302,7 @@
   if (!Policy.SuppressScope)
     AppendScope(D->getDeclContext(), OS, D->getDeclName());
 
-  if (const IdentifierInfo *II = D->getIdentifier())
+  if (IdentifierInfo const *II = D->getIdentifier())
     OS << II->getName();
   else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) {
     assert(Typedef->getIdentifier() && "Typedef without identifier?");
@@ -1314,7 +1315,8 @@
     if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) {
       OS << "lambda";
       HasKindDecoration = true;
-    } else if ((isa<RecordDecl>(D) && cast<RecordDecl>(D)->isAnonymousStructOrUnion())) {
+    } else if ((isa<RecordDecl>(D) &&
+                cast<RecordDecl>(D)->isAnonymousStructOrUnion())) {
       OS << "anonymous";
     } else {
       OS << "unnamed";
@@ -1345,15 +1347,15 @@
 
   // If this is a class template specialization, print the template
   // arguments.
-  if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
+  if (auto const *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
     ArrayRef<TemplateArgument> Args;
     TypeSourceInfo *TAW = Spec->getTypeAsWritten();
     if (!Policy.PrintCanonicalTypes && TAW) {
-      const TemplateSpecializationType *TST =
-        cast<TemplateSpecializationType>(TAW->getType());
+      TemplateSpecializationType const *TST =
+          cast<TemplateSpecializationType>(TAW->getType());
       Args = TST->template_arguments();
     } else {
-      const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
+      TemplateArgumentList const &TemplateArgs = Spec->getTemplateArgs();
       Args = TemplateArgs.asArray();
     }
     IncludeStrongLifetimeRAII Strong(Policy);
@@ -1365,9 +1367,9 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) {
+void TypePrinter::printRecordBefore(RecordType const *T, raw_ostream &OS) {
   // Print the preferred name if we have one for this type.
-  for (const auto *PNA : T->getDecl()->specific_attrs<PreferredNameAttr>()) {
+  for (auto const *PNA : T->getDecl()->specific_attrs<PreferredNameAttr>()) {
     if (declaresSameEntity(PNA->getTypedefType()->getAsCXXRecordDecl(),
                            T->getDecl())) {
       // Find the outermost typedef or alias template.
@@ -1385,15 +1387,15 @@
   printTag(T->getDecl(), OS);
 }
 
-void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {}
+void TypePrinter::printRecordAfter(RecordType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) {
+void TypePrinter::printEnumBefore(EnumType const *T, raw_ostream &OS) {
   printTag(T->getDecl(), OS);
 }
 
-void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {}
+void TypePrinter::printEnumAfter(EnumType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
+void TypePrinter::printTemplateTypeParmBefore(TemplateTypeParmType const *T,
                                               raw_ostream &OS) {
   TemplateTypeParmDecl *D = T->getDecl();
   if (D && D->isImplicit()) {
@@ -1410,38 +1412,34 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T,
+void TypePrinter::printTemplateTypeParmAfter(TemplateTypeParmType const *T,
                                              raw_ostream &OS) {}
 
 void TypePrinter::printSubstTemplateTypeParmBefore(
-                                             const SubstTemplateTypeParmType *T,
-                                             raw_ostream &OS) {
+    SubstTemplateTypeParmType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   printBefore(T->getReplacementType(), OS);
 }
 
 void TypePrinter::printSubstTemplateTypeParmAfter(
-                                             const SubstTemplateTypeParmType *T,
-                                             raw_ostream &OS) {
+    SubstTemplateTypeParmType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   printAfter(T->getReplacementType(), OS);
 }
 
 void TypePrinter::printSubstTemplateTypeParmPackBefore(
-                                        const SubstTemplateTypeParmPackType *T,
-                                        raw_ostream &OS) {
+    SubstTemplateTypeParmPackType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   printTemplateTypeParmBefore(T->getReplacedParameter(), OS);
 }
 
 void TypePrinter::printSubstTemplateTypeParmPackAfter(
-                                        const SubstTemplateTypeParmPackType *T,
-                                        raw_ostream &OS) {
+    SubstTemplateTypeParmPackType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
   printTemplateTypeParmAfter(T->getReplacedParameter(), OS);
 }
 
-void TypePrinter::printTemplateId(const TemplateSpecializationType *T,
+void TypePrinter::printTemplateId(TemplateSpecializationType const *T,
                                   raw_ostream &OS, bool FullyQualify) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
@@ -1461,16 +1459,14 @@
 }
 
 void TypePrinter::printTemplateSpecializationBefore(
-                                            const TemplateSpecializationType *T,
-                                            raw_ostream &OS) {
+    TemplateSpecializationType const *T, raw_ostream &OS) {
   printTemplateId(T, OS, Policy.FullyQualifiedName);
 }
 
 void TypePrinter::printTemplateSpecializationAfter(
-                                            const TemplateSpecializationType *T,
-                                            raw_ostream &OS) {}
+    TemplateSpecializationType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T,
+void TypePrinter::printInjectedClassNameBefore(InjectedClassNameType const *T,
                                                raw_ostream &OS) {
   if (Policy.PrintInjectedClassNameWithArguments)
     return printTemplateSpecializationBefore(T->getInjectedTST(), OS);
@@ -1480,10 +1476,10 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T,
-                                               raw_ostream &OS) {}
+void TypePrinter::printInjectedClassNameAfter(InjectedClassNameType const *T,
+                                              raw_ostream &OS) {}
 
-void TypePrinter::printElaboratedBefore(const ElaboratedType *T,
+void TypePrinter::printElaboratedBefore(ElaboratedType const *T,
                                         raw_ostream &OS) {
   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) {
     TagDecl *OwnedTagDecl = T->getOwnedTagDecl();
@@ -1497,8 +1493,7 @@
   }
 
   // The tag definition will take care of these.
-  if (!Policy.IncludeTagDefinition)
-  {
+  if (!Policy.IncludeTagDefinition) {
     OS << TypeWithKeyword::getKeywordName(T->getKeyword());
     if (T->getKeyword() != ETK_None)
       OS << " ";
@@ -1511,15 +1506,15 @@
   printBefore(T->getNamedType(), OS);
 }
 
-void TypePrinter::printElaboratedAfter(const ElaboratedType *T,
-                                        raw_ostream &OS) {
+void TypePrinter::printElaboratedAfter(ElaboratedType const *T,
+                                       raw_ostream &OS) {
   if (Policy.IncludeTagDefinition && T->getOwnedTagDecl())
     return;
   ElaboratedTypePolicyRAII PolicyRAII(Policy);
   printAfter(T->getNamedType(), OS);
 }
 
-void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) {
+void TypePrinter::printParenBefore(ParenType const *T, raw_ostream &OS) {
   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
     printBefore(T->getInnerType(), OS);
     OS << '(';
@@ -1527,7 +1522,7 @@
     printBefore(T->getInnerType(), OS);
 }
 
-void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) {
+void TypePrinter::printParenAfter(ParenType const *T, raw_ostream &OS) {
   if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) {
     OS << ')';
     printAfter(T->getInnerType(), OS);
@@ -1535,7 +1530,7 @@
     printAfter(T->getInnerType(), OS);
 }
 
-void TypePrinter::printDependentNameBefore(const DependentNameType *T,
+void TypePrinter::printDependentNameBefore(DependentNameType const *T,
                                            raw_ostream &OS) {
   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
   if (T->getKeyword() != ETK_None)
@@ -1547,11 +1542,11 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printDependentNameAfter(const DependentNameType *T,
+void TypePrinter::printDependentNameAfter(DependentNameType const *T,
                                           raw_ostream &OS) {}
 
 void TypePrinter::printDependentTemplateSpecializationBefore(
-        const DependentTemplateSpecializationType *T, raw_ostream &OS) {
+    DependentTemplateSpecializationType const *T, raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   OS << TypeWithKeyword::getKeywordName(T->getKeyword());
@@ -1566,20 +1561,20 @@
 }
 
 void TypePrinter::printDependentTemplateSpecializationAfter(
-        const DependentTemplateSpecializationType *T, raw_ostream &OS) {}
+    DependentTemplateSpecializationType const *T, raw_ostream &OS) {}
 
-void TypePrinter::printPackExpansionBefore(const PackExpansionType *T,
+void TypePrinter::printPackExpansionBefore(PackExpansionType const *T,
                                            raw_ostream &OS) {
   printBefore(T->getPattern(), OS);
 }
 
-void TypePrinter::printPackExpansionAfter(const PackExpansionType *T,
+void TypePrinter::printPackExpansionAfter(PackExpansionType const *T,
                                           raw_ostream &OS) {
   printAfter(T->getPattern(), OS);
   OS << "...";
 }
 
-void TypePrinter::printAttributedBefore(const AttributedType *T,
+void TypePrinter::printAttributedBefore(AttributedType const *T,
                                         raw_ostream &OS) {
   // FIXME: Generate this with TableGen.
 
@@ -1598,11 +1593,20 @@
 
   if (T->isMSTypeSpec()) {
     switch (T->getAttrKind()) {
-    default: return;
-    case attr::Ptr32: OS << " __ptr32"; break;
-    case attr::Ptr64: OS << " __ptr64"; break;
-    case attr::SPtr: OS << " __sptr"; break;
-    case attr::UPtr: OS << " __uptr"; break;
+    default:
+      return;
+    case attr::Ptr32:
+      OS << " __ptr32";
+      break;
+    case attr::Ptr64:
+      OS << " __ptr64";
+      break;
+    case attr::SPtr:
+      OS << " __sptr";
+      break;
+    case attr::UPtr:
+      OS << " __uptr";
+      break;
     }
     spaceBeforePlaceHolder(OS);
   }
@@ -1623,7 +1627,7 @@
   }
 }
 
-void TypePrinter::printAttributedAfter(const AttributedType *T,
+void TypePrinter::printAttributedAfter(AttributedType const *T,
                                        raw_ostream &OS) {
   // FIXME: Generate this with TableGen.
 
@@ -1640,8 +1644,8 @@
 
   // Some attributes are printed as qualifiers before the type, so we have
   // nothing left to do.
-  if (T->getAttrKind() == attr::ObjCKindOf ||
-      T->isMSTypeSpec() || T->getImmediateNullability())
+  if (T->getAttrKind() == attr::ObjCKindOf || T->isMSTypeSpec() ||
+      T->getImmediateNullability())
     return;
 
   // Don't print the inert __unsafe_unretained attribute at all.
@@ -1650,8 +1654,10 @@
 
   // Don't print ns_returns_retained unless it had an effect.
   if (T->getAttrKind() == attr::NSReturnsRetained &&
-      !T->getEquivalentType()->castAs<FunctionType>()
-                             ->getExtInfo().getProducesResult())
+      !T->getEquivalentType()
+           ->castAs<FunctionType>()
+           ->getExtInfo()
+           .getProducesResult())
     return;
 
   if (T->getAttrKind() == attr::LifetimeBound) {
@@ -1707,30 +1713,59 @@
 
   // FIXME: When Sema learns to form this AttributedType, avoid printing the
   // attribute again in printFunctionProtoAfter.
-  case attr::AnyX86NoCfCheck: OS << "nocf_check"; break;
-  case attr::CDecl: OS << "cdecl"; break;
-  case attr::FastCall: OS << "fastcall"; break;
-  case attr::StdCall: OS << "stdcall"; break;
-  case attr::ThisCall: OS << "thiscall"; break;
-  case attr::SwiftCall: OS << "swiftcall"; break;
-  case attr::SwiftAsyncCall: OS << "swiftasynccall"; break;
-  case attr::VectorCall: OS << "vectorcall"; break;
-  case attr::Pascal: OS << "pascal"; break;
-  case attr::MSABI: OS << "ms_abi"; break;
-  case attr::SysVABI: OS << "sysv_abi"; break;
-  case attr::RegCall: OS << "regcall"; break;
+  case attr::AnyX86NoCfCheck:
+    OS << "nocf_check";
+    break;
+  case attr::CDecl:
+    OS << "cdecl";
+    break;
+  case attr::FastCall:
+    OS << "fastcall";
+    break;
+  case attr::StdCall:
+    OS << "stdcall";
+    break;
+  case attr::ThisCall:
+    OS << "thiscall";
+    break;
+  case attr::SwiftCall:
+    OS << "swiftcall";
+    break;
+  case attr::SwiftAsyncCall:
+    OS << "swiftasynccall";
+    break;
+  case attr::VectorCall:
+    OS << "vectorcall";
+    break;
+  case attr::Pascal:
+    OS << "pascal";
+    break;
+  case attr::MSABI:
+    OS << "ms_abi";
+    break;
+  case attr::SysVABI:
+    OS << "sysv_abi";
+    break;
+  case attr::RegCall:
+    OS << "regcall";
+    break;
   case attr::Pcs: {
     OS << "pcs(";
-   QualType t = T->getEquivalentType();
-   while (!t->isFunctionType())
-     t = t->getPointeeType();
-   OS << (t->castAs<FunctionType>()->getCallConv() == CC_AAPCS ?
-         "\"aapcs\"" : "\"aapcs-vfp\"");
-   OS << ')';
-   break;
-  }
-  case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break;
-  case attr::IntelOclBicc: OS << "inteloclbicc"; break;
+    QualType t = T->getEquivalentType();
+    while (!t->isFunctionType())
+      t = t->getPointeeType();
+    OS << (t->castAs<FunctionType>()->getCallConv() == CC_AAPCS
+               ? "\"aapcs\""
+               : "\"aapcs-vfp\"");
+    OS << ')';
+    break;
+  }
+  case attr::AArch64VectorPcs:
+    OS << "aarch64_vector_pcs";
+    break;
+  case attr::IntelOclBicc:
+    OS << "inteloclbicc";
+    break;
   case attr::PreserveMost:
     OS << "preserve_most";
     break;
@@ -1751,22 +1786,22 @@
   OS << "))";
 }
 
-void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T,
+void TypePrinter::printObjCInterfaceBefore(ObjCInterfaceType const *T,
                                            raw_ostream &OS) {
   OS << T->getDecl()->getName();
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T,
+void TypePrinter::printObjCInterfaceAfter(ObjCInterfaceType const *T,
                                           raw_ostream &OS) {}
 
-void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T,
-                                          raw_ostream &OS) {
+void TypePrinter::printObjCTypeParamBefore(ObjCTypeParamType const *T,
+                                           raw_ostream &OS) {
   OS << T->getDecl()->getName();
   if (!T->qual_empty()) {
     bool isFirst = true;
     OS << '<';
-    for (const auto *I : T->quals()) {
+    for (auto const *I : T->quals()) {
       if (isFirst)
         isFirst = false;
       else
@@ -1779,10 +1814,10 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T,
+void TypePrinter::printObjCTypeParamAfter(ObjCTypeParamType const *T,
                                           raw_ostream &OS) {}
 
-void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T,
+void TypePrinter::printObjCObjectBefore(ObjCObjectType const *T,
                                         raw_ostream &OS) {
   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
       !T->isKindOfTypeAsWritten())
@@ -1810,7 +1845,7 @@
   if (!T->qual_empty()) {
     bool isFirst = true;
     OS << '<';
-    for (const auto *I : T->quals()) {
+    for (auto const *I : T->quals()) {
       if (isFirst)
         isFirst = false;
       else
@@ -1823,14 +1858,14 @@
   spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T,
-                                        raw_ostream &OS) {
+void TypePrinter::printObjCObjectAfter(ObjCObjectType const *T,
+                                       raw_ostream &OS) {
   if (T->qual_empty() && T->isUnspecializedAsWritten() &&
       !T->isKindOfTypeAsWritten())
     return printAfter(T->getBaseType(), OS);
 }
 
-void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T,
+void TypePrinter::printObjCObjectPointerBefore(ObjCObjectPointerType const *T,
                                                raw_ostream &OS) {
   printBefore(T->getPointeeType(), OS);
 
@@ -1843,25 +1878,26 @@
   }
 }
 
-void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T,
+void TypePrinter::printObjCObjectPointerAfter(ObjCObjectPointerType const *T,
                                               raw_ostream &OS) {}
 
-static
-const TemplateArgument &getArgument(const TemplateArgument &A) { return A; }
+static TemplateArgument const &getArgument(TemplateArgument const &A) {
+  return A;
+}
 
-static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) {
+static TemplateArgument const &getArgument(TemplateArgumentLoc const &A) {
   return A.getArgument();
 }
 
-static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP,
+static void printArgument(TemplateArgument const &A, PrintingPolicy const &PP,
                           llvm::raw_ostream &OS, bool IncludeType) {
   A.print(PP, OS, IncludeType);
 }
 
-static void printArgument(const TemplateArgumentLoc &A,
-                          const PrintingPolicy &PP, llvm::raw_ostream &OS,
+static void printArgument(TemplateArgumentLoc const &A,
+                          PrintingPolicy const &PP, llvm::raw_ostream &OS,
                           bool IncludeType) {
-  const TemplateArgument::ArgKind &Kind = A.getArgument().getKind();
+  TemplateArgument::ArgKind const &Kind = A.getArgument().getKind();
   if (Kind == TemplateArgument::ArgKind::Type)
     return A.getTypeSourceInfo()->getType().print(OS, PP);
   return A.getArgument().print(PP, OS, IncludeType);
@@ -1978,7 +2014,7 @@
 /// Make a best-effort determination of whether the type T can be produced by
 /// substituting Args into the default argument of Param.
 static bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
-                                         const NamedDecl *Param,
+                                         NamedDecl const *Param,
                                          ArrayRef<TemplateArgument> Args,
                                          unsigned Depth) {
   // An empty pack is equivalent to not providing a pack argument.
@@ -2003,8 +2039,8 @@
 
 template <typename TA>
 static void
-printTo(raw_ostream &OS, ArrayRef<TA> Args, const PrintingPolicy &Policy,
-        const TemplateParameterList *TPL, bool IsPack, unsigned ParmIndex) {
+printTo(raw_ostream &OS, ArrayRef<TA> Args, PrintingPolicy const &Policy,
+        TemplateParameterList const *TPL, bool IsPack, unsigned ParmIndex) {
   // Drop trailing template arguments that match default arguments.
   if (TPL && Policy.SuppressDefaultTemplateArgs &&
       !Policy.PrintCanonicalTypes && !Args.empty() && !IsPack &&
@@ -2020,17 +2056,17 @@
       Args = Args.drop_back();
   }
 
-  const char *Comma = Policy.MSVCFormatting ? "," : ", ";
+  char const *Comma = Policy.MSVCFormatting ? "," : ", ";
   if (!IsPack)
     OS << '<';
 
   bool NeedSpace = false;
   bool FirstArg = true;
-  for (const auto &Arg : Args) {
+  for (auto const &Arg : Args) {
     // Print the argument into a string.
     SmallString<128> Buf;
     llvm::raw_svector_ostream ArgOS(Buf);
-    const TemplateArgument &Argument = getArgument(Arg);
+    TemplateArgument const &Argument = getArgument(Arg);
     if (Argument.getKind() == TemplateArgument::Pack) {
       if (Argument.pack_size() && !FirstArg)
         OS << Comma;
@@ -2074,23 +2110,23 @@
 }
 
 void clang::printTemplateArgumentList(raw_ostream &OS,
-                                      const TemplateArgumentListInfo &Args,
-                                      const PrintingPolicy &Policy,
-                                      const TemplateParameterList *TPL) {
+                                      TemplateArgumentListInfo const &Args,
+                                      PrintingPolicy const &Policy,
+                                      TemplateParameterList const *TPL) {
   printTemplateArgumentList(OS, Args.arguments(), Policy, TPL);
 }
 
 void clang::printTemplateArgumentList(raw_ostream &OS,
                                       ArrayRef<TemplateArgument> Args,
-                                      const PrintingPolicy &Policy,
-                                      const TemplateParameterList *TPL) {
+                                      PrintingPolicy const &Policy,
+                                      TemplateParameterList const *TPL) {
   printTo(OS, Args, Policy, TPL, /*isPack*/ false, /*parmIndex*/ 0);
 }
 
 void clang::printTemplateArgumentList(raw_ostream &OS,
                                       ArrayRef<TemplateArgumentLoc> Args,
-                                      const PrintingPolicy &Policy,
-                                      const TemplateParameterList *TPL) {
+                                      PrintingPolicy const &Policy,
+                                      TemplateParameterList const *TPL) {
   printTo(OS, Args, Policy, TPL, /*isPack*/ false, /*parmIndex*/ 0);
 }
 
@@ -2102,14 +2138,14 @@
 // Appends qualifiers to the given string, separated by spaces.  Will
 // prefix a space if the string is non-empty.  Will not append a final
 // space.
-std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const {
+std::string Qualifiers::getAsString(PrintingPolicy const &Policy) const {
   SmallString<64> Buf;
   llvm::raw_svector_ostream StrOS(Buf);
   print(StrOS, Policy);
   return std::string(StrOS.str());
 }
 
-bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const {
+bool Qualifiers::isEmptyWhenPrinted(PrintingPolicy const &Policy) const {
   if (getCVRQualifiers())
     return false;
 
@@ -2169,7 +2205,7 @@
 // Appends qualifiers to the given string, separated by spaces.  Will
 // prefix a space if the string is non-empty.  Will not append a final
 // space.
-void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy,
+void Qualifiers::print(raw_ostream &OS, PrintingPolicy const &Policy,
                        bool appendSpaceIfNonEmpty) const {
   bool addSpace = false;
 
@@ -2206,22 +2242,30 @@
       OS << "__strong";
   }
   if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) {
-    if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){
+    if (!(lifetime == Qualifiers::OCL_Strong &&
+          Policy.SuppressStrongLifetime)) {
       if (addSpace)
         OS << ' ';
       addSpace = true;
     }
 
     switch (lifetime) {
-    case Qualifiers::OCL_None: llvm_unreachable("none but true");
-    case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break;
+    case Qualifiers::OCL_None:
+      llvm_unreachable("none but true");
+    case Qualifiers::OCL_ExplicitNone:
+      OS << "__unsafe_unretained";
+      break;
     case Qualifiers::OCL_Strong:
       if (!Policy.SuppressStrongLifetime)
         OS << "__strong";
       break;
 
-    case Qualifiers::OCL_Weak: OS << "__weak"; break;
-    case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break;
+    case Qualifiers::OCL_Weak:
+      OS << "__weak";
+      break;
+    case Qualifiers::OCL_Autoreleasing:
+      OS << "__autoreleasing";
+      break;
     }
   }
 
@@ -2233,28 +2277,28 @@
   return getAsString(split(), LangOptions());
 }
 
-std::string QualType::getAsString(const PrintingPolicy &Policy) const {
+std::string QualType::getAsString(PrintingPolicy const &Policy) const {
   std::string S;
   getAsStringInternal(S, Policy);
   return S;
 }
 
-std::string QualType::getAsString(const Type *ty, Qualifiers qs,
-                                  const PrintingPolicy &Policy) {
+std::string QualType::getAsString(Type const *ty, Qualifiers qs,
+                                  PrintingPolicy const &Policy) {
   std::string buffer;
   getAsStringInternal(ty, qs, buffer, Policy);
   return buffer;
 }
 
-void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy,
-                     const Twine &PlaceHolder, unsigned Indentation) const {
+void QualType::print(raw_ostream &OS, PrintingPolicy const &Policy,
+                     Twine const &PlaceHolder, unsigned Indentation) const {
   print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder,
         Indentation);
 }
 
-void QualType::print(const Type *ty, Qualifiers qs,
-                     raw_ostream &OS, const PrintingPolicy &policy,
-                     const Twine &PlaceHolder, unsigned Indentation) {
+void QualType::print(Type const *ty, Qualifiers qs, raw_ostream &OS,
+                     PrintingPolicy const &policy, Twine const &PlaceHolder,
+                     unsigned Indentation) {
   SmallString<128> PHBuf;
   StringRef PH = PlaceHolder.toStringRef(PHBuf);
 
@@ -2262,14 +2306,14 @@
 }
 
 void QualType::getAsStringInternal(std::string &Str,
-                                   const PrintingPolicy &Policy) const {
+                                   PrintingPolicy const &Policy) const {
   return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str,
                              Policy);
 }
 
-void QualType::getAsStringInternal(const Type *ty, Qualifiers qs,
+void QualType::getAsStringInternal(Type const *ty, Qualifiers qs,
                                    std::string &buffer,
-                                   const PrintingPolicy &policy) {
+                                   PrintingPolicy const &policy) {
   SmallString<256> Buf;
   llvm::raw_svector_ostream StrOS(Buf);
   TypePrinter(policy).print(ty, qs, StrOS, buffer);
Index: clang/lib/AST/VTTBuilder.cpp
===================================================================
--- clang/lib/AST/VTTBuilder.cpp
+++ clang/lib/AST/VTTBuilder.cpp
@@ -28,8 +28,7 @@
 
 #define DUMP_OVERRIDERS 0
 
-VTTBuilder::VTTBuilder(ASTContext &Ctx,
-                       const CXXRecordDecl *MostDerivedClass,
+VTTBuilder::VTTBuilder(ASTContext &Ctx, CXXRecordDecl const *MostDerivedClass,
                        bool GenerateDefinition)
     : Ctx(Ctx), MostDerivedClass(MostDerivedClass),
       MostDerivedClassLayout(Ctx.getASTRecordLayout(MostDerivedClass)),
@@ -40,7 +39,7 @@
 }
 
 void VTTBuilder::AddVTablePointer(BaseSubobject Base, uint64_t VTableIndex,
-                                  const CXXRecordDecl *VTableClass) {
+                                  CXXRecordDecl const *VTableClass) {
   // Store the vtable pointer index if we're generating the primary VTT.
   if (VTableClass == MostDerivedClass) {
     assert(!SecondaryVirtualPointerIndices.count(Base) &&
@@ -57,40 +56,37 @@
 }
 
 void VTTBuilder::LayoutSecondaryVTTs(BaseSubobject Base) {
-  const CXXRecordDecl *RD = Base.getBase();
+  CXXRecordDecl const *RD = Base.getBase();
 
-  for (const auto &I : RD->bases()) {
+  for (auto const &I : RD->bases()) {
     // Don't layout virtual bases.
     if (I.isVirtual())
-        continue;
+      continue;
 
-    const auto *BaseDecl =
+    auto const *BaseDecl =
         cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
 
-    const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
-    CharUnits BaseOffset = Base.getBaseOffset() +
-      Layout.getBaseClassOffset(BaseDecl);
+    ASTRecordLayout const &Layout = Ctx.getASTRecordLayout(RD);
+    CharUnits BaseOffset =
+        Base.getBaseOffset() + Layout.getBaseClassOffset(BaseDecl);
 
     // Layout the VTT for this base.
     LayoutVTT(BaseSubobject(BaseDecl, BaseOffset), /*BaseIsVirtual=*/false);
   }
 }
 
-void
-VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base,
-                                           bool BaseIsMorallyVirtual,
-                                           uint64_t VTableIndex,
-                                           const CXXRecordDecl *VTableClass,
-                                           VisitedVirtualBasesSetTy &VBases) {
-  const CXXRecordDecl *RD = Base.getBase();
+void VTTBuilder::LayoutSecondaryVirtualPointers(
+    BaseSubobject Base, bool BaseIsMorallyVirtual, uint64_t VTableIndex,
+    CXXRecordDecl const *VTableClass, VisitedVirtualBasesSetTy &VBases) {
+  CXXRecordDecl const *RD = Base.getBase();
 
   // We're not interested in bases that don't have virtual bases, and not
   // morally virtual bases.
   if (!RD->getNumVBases() && !BaseIsMorallyVirtual)
     return;
 
-  for (const auto &I : RD->bases()) {
-    const auto *BaseDecl =
+  for (auto const &I : RD->bases()) {
+    auto const *BaseDecl =
         cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
 
     // Itanium C++ ABI 2.6.2:
@@ -114,13 +110,11 @@
       BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
       BaseDeclIsMorallyVirtual = true;
     } else {
-      const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
+      ASTRecordLayout const &Layout = Ctx.getASTRecordLayout(RD);
 
-      BaseOffset = Base.getBaseOffset() +
-        Layout.getBaseClassOffset(BaseDecl);
+      BaseOffset = Base.getBaseOffset() + Layout.getBaseClassOffset(BaseDecl);
 
-      if (!Layout.isPrimaryBaseVirtual() &&
-          Layout.getPrimaryBase() == BaseDecl)
+      if (!Layout.isPrimaryBaseVirtual() && Layout.getPrimaryBase() == BaseDecl)
         BaseDeclIsNonVirtualPrimaryBase = true;
     }
 
@@ -143,18 +137,17 @@
   }
 }
 
-void
-VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base,
-                                           uint64_t VTableIndex) {
+void VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base,
+                                                uint64_t VTableIndex) {
   VisitedVirtualBasesSetTy VBases;
   LayoutSecondaryVirtualPointers(Base, /*BaseIsMorallyVirtual=*/false,
                                  VTableIndex, Base.getBase(), VBases);
 }
 
-void VTTBuilder::LayoutVirtualVTTs(const CXXRecordDecl *RD,
+void VTTBuilder::LayoutVirtualVTTs(CXXRecordDecl const *RD,
                                    VisitedVirtualBasesSetTy &VBases) {
-  for (const auto &I : RD->bases()) {
-    const auto *BaseDecl =
+  for (auto const &I : RD->bases()) {
+    auto const *BaseDecl =
         cast<CXXRecordDecl>(I.getType()->castAs<RecordType>()->getDecl());
 
     // Check if this is a virtual base.
@@ -164,7 +157,7 @@
         continue;
 
       CharUnits BaseOffset =
-        MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
+          MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
 
       LayoutVTT(BaseSubobject(BaseDecl, BaseOffset), /*BaseIsVirtual=*/true);
     }
@@ -177,7 +170,7 @@
 }
 
 void VTTBuilder::LayoutVTT(BaseSubobject Base, bool BaseIsVirtual) {
-  const CXXRecordDecl *RD = Base.getBase();
+  CXXRecordDecl const *RD = Base.getBase();
 
   // Itanium C++ ABI 2.6.2:
   //   An array of virtual table addresses, called the VTT, is declared for
Index: clang/lib/AST/VTableBuilder.cpp
===================================================================
--- clang/lib/AST/VTableBuilder.cpp
+++ clang/lib/AST/VTableBuilder.cpp
@@ -33,12 +33,12 @@
 /// indirect base class.
 struct BaseOffset {
   /// DerivedClass - The derived class.
-  const CXXRecordDecl *DerivedClass;
+  CXXRecordDecl const *DerivedClass;
 
   /// VirtualBase - If the path from the derived class to the base class
   /// involves virtual base classes, this holds the declaration of the last
   /// virtual base in this path (i.e. closest to the base class).
-  const CXXRecordDecl *VirtualBase;
+  CXXRecordDecl const *VirtualBase;
 
   /// NonVirtualOffset - The offset from the derived class to the base class.
   /// (Or the offset from the virtual base class to the base class, if the
@@ -46,12 +46,13 @@
   /// class.
   CharUnits NonVirtualOffset;
 
-  BaseOffset() : DerivedClass(nullptr), VirtualBase(nullptr),
-                 NonVirtualOffset(CharUnits::Zero()) { }
-  BaseOffset(const CXXRecordDecl *DerivedClass,
-             const CXXRecordDecl *VirtualBase, CharUnits NonVirtualOffset)
-    : DerivedClass(DerivedClass), VirtualBase(VirtualBase),
-    NonVirtualOffset(NonVirtualOffset) { }
+  BaseOffset()
+      : DerivedClass(nullptr), VirtualBase(nullptr),
+        NonVirtualOffset(CharUnits::Zero()) {}
+  BaseOffset(CXXRecordDecl const *DerivedClass,
+             CXXRecordDecl const *VirtualBase, CharUnits NonVirtualOffset)
+      : DerivedClass(DerivedClass), VirtualBase(VirtualBase),
+        NonVirtualOffset(NonVirtualOffset) {}
 
   bool isEmpty() const { return NonVirtualOffset.isZero() && !VirtualBase; }
 };
@@ -63,23 +64,23 @@
   /// OverriderInfo - Information about a final overrider.
   struct OverriderInfo {
     /// Method - The method decl of the overrider.
-    const CXXMethodDecl *Method;
+    CXXMethodDecl const *Method;
 
     /// VirtualBase - The virtual base class subobject of this overrider.
     /// Note that this records the closest derived virtual base class subobject.
-    const CXXRecordDecl *VirtualBase;
+    CXXRecordDecl const *VirtualBase;
 
     /// Offset - the base offset of the overrider's parent in the layout class.
     CharUnits Offset;
 
-    OverriderInfo() : Method(nullptr), VirtualBase(nullptr),
-                      Offset(CharUnits::Zero()) { }
+    OverriderInfo()
+        : Method(nullptr), VirtualBase(nullptr), Offset(CharUnits::Zero()) {}
   };
 
 private:
   /// MostDerivedClass - The most derived class for which the final overriders
   /// are stored.
-  const CXXRecordDecl *MostDerivedClass;
+  CXXRecordDecl const *MostDerivedClass;
 
   /// MostDerivedClassOffset - If we're building final overriders for a
   /// construction vtable, this holds the offset from the layout class to the
@@ -89,19 +90,18 @@
   /// LayoutClass - The class we're using for layout information. Will be
   /// different than the most derived class if the final overriders are for a
   /// construction vtable.
-  const CXXRecordDecl *LayoutClass;
+  CXXRecordDecl const *LayoutClass;
 
   ASTContext &Context;
 
   /// MostDerivedClassLayout - the AST record layout of the most derived class.
-  const ASTRecordLayout &MostDerivedClassLayout;
+  ASTRecordLayout const &MostDerivedClassLayout;
 
   /// MethodBaseOffsetPairTy - Uniquely identifies a member function
   /// in a base subobject.
-  typedef std::pair<const CXXMethodDecl *, CharUnits> MethodBaseOffsetPairTy;
+  typedef std::pair<CXXMethodDecl const *, CharUnits> MethodBaseOffsetPairTy;
 
-  typedef llvm::DenseMap<MethodBaseOffsetPairTy,
-                         OverriderInfo> OverridersMapTy;
+  typedef llvm::DenseMap<MethodBaseOffsetPairTy, OverriderInfo> OverridersMapTy;
 
   /// OverridersMap - The final overriders for all virtual member functions of
   /// all the base subobjects of the most derived class.
@@ -110,10 +110,10 @@
   /// SubobjectsToOffsetsMapTy - A mapping from a base subobject (represented
   /// as a record decl and a subobject number) and its offsets in the most
   /// derived class as well as the layout class.
-  typedef llvm::DenseMap<std::pair<const CXXRecordDecl *, unsigned>,
-                         CharUnits> SubobjectOffsetMapTy;
+  typedef llvm::DenseMap<std::pair<CXXRecordDecl const *, unsigned>, CharUnits>
+      SubobjectOffsetMapTy;
 
-  typedef llvm::DenseMap<const CXXRecordDecl *, unsigned> SubobjectCountMapTy;
+  typedef llvm::DenseMap<CXXRecordDecl const *, unsigned> SubobjectCountMapTy;
 
   /// ComputeBaseOffsets - Compute the offsets for all base subobjects of the
   /// given base.
@@ -123,21 +123,21 @@
                           SubobjectOffsetMapTy &SubobjectLayoutClassOffsets,
                           SubobjectCountMapTy &SubobjectCounts);
 
-  typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
+  typedef llvm::SmallPtrSet<CXXRecordDecl const *, 4> VisitedVirtualBasesSetTy;
 
   /// dump - dump the final overriders for a base subobject, and all its direct
   /// and indirect base subobjects.
   void dump(raw_ostream &Out, BaseSubobject Base,
-            VisitedVirtualBasesSetTy& VisitedVirtualBases);
+            VisitedVirtualBasesSetTy &VisitedVirtualBases);
 
 public:
-  FinalOverriders(const CXXRecordDecl *MostDerivedClass,
+  FinalOverriders(CXXRecordDecl const *MostDerivedClass,
                   CharUnits MostDerivedClassOffset,
-                  const CXXRecordDecl *LayoutClass);
+                  CXXRecordDecl const *LayoutClass);
 
   /// getOverrider - Get the final overrider for the given method declaration in
   /// the subobject with the given base offset.
-  OverriderInfo getOverrider(const CXXMethodDecl *MD,
+  OverriderInfo getOverrider(CXXMethodDecl const *MD,
                              CharUnits BaseOffset) const {
     assert(OverridersMap.count(std::make_pair(MD, BaseOffset)) &&
            "Did not find overrider!");
@@ -151,24 +151,22 @@
     dump(llvm::errs(), BaseSubobject(MostDerivedClass, CharUnits::Zero()),
          VisitedVirtualBases);
   }
-
 };
 
-FinalOverriders::FinalOverriders(const CXXRecordDecl *MostDerivedClass,
+FinalOverriders::FinalOverriders(CXXRecordDecl const *MostDerivedClass,
                                  CharUnits MostDerivedClassOffset,
-                                 const CXXRecordDecl *LayoutClass)
-  : MostDerivedClass(MostDerivedClass),
-  MostDerivedClassOffset(MostDerivedClassOffset), LayoutClass(LayoutClass),
-  Context(MostDerivedClass->getASTContext()),
-  MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)) {
+                                 CXXRecordDecl const *LayoutClass)
+    : MostDerivedClass(MostDerivedClass),
+      MostDerivedClassOffset(MostDerivedClassOffset), LayoutClass(LayoutClass),
+      Context(MostDerivedClass->getASTContext()),
+      MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)) {
 
   // Compute base offsets.
   SubobjectOffsetMapTy SubobjectOffsets;
   SubobjectOffsetMapTy SubobjectLayoutClassOffsets;
   SubobjectCountMapTy SubobjectCounts;
   ComputeBaseOffsets(BaseSubobject(MostDerivedClass, CharUnits::Zero()),
-                     /*IsVirtual=*/false,
-                     MostDerivedClassOffset,
+                     /*IsVirtual=*/false, MostDerivedClassOffset,
                      SubobjectOffsets, SubobjectLayoutClassOffsets,
                      SubobjectCounts);
 
@@ -176,31 +174,30 @@
   CXXFinalOverriderMap FinalOverriders;
   MostDerivedClass->getFinalOverriders(FinalOverriders);
 
-  for (const auto &Overrider : FinalOverriders) {
-    const CXXMethodDecl *MD = Overrider.first;
-    const OverridingMethods &Methods = Overrider.second;
+  for (auto const &Overrider : FinalOverriders) {
+    CXXMethodDecl const *MD = Overrider.first;
+    OverridingMethods const &Methods = Overrider.second;
 
-    for (const auto &M : Methods) {
+    for (auto const &M : Methods) {
       unsigned SubobjectNumber = M.first;
-      assert(SubobjectOffsets.count(std::make_pair(MD->getParent(),
-                                                   SubobjectNumber)) &&
+      assert(SubobjectOffsets.count(
+                 std::make_pair(MD->getParent(), SubobjectNumber)) &&
              "Did not find subobject offset!");
 
-      CharUnits BaseOffset = SubobjectOffsets[std::make_pair(MD->getParent(),
-                                                            SubobjectNumber)];
+      CharUnits BaseOffset =
+          SubobjectOffsets[std::make_pair(MD->getParent(), SubobjectNumber)];
 
       assert(M.second.size() == 1 && "Final overrider is not unique!");
-      const UniqueVirtualMethod &Method = M.second.front();
+      UniqueVirtualMethod const &Method = M.second.front();
 
-      const CXXRecordDecl *OverriderRD = Method.Method->getParent();
+      CXXRecordDecl const *OverriderRD = Method.Method->getParent();
       assert(SubobjectLayoutClassOffsets.count(
-             std::make_pair(OverriderRD, Method.Subobject))
-             && "Did not find subobject offset!");
-      CharUnits OverriderOffset =
-        SubobjectLayoutClassOffsets[std::make_pair(OverriderRD,
-                                                   Method.Subobject)];
+                 std::make_pair(OverriderRD, Method.Subobject)) &&
+             "Did not find subobject offset!");
+      CharUnits OverriderOffset = SubobjectLayoutClassOffsets[std::make_pair(
+          OverriderRD, Method.Subobject)];
 
-      OverriderInfo& Overrider = OverridersMap[std::make_pair(MD, BaseOffset)];
+      OverriderInfo &Overrider = OverridersMap[std::make_pair(MD, BaseOffset)];
       assert(!Overrider.Method && "Overrider should not exist yet!");
 
       Overrider.Offset = OverriderOffset;
@@ -215,17 +212,17 @@
 #endif
 }
 
-static BaseOffset ComputeBaseOffset(const ASTContext &Context,
-                                    const CXXRecordDecl *DerivedRD,
-                                    const CXXBasePath &Path) {
+static BaseOffset ComputeBaseOffset(ASTContext const &Context,
+                                    CXXRecordDecl const *DerivedRD,
+                                    CXXBasePath const &Path) {
   CharUnits NonVirtualOffset = CharUnits::Zero();
 
   unsigned NonVirtualStart = 0;
-  const CXXRecordDecl *VirtualBase = nullptr;
+  CXXRecordDecl const *VirtualBase = nullptr;
 
   // First, look for the virtual base class.
   for (int I = Path.size(), E = 0; I != E; --I) {
-    const CXXBasePathElement &Element = Path[I - 1];
+    CXXBasePathElement const &Element = Path[I - 1];
 
     if (Element.Base->isVirtual()) {
       NonVirtualStart = I;
@@ -237,12 +234,12 @@
 
   // Now compute the non-virtual offset.
   for (unsigned I = NonVirtualStart, E = Path.size(); I != E; ++I) {
-    const CXXBasePathElement &Element = Path[I];
+    CXXBasePathElement const &Element = Path[I];
 
     // Check the base class offset.
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(Element.Class);
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(Element.Class);
 
-    const CXXRecordDecl *Base = Element.Base->getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *Base = Element.Base->getType()->getAsCXXRecordDecl();
 
     NonVirtualOffset += Layout.getBaseClassOffset(Base);
   }
@@ -251,12 +248,11 @@
   // even change the base offsets in ASTRecordLayout to be specified in
   // CharUnits.
   return BaseOffset(DerivedRD, VirtualBase, NonVirtualOffset);
-
 }
 
-static BaseOffset ComputeBaseOffset(const ASTContext &Context,
-                                    const CXXRecordDecl *BaseRD,
-                                    const CXXRecordDecl *DerivedRD) {
+static BaseOffset ComputeBaseOffset(ASTContext const &Context,
+                                    CXXRecordDecl const *BaseRD,
+                                    CXXRecordDecl const *DerivedRD) {
   CXXBasePaths Paths(/*FindAmbiguities=*/false,
                      /*RecordPaths=*/true, /*DetectVirtual=*/false);
 
@@ -268,10 +264,10 @@
 
 static BaseOffset
 ComputeReturnAdjustmentBaseOffset(ASTContext &Context,
-                                  const CXXMethodDecl *DerivedMD,
-                                  const CXXMethodDecl *BaseMD) {
-  const auto *BaseFT = BaseMD->getType()->castAs<FunctionType>();
-  const auto *DerivedFT = DerivedMD->getType()->castAs<FunctionType>();
+                                  CXXMethodDecl const *DerivedMD,
+                                  CXXMethodDecl const *BaseMD) {
+  auto const *BaseFT = BaseMD->getType()->castAs<FunctionType>();
+  auto const *DerivedFT = DerivedMD->getType()->castAs<FunctionType>();
 
   // Canonicalize the return types.
   CanQualType CanDerivedReturnType =
@@ -280,7 +276,7 @@
       Context.getCanonicalType(BaseFT->getReturnType());
 
   assert(CanDerivedReturnType->getTypeClass() ==
-         CanBaseReturnType->getTypeClass() &&
+             CanBaseReturnType->getTypeClass() &&
          "Types must have same type class!");
 
   if (CanDerivedReturnType == CanBaseReturnType) {
@@ -290,14 +286,14 @@
 
   if (isa<ReferenceType>(CanDerivedReturnType)) {
     CanDerivedReturnType =
-      CanDerivedReturnType->getAs<ReferenceType>()->getPointeeType();
+        CanDerivedReturnType->getAs<ReferenceType>()->getPointeeType();
     CanBaseReturnType =
-      CanBaseReturnType->getAs<ReferenceType>()->getPointeeType();
+        CanBaseReturnType->getAs<ReferenceType>()->getPointeeType();
   } else if (isa<PointerType>(CanDerivedReturnType)) {
     CanDerivedReturnType =
-      CanDerivedReturnType->getAs<PointerType>()->getPointeeType();
+        CanDerivedReturnType->getAs<PointerType>()->getPointeeType();
     CanBaseReturnType =
-      CanBaseReturnType->getAs<PointerType>()->getPointeeType();
+        CanBaseReturnType->getAs<PointerType>()->getPointeeType();
   } else {
     llvm_unreachable("Unexpected return type!");
   }
@@ -311,40 +307,40 @@
     return BaseOffset();
   }
 
-  const CXXRecordDecl *DerivedRD =
-    cast<CXXRecordDecl>(cast<RecordType>(CanDerivedReturnType)->getDecl());
+  CXXRecordDecl const *DerivedRD =
+      cast<CXXRecordDecl>(cast<RecordType>(CanDerivedReturnType)->getDecl());
 
-  const CXXRecordDecl *BaseRD =
-    cast<CXXRecordDecl>(cast<RecordType>(CanBaseReturnType)->getDecl());
+  CXXRecordDecl const *BaseRD =
+      cast<CXXRecordDecl>(cast<RecordType>(CanBaseReturnType)->getDecl());
 
   return ComputeBaseOffset(Context, BaseRD, DerivedRD);
 }
 
-void
-FinalOverriders::ComputeBaseOffsets(BaseSubobject Base, bool IsVirtual,
-                              CharUnits OffsetInLayoutClass,
-                              SubobjectOffsetMapTy &SubobjectOffsets,
-                              SubobjectOffsetMapTy &SubobjectLayoutClassOffsets,
-                              SubobjectCountMapTy &SubobjectCounts) {
-  const CXXRecordDecl *RD = Base.getBase();
+void FinalOverriders::ComputeBaseOffsets(
+    BaseSubobject Base, bool IsVirtual, CharUnits OffsetInLayoutClass,
+    SubobjectOffsetMapTy &SubobjectOffsets,
+    SubobjectOffsetMapTy &SubobjectLayoutClassOffsets,
+    SubobjectCountMapTy &SubobjectCounts) {
+  CXXRecordDecl const *RD = Base.getBase();
 
   unsigned SubobjectNumber = 0;
   if (!IsVirtual)
     SubobjectNumber = ++SubobjectCounts[RD];
 
   // Set up the subobject to offset mapping.
-  assert(!SubobjectOffsets.count(std::make_pair(RD, SubobjectNumber))
-         && "Subobject offset already exists!");
-  assert(!SubobjectLayoutClassOffsets.count(std::make_pair(RD, SubobjectNumber))
-         && "Subobject offset already exists!");
+  assert(!SubobjectOffsets.count(std::make_pair(RD, SubobjectNumber)) &&
+         "Subobject offset already exists!");
+  assert(
+      !SubobjectLayoutClassOffsets.count(std::make_pair(RD, SubobjectNumber)) &&
+      "Subobject offset already exists!");
 
   SubobjectOffsets[std::make_pair(RD, SubobjectNumber)] = Base.getBaseOffset();
   SubobjectLayoutClassOffsets[std::make_pair(RD, SubobjectNumber)] =
-    OffsetInLayoutClass;
+      OffsetInLayoutClass;
 
   // Traverse our bases.
-  for (const auto &B : RD->bases()) {
-    const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl();
+  for (auto const &B : RD->bases()) {
+    CXXRecordDecl const *BaseDecl = B.getType()->getAsCXXRecordDecl();
 
     CharUnits BaseOffset;
     CharUnits BaseOffsetInLayoutClass;
@@ -353,34 +349,32 @@
       if (SubobjectOffsets.count(std::make_pair(BaseDecl, 0)))
         continue;
 
-      const ASTRecordLayout &LayoutClassLayout =
-        Context.getASTRecordLayout(LayoutClass);
+      ASTRecordLayout const &LayoutClassLayout =
+          Context.getASTRecordLayout(LayoutClass);
 
       BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
-      BaseOffsetInLayoutClass =
-        LayoutClassLayout.getVBaseClassOffset(BaseDecl);
+      BaseOffsetInLayoutClass = LayoutClassLayout.getVBaseClassOffset(BaseDecl);
     } else {
-      const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+      ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
       CharUnits Offset = Layout.getBaseClassOffset(BaseDecl);
 
       BaseOffset = Base.getBaseOffset() + Offset;
       BaseOffsetInLayoutClass = OffsetInLayoutClass + Offset;
     }
 
-    ComputeBaseOffsets(BaseSubobject(BaseDecl, BaseOffset),
-                       B.isVirtual(), BaseOffsetInLayoutClass,
-                       SubobjectOffsets, SubobjectLayoutClassOffsets,
-                       SubobjectCounts);
+    ComputeBaseOffsets(BaseSubobject(BaseDecl, BaseOffset), B.isVirtual(),
+                       BaseOffsetInLayoutClass, SubobjectOffsets,
+                       SubobjectLayoutClassOffsets, SubobjectCounts);
   }
 }
 
 void FinalOverriders::dump(raw_ostream &Out, BaseSubobject Base,
                            VisitedVirtualBasesSetTy &VisitedVirtualBases) {
-  const CXXRecordDecl *RD = Base.getBase();
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  CXXRecordDecl const *RD = Base.getBase();
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
-  for (const auto &B : RD->bases()) {
-    const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl();
+  for (auto const &B : RD->bases()) {
+    CXXRecordDecl const *BaseDecl = B.getType()->getAsCXXRecordDecl();
 
     // Ignore bases that don't have any virtual member functions.
     if (!BaseDecl->isPolymorphic())
@@ -407,7 +401,7 @@
   Out << Base.getBaseOffset().getQuantity() << ")\n";
 
   // Now dump the overriders for this base subobject.
-  for (const auto *MD : RD->methods()) {
+  for (auto const *MD : RD->methods()) {
     if (!VTableContextBase::hasVtableSlot(MD))
       continue;
     MD = MD->getCanonicalDecl();
@@ -441,7 +435,7 @@
 /// VCallOffsetMap - Keeps track of vcall offsets when building a vtable.
 struct VCallOffsetMap {
 
-  typedef std::pair<const CXXMethodDecl *, CharUnits> MethodAndOffsetPairTy;
+  typedef std::pair<CXXMethodDecl const *, CharUnits> MethodAndOffsetPairTy;
 
   /// Offsets - Keeps track of methods and their offsets.
   // FIXME: This should be a real map and not a vector.
@@ -449,32 +443,33 @@
 
   /// MethodsCanShareVCallOffset - Returns whether two virtual member functions
   /// can share the same vcall offset.
-  static bool MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
-                                         const CXXMethodDecl *RHS);
+  static bool MethodsCanShareVCallOffset(CXXMethodDecl const *LHS,
+                                         CXXMethodDecl const *RHS);
 
 public:
   /// AddVCallOffset - Adds a vcall offset to the map. Returns true if the
   /// add was successful, or false if there was already a member function with
   /// the same signature in the map.
-  bool AddVCallOffset(const CXXMethodDecl *MD, CharUnits OffsetOffset);
+  bool AddVCallOffset(CXXMethodDecl const *MD, CharUnits OffsetOffset);
 
   /// getVCallOffsetOffset - Returns the vcall offset offset (relative to the
   /// vtable address point) for the given virtual member function.
-  CharUnits getVCallOffsetOffset(const CXXMethodDecl *MD);
+  CharUnits getVCallOffsetOffset(CXXMethodDecl const *MD);
 
   // empty - Return whether the offset map is empty or not.
   bool empty() const { return Offsets.empty(); }
 };
 
-static bool HasSameVirtualSignature(const CXXMethodDecl *LHS,
-                                    const CXXMethodDecl *RHS) {
-  const FunctionProtoType *LT =
-    cast<FunctionProtoType>(LHS->getType().getCanonicalType());
-  const FunctionProtoType *RT =
-    cast<FunctionProtoType>(RHS->getType().getCanonicalType());
+static bool HasSameVirtualSignature(CXXMethodDecl const *LHS,
+                                    CXXMethodDecl const *RHS) {
+  FunctionProtoType const *LT =
+      cast<FunctionProtoType>(LHS->getType().getCanonicalType());
+  FunctionProtoType const *RT =
+      cast<FunctionProtoType>(RHS->getType().getCanonicalType());
 
   // Fast-path matches in the canonical types.
-  if (LT == RT) return true;
+  if (LT == RT)
+    return true;
 
   // Force the signatures to match.  We can't rely on the overrides
   // list here because there isn't necessarily an inheritance
@@ -484,8 +479,8 @@
   return LT->getParamTypes() == RT->getParamTypes();
 }
 
-bool VCallOffsetMap::MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
-                                                const CXXMethodDecl *RHS) {
+bool VCallOffsetMap::MethodsCanShareVCallOffset(CXXMethodDecl const *LHS,
+                                                CXXMethodDecl const *RHS) {
   assert(VTableContextBase::hasVtableSlot(LHS) && "LHS must be virtual!");
   assert(VTableContextBase::hasVtableSlot(RHS) && "RHS must be virtual!");
 
@@ -505,10 +500,10 @@
   return HasSameVirtualSignature(LHS, RHS);
 }
 
-bool VCallOffsetMap::AddVCallOffset(const CXXMethodDecl *MD,
+bool VCallOffsetMap::AddVCallOffset(CXXMethodDecl const *MD,
                                     CharUnits OffsetOffset) {
   // Check if we can reuse an offset.
-  for (const auto &OffsetPair : Offsets) {
+  for (auto const &OffsetPair : Offsets) {
     if (MethodsCanShareVCallOffset(OffsetPair.first, MD))
       return false;
   }
@@ -518,9 +513,9 @@
   return true;
 }
 
-CharUnits VCallOffsetMap::getVCallOffsetOffset(const CXXMethodDecl *MD) {
+CharUnits VCallOffsetMap::getVCallOffsetOffset(CXXMethodDecl const *MD) {
   // Look for an offset.
-  for (const auto &OffsetPair : Offsets) {
+  for (auto const &OffsetPair : Offsets) {
     if (MethodsCanShareVCallOffset(OffsetPair.first, MD))
       return OffsetPair.second;
   }
@@ -531,20 +526,20 @@
 /// VCallAndVBaseOffsetBuilder - Class for building vcall and vbase offsets.
 class VCallAndVBaseOffsetBuilder {
 public:
-  typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits>
-    VBaseOffsetOffsetsMapTy;
+  typedef llvm::DenseMap<CXXRecordDecl const *, CharUnits>
+      VBaseOffsetOffsetsMapTy;
 
 private:
-  const ItaniumVTableContext &VTables;
+  ItaniumVTableContext const &VTables;
 
   /// MostDerivedClass - The most derived class for which we're building vcall
   /// and vbase offsets.
-  const CXXRecordDecl *MostDerivedClass;
+  CXXRecordDecl const *MostDerivedClass;
 
   /// LayoutClass - The class we're using for layout information. Will be
   /// different than the most derived class if we're building a construction
   /// vtable.
-  const CXXRecordDecl *LayoutClass;
+  CXXRecordDecl const *LayoutClass;
 
   /// Context - The ASTContext which we will use for layout information.
   ASTContext &Context;
@@ -554,19 +549,18 @@
   VTableComponentVectorTy Components;
 
   /// VisitedVirtualBases - Visited virtual bases.
-  llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
+  llvm::SmallPtrSet<CXXRecordDecl const *, 4> VisitedVirtualBases;
 
   /// VCallOffsets - Keeps track of vcall offsets.
   VCallOffsetMap VCallOffsets;
 
-
   /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets,
   /// relative to the address point.
   VBaseOffsetOffsetsMapTy VBaseOffsetOffsets;
 
   /// FinalOverriders - The final overriders of the most derived class.
   /// (Can be null when we're not building a vtable of the most derived class).
-  const FinalOverriders *Overriders;
+  FinalOverriders const *Overriders;
 
   /// AddVCallAndVBaseOffsets - Add vcall offsets and vbase offsets for the
   /// given base subobject.
@@ -577,7 +571,7 @@
   void AddVCallOffsets(BaseSubobject Base, CharUnits VBaseOffset);
 
   /// AddVBaseOffsets - Add vbase offsets for the given class.
-  void AddVBaseOffsets(const CXXRecordDecl *Base,
+  void AddVBaseOffsets(CXXRecordDecl const *Base,
                        CharUnits OffsetInLayoutClass);
 
   /// getCurrentOffsetOffset - Get the current vcall or vbase offset offset in
@@ -585,10 +579,10 @@
   CharUnits getCurrentOffsetOffset() const;
 
 public:
-  VCallAndVBaseOffsetBuilder(const ItaniumVTableContext &VTables,
-                             const CXXRecordDecl *MostDerivedClass,
-                             const CXXRecordDecl *LayoutClass,
-                             const FinalOverriders *Overriders,
+  VCallAndVBaseOffsetBuilder(ItaniumVTableContext const &VTables,
+                             CXXRecordDecl const *MostDerivedClass,
+                             CXXRecordDecl const *LayoutClass,
+                             FinalOverriders const *Overriders,
                              BaseSubobject Base, bool BaseIsVirtual,
                              CharUnits OffsetInLayoutClass)
       : VTables(VTables), MostDerivedClass(MostDerivedClass),
@@ -604,17 +598,15 @@
   const_iterator components_begin() const { return Components.rbegin(); }
   const_iterator components_end() const { return Components.rend(); }
 
-  const VCallOffsetMap &getVCallOffsets() const { return VCallOffsets; }
-  const VBaseOffsetOffsetsMapTy &getVBaseOffsetOffsets() const {
+  VCallOffsetMap const &getVCallOffsets() const { return VCallOffsets; }
+  VBaseOffsetOffsetsMapTy const &getVBaseOffsetOffsets() const {
     return VBaseOffsetOffsets;
   }
 };
 
-void
-VCallAndVBaseOffsetBuilder::AddVCallAndVBaseOffsets(BaseSubobject Base,
-                                                    bool BaseIsVirtual,
-                                                    CharUnits RealBaseOffset) {
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base.getBase());
+void VCallAndVBaseOffsetBuilder::AddVCallAndVBaseOffsets(
+    BaseSubobject Base, bool BaseIsVirtual, CharUnits RealBaseOffset) {
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(Base.getBase());
 
   // Itanium C++ ABI 2.5.2:
   //   ..in classes sharing a virtual table with a primary base class, the vcall
@@ -625,7 +617,7 @@
 
   // (Since we're emitting the vcall and vbase offsets in reverse order, we'll
   // emit them for the primary base first).
-  if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
+  if (CXXRecordDecl const *PrimaryBase = Layout.getPrimaryBase()) {
     bool PrimaryBaseIsVirtual = Layout.isPrimaryBaseVirtual();
 
     CharUnits PrimaryBaseOffset;
@@ -635,11 +627,11 @@
       assert(Layout.getVBaseClassOffset(PrimaryBase).isZero() &&
              "Primary vbase should have a zero offset!");
 
-      const ASTRecordLayout &MostDerivedClassLayout =
-        Context.getASTRecordLayout(MostDerivedClass);
+      ASTRecordLayout const &MostDerivedClassLayout =
+          Context.getASTRecordLayout(MostDerivedClass);
 
       PrimaryBaseOffset =
-        MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
+          MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
     } else {
       assert(Layout.getBaseClassOffset(PrimaryBase).isZero() &&
              "Primary base should have a zero offset!");
@@ -647,9 +639,8 @@
       PrimaryBaseOffset = Base.getBaseOffset();
     }
 
-    AddVCallAndVBaseOffsets(
-      BaseSubobject(PrimaryBase,PrimaryBaseOffset),
-      PrimaryBaseIsVirtual, RealBaseOffset);
+    AddVCallAndVBaseOffsets(BaseSubobject(PrimaryBase, PrimaryBaseOffset),
+                            PrimaryBaseIsVirtual, RealBaseOffset);
   }
 
   AddVBaseOffsets(Base.getBase(), RealBaseOffset);
@@ -678,10 +669,10 @@
 
 void VCallAndVBaseOffsetBuilder::AddVCallOffsets(BaseSubobject Base,
                                                  CharUnits VBaseOffset) {
-  const CXXRecordDecl *RD = Base.getBase();
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  CXXRecordDecl const *RD = Base.getBase();
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
-  const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
+  CXXRecordDecl const *PrimaryBase = Layout.getPrimaryBase();
 
   // Handle the primary base first.
   // We only want to add vcall offsets if the base is non-virtual; a virtual
@@ -696,7 +687,7 @@
   }
 
   // Add the vcall offsets.
-  for (const auto *MD : RD->methods()) {
+  for (auto const *MD : RD->methods()) {
     if (!VTableContextBase::hasVtableSlot(MD))
       continue;
     MD = MD->getCanonicalDecl();
@@ -713,60 +704,55 @@
     if (Overriders) {
       // Get the final overrider.
       FinalOverriders::OverriderInfo Overrider =
-        Overriders->getOverrider(MD, Base.getBaseOffset());
+          Overriders->getOverrider(MD, Base.getBaseOffset());
 
       /// The vcall offset is the offset from the virtual base to the object
       /// where the function was overridden.
       Offset = Overrider.Offset - VBaseOffset;
     }
 
-    Components.push_back(
-      VTableComponent::MakeVCallOffset(Offset));
+    Components.push_back(VTableComponent::MakeVCallOffset(Offset));
   }
 
   // And iterate over all non-virtual bases (ignoring the primary base).
-  for (const auto &B : RD->bases()) {
+  for (auto const &B : RD->bases()) {
     if (B.isVirtual())
       continue;
 
-    const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *BaseDecl = B.getType()->getAsCXXRecordDecl();
     if (BaseDecl == PrimaryBase)
       continue;
 
     // Get the base offset of this base.
-    CharUnits BaseOffset = Base.getBaseOffset() +
-      Layout.getBaseClassOffset(BaseDecl);
+    CharUnits BaseOffset =
+        Base.getBaseOffset() + Layout.getBaseClassOffset(BaseDecl);
 
-    AddVCallOffsets(BaseSubobject(BaseDecl, BaseOffset),
-                    VBaseOffset);
+    AddVCallOffsets(BaseSubobject(BaseDecl, BaseOffset), VBaseOffset);
   }
 }
 
-void
-VCallAndVBaseOffsetBuilder::AddVBaseOffsets(const CXXRecordDecl *RD,
-                                            CharUnits OffsetInLayoutClass) {
-  const ASTRecordLayout &LayoutClassLayout =
-    Context.getASTRecordLayout(LayoutClass);
+void VCallAndVBaseOffsetBuilder::AddVBaseOffsets(
+    CXXRecordDecl const *RD, CharUnits OffsetInLayoutClass) {
+  ASTRecordLayout const &LayoutClassLayout =
+      Context.getASTRecordLayout(LayoutClass);
 
   // Add vbase offsets.
-  for (const auto &B : RD->bases()) {
-    const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl();
+  for (auto const &B : RD->bases()) {
+    CXXRecordDecl const *BaseDecl = B.getType()->getAsCXXRecordDecl();
 
     // Check if this is a virtual base that we haven't visited before.
     if (B.isVirtual() && VisitedVirtualBases.insert(BaseDecl).second) {
       CharUnits Offset =
-        LayoutClassLayout.getVBaseClassOffset(BaseDecl) - OffsetInLayoutClass;
+          LayoutClassLayout.getVBaseClassOffset(BaseDecl) - OffsetInLayoutClass;
 
       // Add the vbase offset offset.
       assert(!VBaseOffsetOffsets.count(BaseDecl) &&
              "vbase offset offset already exists!");
 
       CharUnits VBaseOffsetOffset = getCurrentOffsetOffset();
-      VBaseOffsetOffsets.insert(
-          std::make_pair(BaseDecl, VBaseOffsetOffset));
+      VBaseOffsetOffsets.insert(std::make_pair(BaseDecl, VBaseOffsetOffset));
 
-      Components.push_back(
-          VTableComponent::MakeVBaseOffset(Offset));
+      Components.push_back(VTableComponent::MakeVBaseOffset(Offset));
     }
 
     // Check the base class looking for more vbase offsets.
@@ -779,11 +765,11 @@
 public:
   /// PrimaryBasesSetVectorTy - A set vector of direct and indirect
   /// primary bases.
-  typedef llvm::SmallSetVector<const CXXRecordDecl *, 8>
-    PrimaryBasesSetVectorTy;
+  typedef llvm::SmallSetVector<CXXRecordDecl const *, 8>
+      PrimaryBasesSetVectorTy;
 
-  typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits>
-    VBaseOffsetOffsetsMapTy;
+  typedef llvm::DenseMap<CXXRecordDecl const *, CharUnits>
+      VBaseOffsetOffsetsMapTy;
 
   typedef VTableLayout::AddressPointsMapTy AddressPointsMapTy;
 
@@ -795,7 +781,7 @@
 
   /// MostDerivedClass - The most derived class for which we're building this
   /// vtable.
-  const CXXRecordDecl *MostDerivedClass;
+  CXXRecordDecl const *MostDerivedClass;
 
   /// MostDerivedClassOffset - If we're building a construction vtable, this
   /// holds the offset from the layout class to the most derived class.
@@ -808,7 +794,7 @@
   /// LayoutClass - The class we're using for layout information. Will be
   /// different than the most derived class if we're building a construction
   /// vtable.
-  const CXXRecordDecl *LayoutClass;
+  CXXRecordDecl const *LayoutClass;
 
   /// Context - The ASTContext which we will use for layout information.
   ASTContext &Context;
@@ -818,7 +804,7 @@
 
   /// VCallOffsetsForVBases - Keeps track of vcall offsets for the virtual
   /// bases in this vtable.
-  llvm::DenseMap<const CXXRecordDecl *, VCallOffsetMap> VCallOffsetsForVBases;
+  llvm::DenseMap<CXXRecordDecl const *, VCallOffsetMap> VCallOffsetsForVBases;
 
   /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets for
   /// the most derived class.
@@ -846,19 +832,18 @@
 
     MethodInfo(CharUnits BaseOffset, CharUnits BaseOffsetInLayoutClass,
                uint64_t VTableIndex)
-      : BaseOffset(BaseOffset),
-      BaseOffsetInLayoutClass(BaseOffsetInLayoutClass),
-      VTableIndex(VTableIndex) { }
+        : BaseOffset(BaseOffset),
+          BaseOffsetInLayoutClass(BaseOffsetInLayoutClass),
+          VTableIndex(VTableIndex) {}
 
     MethodInfo()
-      : BaseOffset(CharUnits::Zero()),
-      BaseOffsetInLayoutClass(CharUnits::Zero()),
-      VTableIndex(0) { }
+        : BaseOffset(CharUnits::Zero()),
+          BaseOffsetInLayoutClass(CharUnits::Zero()), VTableIndex(0) {}
 
-    MethodInfo(MethodInfo const&) = default;
+    MethodInfo(MethodInfo const &) = default;
   };
 
-  typedef llvm::DenseMap<const CXXMethodDecl *, MethodInfo> MethodInfoMapTy;
+  typedef llvm::DenseMap<CXXMethodDecl const *, MethodInfo> MethodInfoMapTy;
 
   /// MethodInfoMap - The information for all methods in the vtable we're
   /// currently building.
@@ -875,20 +860,20 @@
   VTableThunksMapTy VTableThunks;
 
   typedef SmallVector<ThunkInfo, 1> ThunkInfoVectorTy;
-  typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy;
+  typedef llvm::DenseMap<CXXMethodDecl const *, ThunkInfoVectorTy> ThunksMapTy;
 
   /// Thunks - A map that contains all the thunks needed for all methods in the
   /// most derived class for which the vtable is currently being built.
   ThunksMapTy Thunks;
 
   /// AddThunk - Add a thunk for the given method.
-  void AddThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk);
+  void AddThunk(CXXMethodDecl const *MD, ThunkInfo const &Thunk);
 
   /// ComputeThisAdjustments - Compute the 'this' pointer adjustments for the
   /// part of the vtable we're currently building.
   void ComputeThisAdjustments();
 
-  typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
+  typedef llvm::SmallPtrSet<CXXRecordDecl const *, 4> VisitedVirtualBasesSetTy;
 
   /// PrimaryVirtualBases - All known virtual bases who are a primary base of
   /// some other base.
@@ -907,13 +892,13 @@
   /// given virtual member function, its offset in the layout class and its
   /// final overrider.
   ThisAdjustment
-  ComputeThisAdjustment(const CXXMethodDecl *MD,
+  ComputeThisAdjustment(CXXMethodDecl const *MD,
                         CharUnits BaseOffsetInLayoutClass,
                         FinalOverriders::OverriderInfo Overrider);
 
   /// AddMethod - Add a single virtual member function to the vtable
   /// components vector.
-  void AddMethod(const CXXMethodDecl *MD, ReturnAdjustment ReturnAdjustment);
+  void AddMethod(CXXMethodDecl const *MD, ReturnAdjustment ReturnAdjustment);
 
   /// IsOverriderUsed - Returns whether the overrider will ever be used in this
   /// part of the vtable.
@@ -934,16 +919,15 @@
   ///   thunk. Since we require that a call to C::f() first convert to A*,
   ///   C-in-D's copy of A's vtable is never referenced, so this is not
   ///   necessary.
-  bool IsOverriderUsed(const CXXMethodDecl *Overrider,
+  bool IsOverriderUsed(CXXMethodDecl const *Overrider,
                        CharUnits BaseOffsetInLayoutClass,
-                       const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
+                       CXXRecordDecl const *FirstBaseInPrimaryBaseChain,
                        CharUnits FirstBaseOffsetInLayoutClass) const;
 
-
   /// AddMethods - Add the methods of this base subobject and all its
   /// primary bases to the vtable components vector.
   void AddMethods(BaseSubobject Base, CharUnits BaseOffsetInLayoutClass,
-                  const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
+                  CXXRecordDecl const *FirstBaseInPrimaryBaseChain,
                   CharUnits FirstBaseOffsetInLayoutClass,
                   PrimaryBasesSetVectorTy &PrimaryBases);
 
@@ -974,13 +958,13 @@
 
   /// DeterminePrimaryVirtualBases - Determine the primary virtual bases in this
   /// class hierarchy.
-  void DeterminePrimaryVirtualBases(const CXXRecordDecl *RD,
+  void DeterminePrimaryVirtualBases(CXXRecordDecl const *RD,
                                     CharUnits OffsetInLayoutClass,
                                     VisitedVirtualBasesSetTy &VBases);
 
   /// LayoutVTablesForVirtualBases - Layout vtables for all virtual bases of the
   /// given base (excluding any primary bases).
-  void LayoutVTablesForVirtualBases(const CXXRecordDecl *RD,
+  void LayoutVTablesForVirtualBases(CXXRecordDecl const *RD,
                                     VisitedVirtualBasesSetTy &VBases);
 
   /// isBuildingConstructionVTable - Return whether this vtable builder is
@@ -995,10 +979,10 @@
   SmallVector<size_t, 4> VTableIndices;
 
   ItaniumVTableBuilder(ItaniumVTableContext &VTables,
-                       const CXXRecordDecl *MostDerivedClass,
+                       CXXRecordDecl const *MostDerivedClass,
                        CharUnits MostDerivedClassOffset,
                        bool MostDerivedClassIsVirtual,
-                       const CXXRecordDecl *LayoutClass)
+                       CXXRecordDecl const *LayoutClass)
       : VTables(VTables), MostDerivedClass(MostDerivedClass),
         MostDerivedClassOffset(MostDerivedClassOffset),
         MostDerivedClassIsVirtual(MostDerivedClassIsVirtual),
@@ -1012,25 +996,17 @@
       dumpLayout(llvm::outs());
   }
 
-  uint64_t getNumThunks() const {
-    return Thunks.size();
-  }
+  uint64_t getNumThunks() const { return Thunks.size(); }
 
-  ThunksMapTy::const_iterator thunks_begin() const {
-    return Thunks.begin();
-  }
+  ThunksMapTy::const_iterator thunks_begin() const { return Thunks.begin(); }
 
-  ThunksMapTy::const_iterator thunks_end() const {
-    return Thunks.end();
-  }
+  ThunksMapTy::const_iterator thunks_end() const { return Thunks.end(); }
 
-  const VBaseOffsetOffsetsMapTy &getVBaseOffsetOffsets() const {
+  VBaseOffsetOffsetsMapTy const &getVBaseOffsetOffsets() const {
     return VBaseOffsetOffsets;
   }
 
-  const AddressPointsMapTy &getAddressPoints() const {
-    return AddressPoints;
-  }
+  AddressPointsMapTy const &getAddressPoints() const { return AddressPoints; }
 
   MethodVTableIndicesTy::const_iterator vtable_indices_begin() const {
     return MethodVTableIndices.begin();
@@ -1059,11 +1035,11 @@
   }
 
   /// dumpLayout - Dump the vtable layout.
-  void dumpLayout(raw_ostream&);
+  void dumpLayout(raw_ostream &);
 };
 
-void ItaniumVTableBuilder::AddThunk(const CXXMethodDecl *MD,
-                                    const ThunkInfo &Thunk) {
+void ItaniumVTableBuilder::AddThunk(CXXMethodDecl const *MD,
+                                    ThunkInfo const &Thunk) {
   assert(!isBuildingConstructorVTable() &&
          "Can't add thunks for construction vtable");
 
@@ -1076,18 +1052,18 @@
   ThunksVector.push_back(Thunk);
 }
 
-typedef llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverriddenMethodsSetTy;
+typedef llvm::SmallPtrSet<CXXMethodDecl const *, 8> OverriddenMethodsSetTy;
 
 /// Visit all the methods overridden by the given method recursively,
 /// in a depth-first pre-order. The Visitor's visitor method returns a bool
 /// indicating whether to continue the recursion for the given overridden
 /// method (i.e. returning false stops the iteration).
 template <class VisitorTy>
-static void
-visitAllOverriddenMethods(const CXXMethodDecl *MD, VisitorTy &Visitor) {
+static void visitAllOverriddenMethods(CXXMethodDecl const *MD,
+                                      VisitorTy &Visitor) {
   assert(VTableContextBase::hasVtableSlot(MD) && "Method is not virtual!");
 
-  for (const CXXMethodDecl *OverriddenMD : MD->overridden_methods()) {
+  for (CXXMethodDecl const *OverriddenMD : MD->overridden_methods()) {
     if (!Visitor(OverriddenMD))
       continue;
     visitAllOverriddenMethods(OverriddenMD, Visitor);
@@ -1097,9 +1073,9 @@
 /// ComputeAllOverriddenMethods - Given a method decl, will return a set of all
 /// the overridden methods that the function decl overrides.
 static void
-ComputeAllOverriddenMethods(const CXXMethodDecl *MD,
-                            OverriddenMethodsSetTy& OverriddenMethods) {
-  auto OverriddenMethodsCollector = [&](const CXXMethodDecl *MD) {
+ComputeAllOverriddenMethods(CXXMethodDecl const *MD,
+                            OverriddenMethodsSetTy &OverriddenMethods) {
+  auto OverriddenMethodsCollector = [&](CXXMethodDecl const *MD) {
     // Don't recurse on this method if we've already collected it.
     return OverriddenMethods.insert(MD).second;
   };
@@ -1109,9 +1085,9 @@
 void ItaniumVTableBuilder::ComputeThisAdjustments() {
   // Now go through the method info map and see if any of the methods need
   // 'this' pointer adjustments.
-  for (const auto &MI : MethodInfoMap) {
-    const CXXMethodDecl *MD = MI.first;
-    const MethodInfo &MethodInfo = MI.second;
+  for (auto const &MI : MethodInfoMap) {
+    CXXMethodDecl const *MD = MI.first;
+    MethodInfo const &MethodInfo = MI.second;
 
     // Ignore adjustments for unused function pointers.
     uint64_t VTableIndex = MethodInfo.VTableIndex;
@@ -1121,7 +1097,7 @@
 
     // Get the final overrider for this method.
     FinalOverriders::OverriderInfo Overrider =
-      Overriders.getOverrider(MD, MethodInfo.BaseOffset);
+        Overriders.getOverrider(MD, MethodInfo.BaseOffset);
 
     // Check if we need an adjustment at all.
     if (MethodInfo.BaseOffsetInLayoutClass == Overrider.Offset) {
@@ -1134,8 +1110,8 @@
         continue;
     }
 
-    ThisAdjustment ThisAdjustment =
-      ComputeThisAdjustment(MD, MethodInfo.BaseOffsetInLayoutClass, Overrider);
+    ThisAdjustment ThisAdjustment = ComputeThisAdjustment(
+        MD, MethodInfo.BaseOffsetInLayoutClass, Overrider);
 
     if (ThisAdjustment.isEmpty())
       continue;
@@ -1157,10 +1133,10 @@
     return;
   }
 
-  for (const auto &TI : VTableThunks) {
-    const VTableComponent &Component = Components[TI.first];
-    const ThunkInfo &Thunk = TI.second;
-    const CXXMethodDecl *MD;
+  for (auto const &TI : VTableThunks) {
+    VTableComponent const &Component = Components[TI.first];
+    ThunkInfo const &Thunk = TI.second;
+    CXXMethodDecl const *MD;
 
     switch (Component.getKind()) {
     default:
@@ -1191,11 +1167,13 @@
       if (Offset.DerivedClass == MostDerivedClass) {
         // We can get the offset offset directly from our map.
         Adjustment.Virtual.Itanium.VBaseOffsetOffset =
-          VBaseOffsetOffsets.lookup(Offset.VirtualBase).getQuantity();
+            VBaseOffsetOffsets.lookup(Offset.VirtualBase).getQuantity();
       } else {
         Adjustment.Virtual.Itanium.VBaseOffsetOffset =
-          VTables.getVirtualBaseOffsetOffset(Offset.DerivedClass,
-                                             Offset.VirtualBase).getQuantity();
+            VTables
+                .getVirtualBaseOffsetOffset(Offset.DerivedClass,
+                                            Offset.VirtualBase)
+                .getQuantity();
       }
     }
 
@@ -1207,8 +1185,8 @@
 
 BaseOffset ItaniumVTableBuilder::ComputeThisAdjustmentBaseOffset(
     BaseSubobject Base, BaseSubobject Derived) const {
-  const CXXRecordDecl *BaseRD = Base.getBase();
-  const CXXRecordDecl *DerivedRD = Derived.getBase();
+  CXXRecordDecl const *BaseRD = Base.getBase();
+  CXXRecordDecl const *DerivedRD = Derived.getBase();
 
   CXXBasePaths Paths(/*FindAmbiguities=*/true,
                      /*RecordPaths=*/true, /*DetectVirtual=*/true);
@@ -1218,7 +1196,7 @@
 
   // We have to go through all the paths, and see which one leads us to the
   // right base subobject.
-  for (const CXXBasePath &Path : Paths) {
+  for (CXXBasePath const &Path : Paths) {
     BaseOffset Offset = ComputeBaseOffset(Context, DerivedRD, Path);
 
     CharUnits OffsetToBaseSubobject = Offset.NonVirtualOffset;
@@ -1226,13 +1204,13 @@
     if (Offset.VirtualBase) {
       // If we have a virtual base class, the non-virtual offset is relative
       // to the virtual base class offset.
-      const ASTRecordLayout &LayoutClassLayout =
-        Context.getASTRecordLayout(LayoutClass);
+      ASTRecordLayout const &LayoutClassLayout =
+          Context.getASTRecordLayout(LayoutClass);
 
       /// Get the virtual base offset, relative to the most derived class
       /// layout.
       OffsetToBaseSubobject +=
-        LayoutClassLayout.getVBaseClassOffset(Offset.VirtualBase);
+          LayoutClassLayout.getVBaseClassOffset(Offset.VirtualBase);
     } else {
       // Otherwise, the non-virtual offset is relative to the derived class
       // offset.
@@ -1252,7 +1230,7 @@
 }
 
 ThisAdjustment ItaniumVTableBuilder::ComputeThisAdjustment(
-    const CXXMethodDecl *MD, CharUnits BaseOffsetInLayoutClass,
+    CXXMethodDecl const *MD, CharUnits BaseOffsetInLayoutClass,
     FinalOverriders::OverriderInfo Overrider) {
   // Ignore adjustments for pure virtual member functions.
   if (Overrider.Method->isPure())
@@ -1291,7 +1269,7 @@
     }
 
     Adjustment.Virtual.Itanium.VCallOffsetOffset =
-      VCallOffsets.getVCallOffsetOffset(MD).getQuantity();
+        VCallOffsets.getVCallOffsetOffset(MD).getQuantity();
   }
 
   // Set the non-virtual part of the adjustment.
@@ -1300,9 +1278,9 @@
   return Adjustment;
 }
 
-void ItaniumVTableBuilder::AddMethod(const CXXMethodDecl *MD,
+void ItaniumVTableBuilder::AddMethod(CXXMethodDecl const *MD,
                                      ReturnAdjustment ReturnAdjustment) {
-  if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
+  if (CXXDestructorDecl const *DD = dyn_cast<CXXDestructorDecl>(MD)) {
     assert(ReturnAdjustment.isEmpty() &&
            "Destructor can't have return adjustment!");
 
@@ -1331,12 +1309,12 @@
 /// OverridesIndirectMethodInBase will return true if given C::f as the method
 /// and { A } as the set of bases.
 static bool OverridesIndirectMethodInBases(
-    const CXXMethodDecl *MD,
+    CXXMethodDecl const *MD,
     ItaniumVTableBuilder::PrimaryBasesSetVectorTy &Bases) {
   if (Bases.count(MD->getParent()))
     return true;
 
-  for (const CXXMethodDecl *OverriddenMD : MD->overridden_methods()) {
+  for (CXXMethodDecl const *OverriddenMD : MD->overridden_methods()) {
     // Check "indirect overriders".
     if (OverridesIndirectMethodInBases(OverriddenMD, Bases))
       return true;
@@ -1346,13 +1324,13 @@
 }
 
 bool ItaniumVTableBuilder::IsOverriderUsed(
-    const CXXMethodDecl *Overrider, CharUnits BaseOffsetInLayoutClass,
-    const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
+    CXXMethodDecl const *Overrider, CharUnits BaseOffsetInLayoutClass,
+    CXXRecordDecl const *FirstBaseInPrimaryBaseChain,
     CharUnits FirstBaseOffsetInLayoutClass) const {
   // If the base and the first base in the primary base chain have the same
   // offsets, then this overrider will be used.
   if (BaseOffsetInLayoutClass == FirstBaseOffsetInLayoutClass)
-   return true;
+    return true;
 
   // We know now that Base (or a direct or indirect base of it) is a primary
   // base in part of the class hierarchy, but not a primary base in the most
@@ -1365,14 +1343,14 @@
 
   ItaniumVTableBuilder::PrimaryBasesSetVectorTy PrimaryBases;
 
-  const CXXRecordDecl *RD = FirstBaseInPrimaryBaseChain;
+  CXXRecordDecl const *RD = FirstBaseInPrimaryBaseChain;
   PrimaryBases.insert(RD);
 
   // Now traverse the base chain, starting with the first base, until we find
   // the base that is no longer a primary base.
   while (true) {
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
-    const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
+    CXXRecordDecl const *PrimaryBase = Layout.getPrimaryBase();
 
     if (!PrimaryBase)
       break;
@@ -1381,8 +1359,8 @@
       assert(Layout.getVBaseClassOffset(PrimaryBase).isZero() &&
              "Primary base should always be at offset 0!");
 
-      const ASTRecordLayout &LayoutClassLayout =
-        Context.getASTRecordLayout(LayoutClass);
+      ASTRecordLayout const &LayoutClassLayout =
+          Context.getASTRecordLayout(LayoutClass);
 
       // Now check if this is the primary base that is not a primary base in the
       // most derived class.
@@ -1407,21 +1385,20 @@
   return OverridesIndirectMethodInBases(Overrider, PrimaryBases);
 }
 
-typedef llvm::SmallSetVector<const CXXRecordDecl *, 8> BasesSetVectorTy;
+typedef llvm::SmallSetVector<CXXRecordDecl const *, 8> BasesSetVectorTy;
 
 /// FindNearestOverriddenMethod - Given a method, returns the overridden method
 /// from the nearest base. Returns null if no method was found.
 /// The Bases are expected to be sorted in a base-to-derived order.
-static const CXXMethodDecl *
-FindNearestOverriddenMethod(const CXXMethodDecl *MD,
-                            BasesSetVectorTy &Bases) {
+static CXXMethodDecl const *
+FindNearestOverriddenMethod(CXXMethodDecl const *MD, BasesSetVectorTy &Bases) {
   OverriddenMethodsSetTy OverriddenMethods;
   ComputeAllOverriddenMethods(MD, OverriddenMethods);
 
-  for (const CXXRecordDecl *PrimaryBase :
+  for (CXXRecordDecl const *PrimaryBase :
        llvm::make_range(Bases.rbegin(), Bases.rend())) {
     // Now check the overridden methods.
-    for (const CXXMethodDecl *OverriddenMD : OverriddenMethods) {
+    for (CXXMethodDecl const *OverriddenMD : OverriddenMethods) {
       // We found our overridden method.
       if (OverriddenMD->getParent() == PrimaryBase)
         return OverriddenMD;
@@ -1433,7 +1410,7 @@
 
 void ItaniumVTableBuilder::AddMethods(
     BaseSubobject Base, CharUnits BaseOffsetInLayoutClass,
-    const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
+    CXXRecordDecl const *FirstBaseInPrimaryBaseChain,
     CharUnits FirstBaseOffsetInLayoutClass,
     PrimaryBasesSetVectorTy &PrimaryBases) {
   // Itanium C++ ABI 2.5.2:
@@ -1445,27 +1422,27 @@
   //   unless it overrides a function from the primary base, and conversion
   //   between their return types does not require an adjustment.
 
-  const CXXRecordDecl *RD = Base.getBase();
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  CXXRecordDecl const *RD = Base.getBase();
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
-  if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
+  if (CXXRecordDecl const *PrimaryBase = Layout.getPrimaryBase()) {
     CharUnits PrimaryBaseOffset;
     CharUnits PrimaryBaseOffsetInLayoutClass;
     if (Layout.isPrimaryBaseVirtual()) {
       assert(Layout.getVBaseClassOffset(PrimaryBase).isZero() &&
              "Primary vbase should have a zero offset!");
 
-      const ASTRecordLayout &MostDerivedClassLayout =
-        Context.getASTRecordLayout(MostDerivedClass);
+      ASTRecordLayout const &MostDerivedClassLayout =
+          Context.getASTRecordLayout(MostDerivedClass);
 
       PrimaryBaseOffset =
-        MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
+          MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
 
-      const ASTRecordLayout &LayoutClassLayout =
-        Context.getASTRecordLayout(LayoutClass);
+      ASTRecordLayout const &LayoutClassLayout =
+          Context.getASTRecordLayout(LayoutClass);
 
       PrimaryBaseOffsetInLayoutClass =
-        LayoutClassLayout.getVBaseClassOffset(PrimaryBase);
+          LayoutClassLayout.getVBaseClassOffset(PrimaryBase);
     } else {
       assert(Layout.getBaseClassOffset(PrimaryBase).isZero() &&
              "Primary base should have a zero offset!");
@@ -1482,28 +1459,28 @@
       llvm_unreachable("Found a duplicate primary base!");
   }
 
-  typedef llvm::SmallVector<const CXXMethodDecl *, 8> NewVirtualFunctionsTy;
+  typedef llvm::SmallVector<CXXMethodDecl const *, 8> NewVirtualFunctionsTy;
   NewVirtualFunctionsTy NewVirtualFunctions;
 
-  llvm::SmallVector<const CXXMethodDecl*, 4> NewImplicitVirtualFunctions;
+  llvm::SmallVector<CXXMethodDecl const *, 4> NewImplicitVirtualFunctions;
 
   // Now go through all virtual member functions and add them.
-  for (const auto *MD : RD->methods()) {
+  for (auto const *MD : RD->methods()) {
     if (!ItaniumVTableContext::hasVtableSlot(MD))
       continue;
     MD = MD->getCanonicalDecl();
 
     // Get the final overrider.
     FinalOverriders::OverriderInfo Overrider =
-      Overriders.getOverrider(MD, Base.getBaseOffset());
+        Overriders.getOverrider(MD, Base.getBaseOffset());
 
     // Check if this virtual member function overrides a method in a primary
     // base. If this is the case, and the return type doesn't require adjustment
     // then we can just use the member function from the primary base.
-    if (const CXXMethodDecl *OverriddenMD =
-          FindNearestOverriddenMethod(MD, PrimaryBases)) {
-      if (ComputeReturnAdjustmentBaseOffset(Context, MD,
-                                            OverriddenMD).isEmpty()) {
+    if (CXXMethodDecl const *OverriddenMD =
+            FindNearestOverriddenMethod(MD, PrimaryBases)) {
+      if (ComputeReturnAdjustmentBaseOffset(Context, MD, OverriddenMD)
+              .isEmpty()) {
         // Replace the method info of the overridden method with our own
         // method.
         assert(MethodInfoMap.count(OverriddenMD) &&
@@ -1525,9 +1502,8 @@
         // a primary base in the complete object.
         if (!isBuildingConstructorVTable() && OverriddenMD != MD) {
           // Compute the this adjustment.
-          ThisAdjustment ThisAdjustment =
-            ComputeThisAdjustment(OverriddenMD, BaseOffsetInLayoutClass,
-                                  Overrider);
+          ThisAdjustment ThisAdjustment = ComputeThisAdjustment(
+              OverriddenMD, BaseOffsetInLayoutClass, Overrider);
 
           if (ThisAdjustment.Virtual.Itanium.VCallOffsetOffset &&
               Overrider.Method->getParent() == MostDerivedClass) {
@@ -1536,9 +1512,10 @@
             // but that doesn't mean there isn't one between MD and
             // the final overrider.
             BaseOffset ReturnAdjustmentOffset =
-              ComputeReturnAdjustmentBaseOffset(Context, Overrider.Method, MD);
+                ComputeReturnAdjustmentBaseOffset(Context, Overrider.Method,
+                                                  MD);
             ReturnAdjustment ReturnAdjustment =
-              ComputeReturnAdjustment(ReturnAdjustmentOffset);
+                ComputeReturnAdjustment(ReturnAdjustmentOffset);
 
             // This is a virtual thunk for the most derived class, add it.
             AddThunk(Overrider.Method,
@@ -1558,7 +1535,7 @@
 
   std::stable_sort(
       NewImplicitVirtualFunctions.begin(), NewImplicitVirtualFunctions.end(),
-      [](const CXXMethodDecl *A, const CXXMethodDecl *B) {
+      [](CXXMethodDecl const *A, CXXMethodDecl const *B) {
         if (A->isCopyAssignmentOperator() != B->isCopyAssignmentOperator())
           return A->isCopyAssignmentOperator();
         if (A->isMoveAssignmentOperator() != B->isMoveAssignmentOperator())
@@ -1575,10 +1552,10 @@
   NewVirtualFunctions.append(NewImplicitVirtualFunctions.begin(),
                              NewImplicitVirtualFunctions.end());
 
-  for (const CXXMethodDecl *MD : NewVirtualFunctions) {
+  for (CXXMethodDecl const *MD : NewVirtualFunctions) {
     // Get the final overrider.
     FinalOverriders::OverriderInfo Overrider =
-      Overriders.getOverrider(MD, Base.getBaseOffset());
+        Overriders.getOverrider(MD, Base.getBaseOffset());
 
     // Insert the method info for this method.
     MethodInfo MethodInfo(Base.getBaseOffset(), BaseOffsetInLayoutClass,
@@ -1589,7 +1566,7 @@
     MethodInfoMap.insert(std::make_pair(MD, MethodInfo));
 
     // Check if this overrider is going to be used.
-    const CXXMethodDecl *OverriderMD = Overrider.Method;
+    CXXMethodDecl const *OverriderMD = Overrider.Method;
     if (!IsOverriderUsed(OverriderMD, BaseOffsetInLayoutClass,
                          FirstBaseInPrimaryBaseChain,
                          FirstBaseOffsetInLayoutClass)) {
@@ -1602,22 +1579,21 @@
     BaseOffset ReturnAdjustmentOffset;
     if (!OverriderMD->isPure()) {
       ReturnAdjustmentOffset =
-        ComputeReturnAdjustmentBaseOffset(Context, OverriderMD, MD);
+          ComputeReturnAdjustmentBaseOffset(Context, OverriderMD, MD);
     }
 
     ReturnAdjustment ReturnAdjustment =
-      ComputeReturnAdjustment(ReturnAdjustmentOffset);
+        ComputeReturnAdjustment(ReturnAdjustmentOffset);
 
     AddMethod(Overrider.Method, ReturnAdjustment);
   }
 }
 
 void ItaniumVTableBuilder::LayoutVTable() {
-  LayoutPrimaryAndSecondaryVTables(BaseSubobject(MostDerivedClass,
-                                                 CharUnits::Zero()),
-                                   /*BaseIsMorallyVirtual=*/false,
-                                   MostDerivedClassIsVirtual,
-                                   MostDerivedClassOffset);
+  LayoutPrimaryAndSecondaryVTables(
+      BaseSubobject(MostDerivedClass, CharUnits::Zero()),
+      /*BaseIsMorallyVirtual=*/false, MostDerivedClassIsVirtual,
+      MostDerivedClassOffset);
 
   VisitedVirtualBasesSetTy VBases;
 
@@ -1672,21 +1648,20 @@
 
   // Now go through all virtual member functions and add them.
   PrimaryBasesSetVectorTy PrimaryBases;
-  AddMethods(Base, OffsetInLayoutClass,
-             Base.getBase(), OffsetInLayoutClass,
+  AddMethods(Base, OffsetInLayoutClass, Base.getBase(), OffsetInLayoutClass,
              PrimaryBases);
 
-  const CXXRecordDecl *RD = Base.getBase();
+  CXXRecordDecl const *RD = Base.getBase();
   if (RD == MostDerivedClass) {
     assert(MethodVTableIndices.empty());
-    for (const auto &I : MethodInfoMap) {
-      const CXXMethodDecl *MD = I.first;
-      const MethodInfo &MI = I.second;
-      if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
-        MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)]
-            = MI.VTableIndex - AddressPoint;
-        MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)]
-            = MI.VTableIndex + 1 - AddressPoint;
+    for (auto const &I : MethodInfoMap) {
+      CXXMethodDecl const *MD = I.first;
+      MethodInfo const &MI = I.second;
+      if (CXXDestructorDecl const *DD = dyn_cast<CXXDestructorDecl>(MD)) {
+        MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] =
+            MI.VTableIndex - AddressPoint;
+        MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] =
+            MI.VTableIndex + 1 - AddressPoint;
       } else {
         MethodVTableIndices[MD] = MI.VTableIndex - AddressPoint;
       }
@@ -1704,8 +1679,8 @@
                            unsigned(VTableIndices.size() - 1),
                            unsigned(AddressPoint - VTableIndex)}));
 
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
-    const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
+    CXXRecordDecl const *PrimaryBase = Layout.getPrimaryBase();
 
     if (!PrimaryBase)
       break;
@@ -1713,8 +1688,8 @@
     if (Layout.isPrimaryBaseVirtual()) {
       // Check if this virtual primary base is a primary base in the layout
       // class. If it's not, we don't want to add it.
-      const ASTRecordLayout &LayoutClassLayout =
-        Context.getASTRecordLayout(LayoutClass);
+      ASTRecordLayout const &LayoutClassLayout =
+          Context.getASTRecordLayout(LayoutClass);
 
       if (LayoutClassLayout.getVBaseClassOffset(PrimaryBase) !=
           OffsetInLayoutClass) {
@@ -1730,25 +1705,24 @@
   LayoutSecondaryVTables(Base, BaseIsMorallyVirtual, OffsetInLayoutClass);
 }
 
-void
-ItaniumVTableBuilder::LayoutSecondaryVTables(BaseSubobject Base,
-                                             bool BaseIsMorallyVirtual,
-                                             CharUnits OffsetInLayoutClass) {
+void ItaniumVTableBuilder::LayoutSecondaryVTables(
+    BaseSubobject Base, bool BaseIsMorallyVirtual,
+    CharUnits OffsetInLayoutClass) {
   // Itanium C++ ABI 2.5.2:
   //   Following the primary virtual table of a derived class are secondary
   //   virtual tables for each of its proper base classes, except any primary
   //   base(s) with which it shares its primary virtual table.
 
-  const CXXRecordDecl *RD = Base.getBase();
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
-  const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
+  CXXRecordDecl const *RD = Base.getBase();
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
+  CXXRecordDecl const *PrimaryBase = Layout.getPrimaryBase();
 
-  for (const auto &B : RD->bases()) {
+  for (auto const &B : RD->bases()) {
     // Ignore virtual bases, we'll emit them later.
     if (B.isVirtual())
       continue;
 
-    const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl();
+    CXXRecordDecl const *BaseDecl = B.getType()->getAsCXXRecordDecl();
 
     // Ignore bases that don't have a vtable.
     if (!BaseDecl->isDynamicClass())
@@ -1769,7 +1743,7 @@
     CharUnits BaseOffset = Base.getBaseOffset() + RelativeBaseOffset;
 
     CharUnits BaseOffsetInLayoutClass =
-      OffsetInLayoutClass + RelativeBaseOffset;
+        OffsetInLayoutClass + RelativeBaseOffset;
 
     // Don't emit a secondary vtable for a primary base. We might however want
     // to emit secondary vtables for other bases of this base.
@@ -1781,20 +1755,18 @@
 
     // Layout the primary vtable (and any secondary vtables) for this base.
     LayoutPrimaryAndSecondaryVTables(
-      BaseSubobject(BaseDecl, BaseOffset),
-      BaseIsMorallyVirtual,
-      /*BaseIsVirtualInLayoutClass=*/false,
-      BaseOffsetInLayoutClass);
+        BaseSubobject(BaseDecl, BaseOffset), BaseIsMorallyVirtual,
+        /*BaseIsVirtualInLayoutClass=*/false, BaseOffsetInLayoutClass);
   }
 }
 
 void ItaniumVTableBuilder::DeterminePrimaryVirtualBases(
-    const CXXRecordDecl *RD, CharUnits OffsetInLayoutClass,
+    CXXRecordDecl const *RD, CharUnits OffsetInLayoutClass,
     VisitedVirtualBasesSetTy &VBases) {
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
   // Check if this base has a primary base.
-  if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
+  if (CXXRecordDecl const *PrimaryBase = Layout.getPrimaryBase()) {
 
     // Check if it's virtual.
     if (Layout.isPrimaryBaseVirtual()) {
@@ -1803,11 +1775,11 @@
       if (isBuildingConstructorVTable()) {
         // Check if the base is actually a primary base in the class we use for
         // layout.
-        const ASTRecordLayout &LayoutClassLayout =
-          Context.getASTRecordLayout(LayoutClass);
+        ASTRecordLayout const &LayoutClassLayout =
+            Context.getASTRecordLayout(LayoutClass);
 
         CharUnits PrimaryBaseOffsetInLayoutClass =
-          LayoutClassLayout.getVBaseClassOffset(PrimaryBase);
+            LayoutClassLayout.getVBaseClassOffset(PrimaryBase);
 
         // We know that the base is not a primary base in the layout class if
         // the base offsets are different.
@@ -1821,8 +1793,8 @@
   }
 
   // Traverse bases, looking for more primary virtual bases.
-  for (const auto &B : RD->bases()) {
-    const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl();
+  for (auto const &B : RD->bases()) {
+    CXXRecordDecl const *BaseDecl = B.getType()->getAsCXXRecordDecl();
 
     CharUnits BaseOffsetInLayoutClass;
 
@@ -1830,14 +1802,13 @@
       if (!VBases.insert(BaseDecl).second)
         continue;
 
-      const ASTRecordLayout &LayoutClassLayout =
-        Context.getASTRecordLayout(LayoutClass);
+      ASTRecordLayout const &LayoutClassLayout =
+          Context.getASTRecordLayout(LayoutClass);
 
-      BaseOffsetInLayoutClass =
-        LayoutClassLayout.getVBaseClassOffset(BaseDecl);
+      BaseOffsetInLayoutClass = LayoutClassLayout.getVBaseClassOffset(BaseDecl);
     } else {
       BaseOffsetInLayoutClass =
-        OffsetInLayoutClass + Layout.getBaseClassOffset(BaseDecl);
+          OffsetInLayoutClass + Layout.getBaseClassOffset(BaseDecl);
     }
 
     DeterminePrimaryVirtualBases(BaseDecl, BaseOffsetInLayoutClass, VBases);
@@ -1845,34 +1816,33 @@
 }
 
 void ItaniumVTableBuilder::LayoutVTablesForVirtualBases(
-    const CXXRecordDecl *RD, VisitedVirtualBasesSetTy &VBases) {
+    CXXRecordDecl const *RD, VisitedVirtualBasesSetTy &VBases) {
   // Itanium C++ ABI 2.5.2:
   //   Then come the virtual base virtual tables, also in inheritance graph
   //   order, and again excluding primary bases (which share virtual tables with
   //   the classes for which they are primary).
-  for (const auto &B : RD->bases()) {
-    const CXXRecordDecl *BaseDecl = B.getType()->getAsCXXRecordDecl();
+  for (auto const &B : RD->bases()) {
+    CXXRecordDecl const *BaseDecl = B.getType()->getAsCXXRecordDecl();
 
     // Check if this base needs a vtable. (If it's virtual, not a primary base
     // of some other class, and we haven't visited it before).
     if (B.isVirtual() && BaseDecl->isDynamicClass() &&
         !PrimaryVirtualBases.count(BaseDecl) &&
         VBases.insert(BaseDecl).second) {
-      const ASTRecordLayout &MostDerivedClassLayout =
-        Context.getASTRecordLayout(MostDerivedClass);
+      ASTRecordLayout const &MostDerivedClassLayout =
+          Context.getASTRecordLayout(MostDerivedClass);
       CharUnits BaseOffset =
-        MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
+          MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
 
-      const ASTRecordLayout &LayoutClassLayout =
-        Context.getASTRecordLayout(LayoutClass);
+      ASTRecordLayout const &LayoutClassLayout =
+          Context.getASTRecordLayout(LayoutClass);
       CharUnits BaseOffsetInLayoutClass =
-        LayoutClassLayout.getVBaseClassOffset(BaseDecl);
+          LayoutClassLayout.getVBaseClassOffset(BaseDecl);
 
-      LayoutPrimaryAndSecondaryVTables(
-        BaseSubobject(BaseDecl, BaseOffset),
-        /*BaseIsMorallyVirtual=*/true,
-        /*BaseIsVirtualInLayoutClass=*/true,
-        BaseOffsetInLayoutClass);
+      LayoutPrimaryAndSecondaryVTables(BaseSubobject(BaseDecl, BaseOffset),
+                                       /*BaseIsMorallyVirtual=*/true,
+                                       /*BaseIsVirtualInLayoutClass=*/true,
+                                       BaseOffsetInLayoutClass);
     }
 
     // We only need to check the base for virtual base vtables if it actually
@@ -1904,8 +1874,8 @@
   // Since an address point can be shared by multiple subobjects, we use an
   // STL multimap.
   std::multimap<uint64_t, BaseSubobject> AddressPointsByIndex;
-  for (const auto &AP : AddressPoints) {
-    const BaseSubobject &Base = AP.first;
+  for (auto const &AP : AddressPoints) {
+    BaseSubobject const &Base = AP.first;
     uint64_t Index =
         VTableIndices[AP.second.VTableIndex] + AP.second.AddressPointIndex;
 
@@ -1917,26 +1887,23 @@
 
     Out << llvm::format("%4d | ", I);
 
-    const VTableComponent &Component = Components[I];
+    VTableComponent const &Component = Components[I];
 
     // Dump the component.
     switch (Component.getKind()) {
 
     case VTableComponent::CK_VCallOffset:
-      Out << "vcall_offset ("
-          << Component.getVCallOffset().getQuantity()
+      Out << "vcall_offset (" << Component.getVCallOffset().getQuantity()
           << ")";
       break;
 
     case VTableComponent::CK_VBaseOffset:
-      Out << "vbase_offset ("
-          << Component.getVBaseOffset().getQuantity()
+      Out << "vbase_offset (" << Component.getVBaseOffset().getQuantity()
           << ")";
       break;
 
     case VTableComponent::CK_OffsetToTop:
-      Out << "offset_to_top ("
-          << Component.getOffsetToTop().getQuantity()
+      Out << "offset_to_top (" << Component.getOffsetToTop().getQuantity()
           << ")";
       break;
 
@@ -1946,11 +1913,10 @@
       break;
 
     case VTableComponent::CK_FunctionPointer: {
-      const CXXMethodDecl *MD = Component.getFunctionDecl();
+      CXXMethodDecl const *MD = Component.getFunctionDecl();
 
-      std::string Str =
-        PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
-                                    MD);
+      std::string Str = PredefinedExpr::ComputeName(
+          PredefinedExpr::PrettyFunctionNoVirtual, MD);
       Out << Str;
       if (MD->isPure())
         Out << " [pure]";
@@ -1993,9 +1959,9 @@
     case VTableComponent::CK_CompleteDtorPointer:
     case VTableComponent::CK_DeletingDtorPointer: {
       bool IsComplete =
-        Component.getKind() == VTableComponent::CK_CompleteDtorPointer;
+          Component.getKind() == VTableComponent::CK_CompleteDtorPointer;
 
-      const CXXDestructorDecl *DD = Component.getDestructorDecl();
+      CXXDestructorDecl const *DD = Component.getDestructorDecl();
 
       DD->printQualifiedName(Out);
       if (IsComplete)
@@ -2026,16 +1992,14 @@
     }
 
     case VTableComponent::CK_UnusedFunctionPointer: {
-      const CXXMethodDecl *MD = Component.getUnusedFunctionDecl();
+      CXXMethodDecl const *MD = Component.getUnusedFunctionDecl();
 
-      std::string Str =
-        PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
-                                    MD);
+      std::string Str = PredefinedExpr::ComputeName(
+          PredefinedExpr::PrettyFunctionNoVirtual, MD);
       Out << "[unused] " << Str;
       if (MD->isPure())
         Out << " [pure]";
     }
-
     }
 
     Out << '\n';
@@ -2044,8 +2008,8 @@
     uint64_t NextIndex = Index + 1;
     if (AddressPointsByIndex.count(NextIndex)) {
       if (AddressPointsByIndex.count(NextIndex) == 1) {
-        const BaseSubobject &Base =
-          AddressPointsByIndex.find(NextIndex)->second;
+        BaseSubobject const &Base =
+            AddressPointsByIndex.find(NextIndex)->second;
 
         Out << "       -- (";
         Base.getBase()->printQualifiedName(Out);
@@ -2053,19 +2017,19 @@
         Out << ") vtable address --\n";
       } else {
         CharUnits BaseOffset =
-          AddressPointsByIndex.lower_bound(NextIndex)->second.getBaseOffset();
+            AddressPointsByIndex.lower_bound(NextIndex)->second.getBaseOffset();
 
         // We store the class names in a set to get a stable order.
         std::set<std::string> ClassNames;
-        for (const auto &I :
+        for (auto const &I :
              llvm::make_range(AddressPointsByIndex.equal_range(NextIndex))) {
           assert(I.second.getBaseOffset() == BaseOffset &&
                  "Invalid base offset!");
-          const CXXRecordDecl *RD = I.second.getBase();
+          CXXRecordDecl const *RD = I.second.getBase();
           ClassNames.insert(RD->getQualifiedNameAsString());
         }
 
-        for (const std::string &Name : ClassNames) {
+        for (std::string const &Name : ClassNames) {
           Out << "       -- (" << Name;
           Out << ", " << BaseOffset.getQuantity() << ") vtable address --\n";
         }
@@ -2083,7 +2047,7 @@
     // a stable order.
 
     std::map<std::string, CharUnits> ClassNamesAndOffsets;
-    for (const auto &I : VBaseOffsetOffsets) {
+    for (auto const &I : VBaseOffsetOffsets) {
       std::string ClassName = I.first->getQualifiedNameAsString();
       CharUnits OffsetOffset = I.second;
       ClassNamesAndOffsets.insert(std::make_pair(ClassName, OffsetOffset));
@@ -2095,7 +2059,7 @@
     Out << ClassNamesAndOffsets.size();
     Out << (ClassNamesAndOffsets.size() == 1 ? " entry" : " entries") << ").\n";
 
-    for (const auto &I : ClassNamesAndOffsets)
+    for (auto const &I : ClassNamesAndOffsets)
       Out << "   " << I.first << " | " << I.second.getQuantity() << '\n';
 
     Out << "\n";
@@ -2103,23 +2067,22 @@
 
   if (!Thunks.empty()) {
     // We store the method names in a map to get a stable order.
-    std::map<std::string, const CXXMethodDecl *> MethodNamesAndDecls;
+    std::map<std::string, CXXMethodDecl const *> MethodNamesAndDecls;
 
-    for (const auto &I : Thunks) {
-      const CXXMethodDecl *MD = I.first;
-      std::string MethodName =
-        PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
-                                    MD);
+    for (auto const &I : Thunks) {
+      CXXMethodDecl const *MD = I.first;
+      std::string MethodName = PredefinedExpr::ComputeName(
+          PredefinedExpr::PrettyFunctionNoVirtual, MD);
 
       MethodNamesAndDecls.insert(std::make_pair(MethodName, MD));
     }
 
-    for (const auto &I : MethodNamesAndDecls) {
-      const std::string &MethodName = I.first;
-      const CXXMethodDecl *MD = I.second;
+    for (auto const &I : MethodNamesAndDecls) {
+      std::string const &MethodName = I.first;
+      CXXMethodDecl const *MD = I.second;
 
       ThunkInfoVectorTy ThunksVector = Thunks[MD];
-      llvm::sort(ThunksVector, [](const ThunkInfo &LHS, const ThunkInfo &RHS) {
+      llvm::sort(ThunksVector, [](ThunkInfo const &LHS, ThunkInfo const &RHS) {
         assert(LHS.Method == nullptr && RHS.Method == nullptr);
         return std::tie(LHS.This, LHS.Return) < std::tie(RHS.This, RHS.Return);
       });
@@ -2128,7 +2091,7 @@
       Out << (ThunksVector.size() == 1 ? " entry" : " entries") << ").\n";
 
       for (unsigned I = 0, E = ThunksVector.size(); I != E; ++I) {
-        const ThunkInfo &Thunk = ThunksVector[I];
+        ThunkInfo const &Thunk = ThunksVector[I];
 
         Out << llvm::format("%4d | ", I);
 
@@ -2167,17 +2130,16 @@
   // Store them in a map keyed by the index so we'll get a sorted table.
   std::map<uint64_t, std::string> IndicesMap;
 
-  for (const auto *MD : MostDerivedClass->methods()) {
+  for (auto const *MD : MostDerivedClass->methods()) {
     // We only want virtual member functions.
     if (!ItaniumVTableContext::hasVtableSlot(MD))
       continue;
     MD = MD->getCanonicalDecl();
 
-    std::string MethodName =
-      PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
-                                  MD);
+    std::string MethodName = PredefinedExpr::ComputeName(
+        PredefinedExpr::PrettyFunctionNoVirtual, MD);
 
-    if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
+    if (CXXDestructorDecl const *DD = dyn_cast<CXXDestructorDecl>(MD)) {
       GlobalDecl GD(DD, Dtor_Complete);
       assert(MethodVTableIndices.count(GD));
       uint64_t VTableIndex = MethodVTableIndices[GD];
@@ -2195,26 +2157,25 @@
     MostDerivedClass->printQualifiedName(Out);
     Out << "' (" << IndicesMap.size() << " entries).\n";
 
-    for (const auto &I : IndicesMap) {
+    for (auto const &I : IndicesMap) {
       uint64_t VTableIndex = I.first;
-      const std::string &MethodName = I.second;
+      std::string const &MethodName = I.second;
 
-      Out << llvm::format("%4" PRIu64 " | ", VTableIndex) << MethodName
-          << '\n';
+      Out << llvm::format("%4" PRIu64 " | ", VTableIndex) << MethodName << '\n';
     }
   }
 
   Out << '\n';
 }
-}
+} // namespace
 
 static VTableLayout::AddressPointsIndexMapTy
-MakeAddressPointIndices(const VTableLayout::AddressPointsMapTy &addressPoints,
+MakeAddressPointIndices(VTableLayout::AddressPointsMapTy const &addressPoints,
                         unsigned numVTables) {
   VTableLayout::AddressPointsIndexMapTy indexMap(numVTables);
 
   for (auto it = addressPoints.begin(); it != addressPoints.end(); ++it) {
-    const auto &addressPointLoc = it->second;
+    auto const &addressPointLoc = it->second;
     unsigned vtableIndex = addressPointLoc.VTableIndex;
     unsigned addressPoint = addressPointLoc.AddressPointIndex;
     if (indexMap[vtableIndex]) {
@@ -2238,7 +2199,7 @@
 VTableLayout::VTableLayout(ArrayRef<size_t> VTableIndices,
                            ArrayRef<VTableComponent> VTableComponents,
                            ArrayRef<VTableThunkTy> VTableThunks,
-                           const AddressPointsMapTy &AddressPoints)
+                           AddressPointsMapTy const &AddressPoints)
     : VTableComponents(VTableComponents), VTableThunks(VTableThunks),
       AddressPoints(AddressPoints), AddressPointIndices(MakeAddressPointIndices(
                                         AddressPoints, VTableIndices.size())) {
@@ -2247,17 +2208,17 @@
   else
     this->VTableIndices = OwningArrayRef<size_t>(VTableIndices);
 
-  llvm::sort(this->VTableThunks, [](const VTableLayout::VTableThunkTy &LHS,
-                                    const VTableLayout::VTableThunkTy &RHS) {
+  llvm::sort(this->VTableThunks, [](VTableLayout::VTableThunkTy const &LHS,
+                                    VTableLayout::VTableThunkTy const &RHS) {
     assert((LHS.first != RHS.first || LHS.second == RHS.second) &&
            "Different thunks should have unique indices!");
     return LHS.first < RHS.first;
   });
 }
 
-VTableLayout::~VTableLayout() { }
+VTableLayout::~VTableLayout() {}
 
-bool VTableContextBase::hasVtableSlot(const CXXMethodDecl *MD) {
+bool VTableContextBase::hasVtableSlot(CXXMethodDecl const *MD) {
   return MD->isVirtual() && !MD->isConsteval();
 }
 
@@ -2273,7 +2234,7 @@
   if (I != MethodVTableIndices.end())
     return I->second;
 
-  const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
+  CXXRecordDecl const *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
 
   computeVTableRelatedInformation(RD);
 
@@ -2283,12 +2244,12 @@
 }
 
 CharUnits
-ItaniumVTableContext::getVirtualBaseOffsetOffset(const CXXRecordDecl *RD,
-                                                 const CXXRecordDecl *VBase) {
+ItaniumVTableContext::getVirtualBaseOffsetOffset(CXXRecordDecl const *RD,
+                                                 CXXRecordDecl const *VBase) {
   ClassPairTy ClassPair(RD, VBase);
 
   VirtualBaseClassOffsetOffsetsMapTy::iterator I =
-    VirtualBaseClassOffsetOffsets.find(ClassPair);
+      VirtualBaseClassOffsetOffsets.find(ClassPair);
   if (I != VirtualBaseClassOffsetOffsets.end())
     return I->second;
 
@@ -2297,7 +2258,7 @@
                                      /*BaseIsVirtual=*/false,
                                      /*OffsetInLayoutClass=*/CharUnits::Zero());
 
-  for (const auto &I : Builder.getVBaseOffsetOffsets()) {
+  for (auto const &I : Builder.getVBaseOffsetOffsets()) {
     // Insert all types.
     ClassPairTy ClassPair(RD, I.first);
 
@@ -2311,17 +2272,17 @@
 }
 
 static std::unique_ptr<VTableLayout>
-CreateVTableLayout(const ItaniumVTableBuilder &Builder) {
-  SmallVector<VTableLayout::VTableThunkTy, 1>
-    VTableThunks(Builder.vtable_thunks_begin(), Builder.vtable_thunks_end());
+CreateVTableLayout(ItaniumVTableBuilder const &Builder) {
+  SmallVector<VTableLayout::VTableThunkTy, 1> VTableThunks(
+      Builder.vtable_thunks_begin(), Builder.vtable_thunks_end());
 
   return std::make_unique<VTableLayout>(
       Builder.VTableIndices, Builder.vtable_components(), VTableThunks,
       Builder.getAddressPoints());
 }
 
-void
-ItaniumVTableContext::computeVTableRelatedInformation(const CXXRecordDecl *RD) {
+void ItaniumVTableContext::computeVTableRelatedInformation(
+    CXXRecordDecl const *RD) {
   std::unique_ptr<const VTableLayout> &Entry = VTableLayouts[RD];
 
   // Check if we've computed this information before.
@@ -2344,13 +2305,13 @@
   if (!RD->getNumVBases())
     return;
 
-  const CXXRecordDecl *VBase =
-    RD->vbases_begin()->getType()->getAsCXXRecordDecl();
+  CXXRecordDecl const *VBase =
+      RD->vbases_begin()->getType()->getAsCXXRecordDecl();
 
   if (VirtualBaseClassOffsetOffsets.count(std::make_pair(RD, VBase)))
     return;
 
-  for (const auto &I : Builder.getVBaseOffsetOffsets()) {
+  for (auto const &I : Builder.getVBaseOffsetOffsets()) {
     // Insert all types.
     ClassPairTy ClassPair(RD, I.first);
 
@@ -2360,8 +2321,8 @@
 
 std::unique_ptr<VTableLayout>
 ItaniumVTableContext::createConstructionVTableLayout(
-    const CXXRecordDecl *MostDerivedClass, CharUnits MostDerivedClassOffset,
-    bool MostDerivedClassIsVirtual, const CXXRecordDecl *LayoutClass) {
+    CXXRecordDecl const *MostDerivedClass, CharUnits MostDerivedClassOffset,
+    bool MostDerivedClassIsVirtual, CXXRecordDecl const *LayoutClass) {
   ItaniumVTableBuilder Builder(*this, MostDerivedClass, MostDerivedClassOffset,
                                MostDerivedClassIsVirtual, LayoutClass);
   return CreateVTableLayout(Builder);
@@ -2409,15 +2370,16 @@
 //      b) a method overriding a method in a virtual base.
 //
 //  To get a better understanding of this code,
-//  you might want to see examples in test/CodeGenCXX/microsoft-abi-vtables-*.cpp
+//  you might want to see examples in
+//  test/CodeGenCXX/microsoft-abi-vtables-*.cpp
 
 class VFTableBuilder {
 public:
   typedef llvm::DenseMap<GlobalDecl, MethodVFTableLocation>
-    MethodVFTableLocationsTy;
+      MethodVFTableLocationsTy;
 
   typedef llvm::iterator_range<MethodVFTableLocationsTy::const_iterator>
-    method_locations_range;
+      method_locations_range;
 
 private:
   /// VTables - Global vtable information.
@@ -2428,11 +2390,11 @@
 
   /// MostDerivedClass - The most derived class for which we're building this
   /// vtable.
-  const CXXRecordDecl *MostDerivedClass;
+  CXXRecordDecl const *MostDerivedClass;
 
-  const ASTRecordLayout &MostDerivedClassLayout;
+  ASTRecordLayout const &MostDerivedClassLayout;
 
-  const VPtrInfo &WhichVFPtr;
+  VPtrInfo const &WhichVFPtr;
 
   /// FinalOverriders - The final overriders of the most derived class.
   const FinalOverriders Overriders;
@@ -2474,7 +2436,7 @@
           UsesExtraSlot(false) {}
   };
 
-  typedef llvm::DenseMap<const CXXMethodDecl *, MethodInfo> MethodInfoMapTy;
+  typedef llvm::DenseMap<CXXMethodDecl const *, MethodInfo> MethodInfoMapTy;
 
   /// MethodInfoMap - The information for all methods in the vftable we're
   /// currently building.
@@ -2487,14 +2449,14 @@
   VTableThunksMapTy VTableThunks;
 
   typedef SmallVector<ThunkInfo, 1> ThunkInfoVectorTy;
-  typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy;
+  typedef llvm::DenseMap<CXXMethodDecl const *, ThunkInfoVectorTy> ThunksMapTy;
 
   /// Thunks - A map that contains all the thunks needed for all methods in the
   /// most derived class for which the vftable is currently being built.
   ThunksMapTy Thunks;
 
   /// AddThunk - Add a thunk for the given method.
-  void AddThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk) {
+  void AddThunk(CXXMethodDecl const *MD, ThunkInfo const &Thunk) {
     SmallVector<ThunkInfo, 1> &ThunksVector = Thunks[MD];
 
     // Check if we have this thunk already.
@@ -2513,14 +2475,13 @@
 
   /// AddMethod - Add a single virtual member function to the vftable
   /// components vector.
-  void AddMethod(const CXXMethodDecl *MD, ThunkInfo TI) {
+  void AddMethod(CXXMethodDecl const *MD, ThunkInfo TI) {
     if (!TI.isEmpty()) {
       VTableThunks[Components.size()] = TI;
       AddThunk(MD, TI);
     }
-    if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
-      assert(TI.Return.isEmpty() &&
-             "Destructor can't have return adjustment!");
+    if (CXXDestructorDecl const *DD = dyn_cast<CXXDestructorDecl>(MD)) {
+      assert(TI.Return.isEmpty() && "Destructor can't have return adjustment!");
       Components.push_back(VTableComponent::MakeDeletingDtor(DD));
     } else {
       Components.push_back(VTableComponent::MakeFunction(MD));
@@ -2530,7 +2491,7 @@
   /// AddMethods - Add the methods of this base subobject and the relevant
   /// subbases to the vftable we're currently laying out.
   void AddMethods(BaseSubobject Base, unsigned BaseDepth,
-                  const CXXRecordDecl *LastVBase,
+                  CXXRecordDecl const *LastVBase,
                   BasesSetVectorTy &VisitedBases);
 
   void LayoutVFTable() {
@@ -2546,9 +2507,9 @@
     assert(!Components.empty() && "vftable can't be empty");
 
     assert(MethodVFTableLocations.empty());
-    for (const auto &I : MethodInfoMap) {
-      const CXXMethodDecl *MD = I.first;
-      const MethodInfo &MI = I.second;
+    for (auto const &I : MethodInfoMap) {
+      CXXMethodDecl const *MD = I.first;
+      MethodInfo const &MI = I.second;
       assert(MD == MD->getCanonicalDecl());
 
       // Skip the methods that the MostDerivedClass didn't override
@@ -2557,7 +2518,7 @@
         continue;
       MethodVFTableLocation Loc(MI.VBTableIndex, WhichVFPtr.getVBaseWithVPtr(),
                                 WhichVFPtr.NonVirtualOffset, MI.VFTableIndex);
-      if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
+      if (CXXDestructorDecl const *DD = dyn_cast<CXXDestructorDecl>(MD)) {
         MethodVFTableLocations[GlobalDecl(DD, Dtor_Deleting)] = Loc;
       } else {
         MethodVFTableLocations[MD] = Loc;
@@ -2567,9 +2528,8 @@
 
 public:
   VFTableBuilder(MicrosoftVTableContext &VTables,
-                 const CXXRecordDecl *MostDerivedClass, const VPtrInfo &Which)
-      : VTables(VTables),
-        Context(MostDerivedClass->getASTContext()),
+                 CXXRecordDecl const *MostDerivedClass, VPtrInfo const &Which)
+      : VTables(VTables), Context(MostDerivedClass->getASTContext()),
         MostDerivedClass(MostDerivedClass),
         MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)),
         WhichVFPtr(Which),
@@ -2675,13 +2635,13 @@
   {
     // Find the set of least derived bases that define the given method.
     OverriddenMethodsSetTy VisitedOverriddenMethods;
-    auto InitialOverriddenDefinitionCollector = [&](
-        const CXXMethodDecl *OverriddenMD) {
-      if (OverriddenMD->size_overridden_methods() == 0)
-        Bases.insert(OverriddenMD->getParent());
-      // Don't recurse on this method if we've already collected it.
-      return VisitedOverriddenMethods.insert(OverriddenMD).second;
-    };
+    auto InitialOverriddenDefinitionCollector =
+        [&](CXXMethodDecl const *OverriddenMD) {
+          if (OverriddenMD->size_overridden_methods() == 0)
+            Bases.insert(OverriddenMD->getParent());
+          // Don't recurse on this method if we've already collected it.
+          return VisitedOverriddenMethods.insert(OverriddenMD).second;
+        };
     visitAllOverriddenMethods(Overrider.Method,
                               InitialOverriddenDefinitionCollector);
   }
@@ -2693,7 +2653,7 @@
 
   CXXBasePaths Paths;
   Overrider.Method->getParent()->lookupInBases(
-      [&Bases](const CXXBaseSpecifier *Specifier, CXXBasePath &) {
+      [&Bases](CXXBaseSpecifier const *Specifier, CXXBasePath &) {
         return Bases.count(Specifier->getType()->getAsCXXRecordDecl());
       },
       Paths);
@@ -2705,20 +2665,20 @@
   CharUnits Ret;
   bool First = true;
 
-  const ASTRecordLayout &OverriderRDLayout =
+  ASTRecordLayout const &OverriderRDLayout =
       Context.getASTRecordLayout(Overrider.Method->getParent());
-  for (const CXXBasePath &Path : Paths) {
+  for (CXXBasePath const &Path : Paths) {
     CharUnits ThisOffset = Overrider.Offset;
     CharUnits LastVBaseOffset;
 
     // For each path from the overrider to the parents of the overridden
     // methods, traverse the path, calculating the this offset in the most
     // derived class.
-    for (const CXXBasePathElement &Element : Path) {
+    for (CXXBasePathElement const &Element : Path) {
       QualType CurTy = Element.Base->getType();
-      const CXXRecordDecl *PrevRD = Element.Class,
+      CXXRecordDecl const *PrevRD = Element.Class,
                           *CurRD = CurTy->getAsCXXRecordDecl();
-      const ASTRecordLayout &Layout = Context.getASTRecordLayout(PrevRD);
+      ASTRecordLayout const &Layout = Context.getASTRecordLayout(PrevRD);
 
       if (Element.Base->isVirtual()) {
         // The interesting things begin when you have virtual inheritance.
@@ -2862,9 +2822,9 @@
 void VFTableBuilder::CalculateVtordispAdjustment(
     FinalOverriders::OverriderInfo Overrider, CharUnits ThisOffset,
     ThisAdjustment &TA) {
-  const ASTRecordLayout::VBaseOffsetsMapTy &VBaseMap =
+  ASTRecordLayout::VBaseOffsetsMapTy const &VBaseMap =
       MostDerivedClassLayout.getVBaseOffsetsMap();
-  const ASTRecordLayout::VBaseOffsetsMapTy::const_iterator &VBaseMapEntry =
+  ASTRecordLayout::VBaseOffsetsMapTy::const_iterator const &VBaseMapEntry =
       VBaseMap.find(WhichVFPtr.getVBaseWithVPtr());
   assert(VBaseMapEntry != VBaseMap.end());
 
@@ -2890,7 +2850,8 @@
   // in order to get "this" adjustment right.
   TA.Virtual.Microsoft.VBPtrOffset =
       (OffsetOfVBaseWithVFPtr + WhichVFPtr.NonVirtualOffset -
-       MostDerivedClassLayout.getVBPtrOffset()).getQuantity();
+       MostDerivedClassLayout.getVBPtrOffset())
+          .getQuantity();
   TA.Virtual.Microsoft.VBOffsetOffset =
       Context.getTypeSizeInChars(Context.IntTy).getQuantity() *
       VTables.getVBTableIndex(MostDerivedClass, Overrider.VirtualBase);
@@ -2899,20 +2860,20 @@
 }
 
 static void GroupNewVirtualOverloads(
-    const CXXRecordDecl *RD,
-    SmallVector<const CXXMethodDecl *, 10> &VirtualMethods) {
+    CXXRecordDecl const *RD,
+    SmallVector<CXXMethodDecl const *, 10> &VirtualMethods) {
   // Put the virtual methods into VirtualMethods in the proper order:
   // 1) Group overloads by declaration name. New groups are added to the
   //    vftable in the order of their first declarations in this class
   //    (including overrides, non-virtual methods and any other named decl that
   //    might be nested within the class).
   // 2) In each group, new overloads appear in the reverse order of declaration.
-  typedef SmallVector<const CXXMethodDecl *, 1> MethodGroup;
+  typedef SmallVector<CXXMethodDecl const *, 1> MethodGroup;
   SmallVector<MethodGroup, 10> Groups;
   typedef llvm::DenseMap<DeclarationName, unsigned> VisitedGroupIndicesTy;
   VisitedGroupIndicesTy VisitedGroupIndices;
-  for (const auto *D : RD->decls()) {
-    const auto *ND = dyn_cast<NamedDecl>(D);
+  for (auto const *D : RD->decls()) {
+    auto const *ND = dyn_cast<NamedDecl>(D);
     if (!ND)
       continue;
     VisitedGroupIndicesTy::iterator J;
@@ -2921,17 +2882,17 @@
         std::make_pair(ND->getDeclName(), Groups.size()));
     if (Inserted)
       Groups.push_back(MethodGroup());
-    if (const auto *MD = dyn_cast<CXXMethodDecl>(ND))
+    if (auto const *MD = dyn_cast<CXXMethodDecl>(ND))
       if (MicrosoftVTableContext::hasVtableSlot(MD))
         Groups[J->second].push_back(MD->getCanonicalDecl());
   }
 
-  for (const MethodGroup &Group : Groups)
+  for (MethodGroup const &Group : Groups)
     VirtualMethods.append(Group.rbegin(), Group.rend());
 }
 
-static bool isDirectVBase(const CXXRecordDecl *Base, const CXXRecordDecl *RD) {
-  for (const auto &B : RD->bases()) {
+static bool isDirectVBase(CXXRecordDecl const *Base, CXXRecordDecl const *RD) {
+  for (auto const &B : RD->bases()) {
     if (B.isVirtual() && B.getType()->getAsCXXRecordDecl() == Base)
       return true;
   }
@@ -2939,18 +2900,18 @@
 }
 
 void VFTableBuilder::AddMethods(BaseSubobject Base, unsigned BaseDepth,
-                                const CXXRecordDecl *LastVBase,
+                                CXXRecordDecl const *LastVBase,
                                 BasesSetVectorTy &VisitedBases) {
-  const CXXRecordDecl *RD = Base.getBase();
+  CXXRecordDecl const *RD = Base.getBase();
   if (!RD->isPolymorphic())
     return;
 
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
   // See if this class expands a vftable of the base we look at, which is either
   // the one defined by the vfptr base path or the primary base of the current
   // class.
-  const CXXRecordDecl *NextBase = nullptr, *NextLastVBase = LastVBase;
+  CXXRecordDecl const *NextBase = nullptr, *NextLastVBase = LastVBase;
   CharUnits NextBaseOffset;
   if (BaseDepth < WhichVFPtr.PathToIntroducingObject.size()) {
     NextBase = WhichVFPtr.PathToIntroducingObject[BaseDepth];
@@ -2961,7 +2922,7 @@
       NextBaseOffset =
           Base.getBaseOffset() + Layout.getBaseClassOffset(NextBase);
     }
-  } else if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
+  } else if (CXXRecordDecl const *PrimaryBase = Layout.getPrimaryBase()) {
     assert(!Layout.isPrimaryBaseVirtual() &&
            "No primary virtual bases in this ABI");
     NextBase = PrimaryBase;
@@ -2975,7 +2936,7 @@
       llvm_unreachable("Found a duplicate primary base!");
   }
 
-  SmallVector<const CXXMethodDecl*, 10> VirtualMethods;
+  SmallVector<CXXMethodDecl const *, 10> VirtualMethods;
   // Put virtual methods in the proper order.
   GroupNewVirtualOverloads(RD, VirtualMethods);
 
@@ -2987,11 +2948,11 @@
   //    sub-bases;
   //  - adding new slots for methods that require Return adjustment.
   // We keep track of the methods visited in the sub-bases in MethodInfoMap.
-  for (const CXXMethodDecl *MD : VirtualMethods) {
+  for (CXXMethodDecl const *MD : VirtualMethods) {
     FinalOverriders::OverriderInfo FinalOverrider =
         Overriders.getOverrider(MD, Base.getBaseOffset());
-    const CXXMethodDecl *FinalOverriderMD = FinalOverrider.Method;
-    const CXXMethodDecl *OverriddenMD =
+    CXXMethodDecl const *FinalOverriderMD = FinalOverrider.Method;
+    CXXMethodDecl const *OverriddenMD =
         FindNearestOverriddenMethod(MD, VisitedBases);
 
     ThisAdjustment ThisAdjustmentOffset;
@@ -3026,9 +2987,10 @@
       // convertible to the OverriddenMD's one.
       // Once a chain of method overrides adds a return adjusting vftable slot,
       // all subsequent overrides will also use an extra method slot.
-      ReturnAdjustingThunk = !ComputeReturnAdjustmentBaseOffset(
-                                  Context, MD, OverriddenMD).isEmpty() ||
-                             OverriddenMethodInfo.UsesExtraSlot;
+      ReturnAdjustingThunk =
+          !ComputeReturnAdjustmentBaseOffset(Context, MD, OverriddenMD)
+               .isEmpty() ||
+          OverriddenMethodInfo.UsesExtraSlot;
 
       if (!ReturnAdjustingThunk) {
         // No return adjustment needed - just replace the overridden method info
@@ -3081,7 +3043,7 @@
       ReturnAdjustment.NonVirtual =
           ReturnAdjustmentOffset.NonVirtualOffset.getQuantity();
       if (ReturnAdjustmentOffset.VirtualBase) {
-        const ASTRecordLayout &DerivedLayout =
+        ASTRecordLayout const &DerivedLayout =
             Context.getASTRecordLayout(ReturnAdjustmentOffset.DerivedClass);
         ReturnAdjustment.Virtual.Microsoft.VBPtrOffset =
             DerivedLayout.getVBPtrOffset().getQuantity();
@@ -3097,8 +3059,8 @@
   }
 }
 
-static void PrintBasePath(const VPtrInfo::BasePath &Path, raw_ostream &Out) {
-  for (const CXXRecordDecl *Elem :
+static void PrintBasePath(VPtrInfo::BasePath const &Path, raw_ostream &Out) {
+  for (CXXRecordDecl const *Elem :
        llvm::make_range(Path.rbegin(), Path.rend())) {
     Out << "'";
     Elem->printQualifiedName(Out);
@@ -3106,11 +3068,11 @@
   }
 }
 
-static void dumpMicrosoftThunkAdjustment(const ThunkInfo &TI, raw_ostream &Out,
+static void dumpMicrosoftThunkAdjustment(ThunkInfo const &TI, raw_ostream &Out,
                                          bool ContinueFirstLine) {
-  const ReturnAdjustment &R = TI.Return;
+  ReturnAdjustment const &R = TI.Return;
   bool Multiline = false;
-  const char *LinePrefix = "\n       ";
+  char const *LinePrefix = "\n       ";
   if (!R.isEmpty() || TI.Method) {
     if (!ContinueFirstLine)
       Out << LinePrefix;
@@ -3125,7 +3087,7 @@
     Multiline = true;
   }
 
-  const ThisAdjustment &T = TI.This;
+  ThisAdjustment const &T = TI.This;
   if (!T.isEmpty()) {
     if (Multiline || !ContinueFirstLine)
       Out << LinePrefix;
@@ -3156,7 +3118,7 @@
   for (unsigned I = 0, E = Components.size(); I != E; ++I) {
     Out << llvm::format("%4d | ", I);
 
-    const VTableComponent &Component = Components[I];
+    VTableComponent const &Component = Components[I];
 
     // Dump the component.
     switch (Component.getKind()) {
@@ -3166,7 +3128,7 @@
       break;
 
     case VTableComponent::CK_FunctionPointer: {
-      const CXXMethodDecl *MD = Component.getFunctionDecl();
+      CXXMethodDecl const *MD = Component.getFunctionDecl();
 
       // FIXME: Figure out how to print the real thunk type, since they can
       // differ in the return type.
@@ -3187,7 +3149,7 @@
     }
 
     case VTableComponent::CK_DeletingDtorPointer: {
-      const CXXDestructorDecl *DD = Component.getDestructorDecl();
+      CXXDestructorDecl const *DD = Component.getDestructorDecl();
 
       DD->printQualifiedName(Out);
       Out << "() [scalar deleting]";
@@ -3221,23 +3183,23 @@
 
   if (!Thunks.empty()) {
     // We store the method names in a map to get a stable order.
-    std::map<std::string, const CXXMethodDecl *> MethodNamesAndDecls;
+    std::map<std::string, CXXMethodDecl const *> MethodNamesAndDecls;
 
-    for (const auto &I : Thunks) {
-      const CXXMethodDecl *MD = I.first;
+    for (auto const &I : Thunks) {
+      CXXMethodDecl const *MD = I.first;
       std::string MethodName = PredefinedExpr::ComputeName(
           PredefinedExpr::PrettyFunctionNoVirtual, MD);
 
       MethodNamesAndDecls.insert(std::make_pair(MethodName, MD));
     }
 
-    for (const auto &MethodNameAndDecl : MethodNamesAndDecls) {
-      const std::string &MethodName = MethodNameAndDecl.first;
-      const CXXMethodDecl *MD = MethodNameAndDecl.second;
+    for (auto const &MethodNameAndDecl : MethodNamesAndDecls) {
+      std::string const &MethodName = MethodNameAndDecl.first;
+      CXXMethodDecl const *MD = MethodNameAndDecl.second;
 
       ThunkInfoVectorTy ThunksVector = Thunks[MD];
-      llvm::stable_sort(ThunksVector, [](const ThunkInfo &LHS,
-                                         const ThunkInfo &RHS) {
+      llvm::stable_sort(ThunksVector, [](ThunkInfo const &LHS,
+                                         ThunkInfo const &RHS) {
         // Keep different thunks with the same adjustments in the order they
         // were put into the vector.
         return std::tie(LHS.This, LHS.Return) < std::tie(RHS.This, RHS.Return);
@@ -3247,7 +3209,7 @@
       Out << (ThunksVector.size() == 1 ? " entry" : " entries") << ").\n";
 
       for (unsigned I = 0, E = ThunksVector.size(); I != E; ++I) {
-        const ThunkInfo &Thunk = ThunksVector[I];
+        ThunkInfo const &Thunk = ThunksVector[I];
 
         Out << llvm::format("%4d | ", I);
         dumpMicrosoftThunkAdjustment(Thunk, Out, /*ContinueFirstLine=*/true);
@@ -3261,9 +3223,9 @@
   Out.flush();
 }
 
-static bool setsIntersect(const llvm::SmallPtrSet<const CXXRecordDecl *, 4> &A,
-                          ArrayRef<const CXXRecordDecl *> B) {
-  for (const CXXRecordDecl *Decl : B) {
+static bool setsIntersect(llvm::SmallPtrSet<const CXXRecordDecl *, 4> const &A,
+                          ArrayRef<CXXRecordDecl const *> B) {
+  for (CXXRecordDecl const *Decl : B) {
     if (A.count(Decl))
       return true;
   }
@@ -3286,18 +3248,18 @@
 /// ambiguity.  Paths are "ambiguous" if multiple paths have the same set of
 /// components in the same order.  Each group of ambiguous paths is extended by
 /// appending the class of the base from which it came.  If the current class
-/// node produced an ambiguous path, its path is extended with the current class.
-/// After extending paths, MSVC again checks for ambiguity, and extends any
-/// ambiguous path which wasn't already extended.  Because each node yields an
-/// unambiguous set of paths, MSVC doesn't need to extend any path more than once
-/// to produce an unambiguous set of paths.
+/// node produced an ambiguous path, its path is extended with the current
+/// class. After extending paths, MSVC again checks for ambiguity, and extends
+/// any ambiguous path which wasn't already extended.  Because each node yields
+/// an unambiguous set of paths, MSVC doesn't need to extend any path more than
+/// once to produce an unambiguous set of paths.
 ///
 /// TODO: Presumably vftables use the same algorithm.
 void MicrosoftVTableContext::computeVTablePaths(bool ForVBTables,
-                                                const CXXRecordDecl *RD,
+                                                CXXRecordDecl const *RD,
                                                 VPtrInfoVector &Paths) {
   assert(Paths.empty());
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
   // Base case: this subobject has its own vptr.
   if (ForVBTables ? Layout.hasOwnVBPtr() : Layout.hasOwnVFPtr())
@@ -3305,19 +3267,19 @@
 
   // Recursive case: get all the vbtables from our bases and remove anything
   // that shares a virtual base.
-  llvm::SmallPtrSet<const CXXRecordDecl*, 4> VBasesSeen;
-  for (const auto &B : RD->bases()) {
-    const CXXRecordDecl *Base = B.getType()->getAsCXXRecordDecl();
+  llvm::SmallPtrSet<CXXRecordDecl const *, 4> VBasesSeen;
+  for (auto const &B : RD->bases()) {
+    CXXRecordDecl const *Base = B.getType()->getAsCXXRecordDecl();
     if (B.isVirtual() && VBasesSeen.count(Base))
       continue;
 
     if (!Base->isDynamicClass())
       continue;
 
-    const VPtrInfoVector &BasePaths =
+    VPtrInfoVector const &BasePaths =
         ForVBTables ? enumerateVBTables(Base) : getVFPtrOffsets(Base);
 
-    for (const std::unique_ptr<VPtrInfo> &BaseInfo : BasePaths) {
+    for (std::unique_ptr<VPtrInfo> const &BaseInfo : BasePaths) {
       // Don't include the path if it goes through a virtual base that we've
       // already included.
       if (setsIntersect(VBasesSeen, BaseInfo->ContainingVBases))
@@ -3348,7 +3310,7 @@
 
       // Update the full offset in the MDC.
       P->FullOffsetInMDC = P->NonVirtualOffset;
-      if (const CXXRecordDecl *VB = P->getVBaseWithVPtr())
+      if (CXXRecordDecl const *VB = P->getVBaseWithVPtr())
         P->FullOffsetInMDC += Layout.getVBaseClassOffset(VB);
 
       Paths.push_back(std::move(P));
@@ -3359,7 +3321,7 @@
 
     // After visiting any direct base, we've transitively visited all of its
     // morally virtual bases.
-    for (const auto &VB : Base->vbases())
+    for (auto const &VB : Base->vbases())
       VBasesSeen.insert(VB.getType()->getAsCXXRecordDecl());
   }
 
@@ -3373,7 +3335,7 @@
 static bool extendPath(VPtrInfo &P) {
   if (P.NextBaseToMangle) {
     P.MangledPath.push_back(P.NextBaseToMangle);
-    P.NextBaseToMangle = nullptr;// Prevent the path from being extended twice.
+    P.NextBaseToMangle = nullptr; // Prevent the path from being extended twice.
     return true;
   }
   return false;
@@ -3388,9 +3350,9 @@
   // current algorithm is designed to match MSVC 2012's names.
   llvm::SmallVector<std::reference_wrapper<VPtrInfo>, 2> PathsSorted;
   PathsSorted.reserve(Paths.size());
-  for (auto& P : Paths)
+  for (auto &P : Paths)
     PathsSorted.push_back(*P);
-  llvm::sort(PathsSorted, [](const VPtrInfo &LHS, const VPtrInfo &RHS) {
+  llvm::sort(PathsSorted, [](VPtrInfo const &LHS, VPtrInfo const &RHS) {
     return LHS.MangledPath < RHS.MangledPath;
   });
   bool Changed = false;
@@ -3399,9 +3361,8 @@
     size_t BucketStart = I;
     do {
       ++I;
-    } while (I != E &&
-             PathsSorted[BucketStart].get().MangledPath ==
-                 PathsSorted[I].get().MangledPath);
+    } while (I != E && PathsSorted[BucketStart].get().MangledPath ==
+                           PathsSorted[I].get().MangledPath);
 
     // If this bucket has multiple paths, extend them all.
     if (I - BucketStart > 1) {
@@ -3417,14 +3378,15 @@
 
 namespace {
 typedef llvm::SetVector<BaseSubobject, std::vector<BaseSubobject>,
-                        llvm::DenseSet<BaseSubobject>> FullPathTy;
+                        llvm::DenseSet<BaseSubobject>>
+    FullPathTy;
 }
 
 // This recursive function finds all paths from a subobject centered at
 // (RD, Offset) to the subobject located at IntroducingObject.
 static void findPathsToSubobject(ASTContext &Context,
-                                 const ASTRecordLayout &MostDerivedLayout,
-                                 const CXXRecordDecl *RD, CharUnits Offset,
+                                 ASTRecordLayout const &MostDerivedLayout,
+                                 CXXRecordDecl const *RD, CharUnits Offset,
                                  BaseSubobject IntroducingObject,
                                  FullPathTy &FullPath,
                                  std::list<FullPathTy> &Paths) {
@@ -3433,10 +3395,10 @@
     return;
   }
 
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
 
-  for (const CXXBaseSpecifier &BS : RD->bases()) {
-    const CXXRecordDecl *Base = BS.getType()->getAsCXXRecordDecl();
+  for (CXXBaseSpecifier const &BS : RD->bases()) {
+    CXXRecordDecl const *Base = BS.getType()->getAsCXXRecordDecl();
     CharUnits NewOffset = BS.isVirtual()
                               ? MostDerivedLayout.getVBaseClassOffset(Base)
                               : Offset + Layout.getBaseClassOffset(Base);
@@ -3449,7 +3411,7 @@
 
 // Return the paths which are not subsets of other paths.
 static void removeRedundantPaths(std::list<FullPathTy> &FullPaths) {
-  FullPaths.remove_if([&](const FullPathTy &SpecificPath) {
+  FullPaths.remove_if([&](FullPathTy const &SpecificPath) {
     for (const FullPathTy &OtherPath : FullPaths) {
       if (&SpecificPath == &OtherPath)
         continue;
@@ -3464,13 +3426,12 @@
 }
 
 static CharUnits getOffsetOfFullPath(ASTContext &Context,
-                                     const CXXRecordDecl *RD,
-                                     const FullPathTy &FullPath) {
-  const ASTRecordLayout &MostDerivedLayout =
-      Context.getASTRecordLayout(RD);
+                                     CXXRecordDecl const *RD,
+                                     FullPathTy const &FullPath) {
+  ASTRecordLayout const &MostDerivedLayout = Context.getASTRecordLayout(RD);
   CharUnits Offset = CharUnits::fromQuantity(-1);
-  for (const BaseSubobject &BSO : FullPath) {
-    const CXXRecordDecl *Base = BSO.getBase();
+  for (BaseSubobject const &BSO : FullPath) {
+    CXXRecordDecl const *Base = BSO.getBase();
     // The first entry in the path is always the most derived record, skip it.
     if (Base == RD) {
       assert(Offset.getQuantity() == -1);
@@ -3478,11 +3439,11 @@
       continue;
     }
     assert(Offset.getQuantity() != -1);
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
     // While we know which base has to be traversed, we don't know if that base
     // was a virtual base.
-    const CXXBaseSpecifier *BaseBS = std::find_if(
-        RD->bases_begin(), RD->bases_end(), [&](const CXXBaseSpecifier &BS) {
+    CXXBaseSpecifier const *BaseBS = std::find_if(
+        RD->bases_begin(), RD->bases_end(), [&](CXXBaseSpecifier const &BS) {
           return BS.getType()->getAsCXXRecordDecl() == Base;
         });
     Offset = BaseBS->isVirtual() ? MostDerivedLayout.getVBaseClassOffset(Base)
@@ -3495,9 +3456,9 @@
 // We want to select the path which introduces the most covariant overrides.  If
 // two paths introduce overrides which the other path doesn't contain, issue a
 // diagnostic.
-static const FullPathTy *selectBestPath(ASTContext &Context,
-                                        const CXXRecordDecl *RD,
-                                        const VPtrInfo &Info,
+static FullPathTy const *selectBestPath(ASTContext &Context,
+                                        CXXRecordDecl const *RD,
+                                        VPtrInfo const &Info,
                                         std::list<FullPathTy> &FullPaths) {
   // Handle some easy cases first.
   if (FullPaths.empty())
@@ -3505,24 +3466,24 @@
   if (FullPaths.size() == 1)
     return &FullPaths.front();
 
-  const FullPathTy *BestPath = nullptr;
-  typedef std::set<const CXXMethodDecl *> OverriderSetTy;
+  FullPathTy const *BestPath = nullptr;
+  typedef std::set<CXXMethodDecl const *> OverriderSetTy;
   OverriderSetTy LastOverrides;
-  for (const FullPathTy &SpecificPath : FullPaths) {
+  for (FullPathTy const &SpecificPath : FullPaths) {
     assert(!SpecificPath.empty());
     OverriderSetTy CurrentOverrides;
-    const CXXRecordDecl *TopLevelRD = SpecificPath.begin()->getBase();
+    CXXRecordDecl const *TopLevelRD = SpecificPath.begin()->getBase();
     // Find the distance from the start of the path to the subobject with the
     // VPtr.
     CharUnits BaseOffset =
         getOffsetOfFullPath(Context, TopLevelRD, SpecificPath);
     FinalOverriders Overriders(TopLevelRD, CharUnits::Zero(), TopLevelRD);
-    for (const CXXMethodDecl *MD : Info.IntroducingObject->methods()) {
+    for (CXXMethodDecl const *MD : Info.IntroducingObject->methods()) {
       if (!MicrosoftVTableContext::hasVtableSlot(MD))
         continue;
       FinalOverriders::OverriderInfo OI =
           Overriders.getOverrider(MD->getCanonicalDecl(), BaseOffset);
-      const CXXMethodDecl *OverridingMethod = OI.Method;
+      CXXMethodDecl const *OverridingMethod = OI.Method;
       // Only overriders which have a return adjustment introduce problematic
       // thunks.
       if (ComputeReturnAdjustmentBaseOffset(Context, OverridingMethod, MD)
@@ -3530,8 +3491,8 @@
         continue;
       // It's possible that the overrider isn't in this path.  If so, skip it
       // because this path didn't introduce it.
-      const CXXRecordDecl *OverridingParent = OverridingMethod->getParent();
-      if (llvm::none_of(SpecificPath, [&](const BaseSubobject &BSO) {
+      CXXRecordDecl const *OverridingParent = OverridingMethod->getParent();
+      if (llvm::none_of(SpecificPath, [&](BaseSubobject const &BSO) {
             return BSO.getBase() == OverridingParent;
           }))
         continue;
@@ -3550,8 +3511,8 @@
     } else {
       // This path introduces an overrider with a conflicting covariant thunk.
       DiagnosticsEngine &Diags = Context.getDiagnostics();
-      const CXXMethodDecl *CovariantMD = *NewOverrides.begin();
-      const CXXMethodDecl *ConflictMD = *MissingOverrides.begin();
+      CXXMethodDecl const *CovariantMD = *NewOverrides.begin();
+      CXXMethodDecl const *ConflictMD = *MissingOverrides.begin();
       Diags.Report(RD->getLocation(), diag::err_vftable_ambiguous_component)
           << RD;
       Diags.Report(CovariantMD->getLocation(), diag::note_covariant_thunk)
@@ -3566,12 +3527,12 @@
 }
 
 static void computeFullPathsForVFTables(ASTContext &Context,
-                                        const CXXRecordDecl *RD,
+                                        CXXRecordDecl const *RD,
                                         VPtrInfoVector &Paths) {
-  const ASTRecordLayout &MostDerivedLayout = Context.getASTRecordLayout(RD);
+  ASTRecordLayout const &MostDerivedLayout = Context.getASTRecordLayout(RD);
   FullPathTy FullPath;
   std::list<FullPathTy> FullPaths;
-  for (const std::unique_ptr<VPtrInfo>& Info : Paths) {
+  for (std::unique_ptr<VPtrInfo> const &Info : Paths) {
     findPathsToSubobject(
         Context, MostDerivedLayout, RD, CharUnits::Zero(),
         BaseSubobject(Info->IntroducingObject, Info->FullOffsetInMDC), FullPath,
@@ -3579,17 +3540,17 @@
     FullPath.clear();
     removeRedundantPaths(FullPaths);
     Info->PathToIntroducingObject.clear();
-    if (const FullPathTy *BestPath =
+    if (FullPathTy const *BestPath =
             selectBestPath(Context, RD, *Info, FullPaths))
-      for (const BaseSubobject &BSO : *BestPath)
+      for (BaseSubobject const &BSO : *BestPath)
         Info->PathToIntroducingObject.push_back(BSO.getBase());
     FullPaths.clear();
   }
 }
 
-static bool vfptrIsEarlierInMDC(const ASTRecordLayout &Layout,
-                                const MethodVFTableLocation &LHS,
-                                const MethodVFTableLocation &RHS) {
+static bool vfptrIsEarlierInMDC(ASTRecordLayout const &Layout,
+                                MethodVFTableLocation const &LHS,
+                                MethodVFTableLocation const &RHS) {
   CharUnits L = LHS.VFPtrOffset;
   CharUnits R = RHS.VFPtrOffset;
   if (LHS.VBase)
@@ -3600,7 +3561,7 @@
 }
 
 void MicrosoftVTableContext::computeVTableRelatedInformation(
-    const CXXRecordDecl *RD) {
+    CXXRecordDecl const *RD) {
   assert(RD->isDynamicClass());
 
   // Check if we've computed this information before.
@@ -3617,7 +3578,7 @@
   }
 
   MethodVFTableLocationsTy NewMethodLocations;
-  for (const std::unique_ptr<VPtrInfo> &VFPtr : *VFPtrLocations[RD]) {
+  for (std::unique_ptr<VPtrInfo> const &VFPtr : *VFPtrLocations[RD]) {
     VFTableBuilder Builder(*this, RD, *VFPtr);
 
     VFTableIdTy id(RD, VFPtr->FullOffsetInMDC);
@@ -3629,11 +3590,11 @@
         EmptyAddressPointsMap);
     Thunks.insert(Builder.thunks_begin(), Builder.thunks_end());
 
-    const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
-    for (const auto &Loc : Builder.vtable_locations()) {
+    ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
+    for (auto const &Loc : Builder.vtable_locations()) {
       auto Insert = NewMethodLocations.insert(Loc);
       if (!Insert.second) {
-        const MethodVFTableLocation &NewLoc = Loc.second;
+        MethodVFTableLocation const &NewLoc = Loc.second;
         MethodVFTableLocation &OldLoc = Insert.first->second;
         if (vfptrIsEarlierInMDC(Layout, NewLoc, OldLoc))
           OldLoc = NewLoc;
@@ -3648,15 +3609,15 @@
 }
 
 void MicrosoftVTableContext::dumpMethodLocations(
-    const CXXRecordDecl *RD, const MethodVFTableLocationsTy &NewMethods,
+    CXXRecordDecl const *RD, MethodVFTableLocationsTy const &NewMethods,
     raw_ostream &Out) {
   // Compute the vtable indices for all the member functions.
   // Store them in a map keyed by the location so we'll get a sorted table.
   std::map<MethodVFTableLocation, std::string> IndicesMap;
   bool HasNonzeroOffset = false;
 
-  for (const auto &I : NewMethods) {
-    const CXXMethodDecl *MD = cast<const CXXMethodDecl>(I.first.getDecl());
+  for (auto const &I : NewMethods) {
+    CXXMethodDecl const *MD = cast<const CXXMethodDecl>(I.first.getDecl());
     assert(hasVtableSlot(MD));
 
     std::string MethodName = PredefinedExpr::ComputeName(
@@ -3682,7 +3643,7 @@
 
     CharUnits LastVFPtrOffset = CharUnits::fromQuantity(-1);
     uint64_t LastVBIndex = 0;
-    for (const auto &I : IndicesMap) {
+    for (auto const &I : IndicesMap) {
       CharUnits VFPtrOffset = I.first.VFPtrOffset;
       uint64_t VBIndex = I.first.VBTableIndex;
       if (HasNonzeroOffset &&
@@ -3697,7 +3658,7 @@
       }
 
       uint64_t VTableIndex = I.first.Index;
-      const std::string &MethodName = I.second;
+      std::string const &MethodName = I.second;
       Out << llvm::format("%4" PRIu64 " | ", VTableIndex) << MethodName << '\n';
     }
     Out << '\n';
@@ -3706,8 +3667,8 @@
   Out.flush();
 }
 
-const VirtualBaseInfo &MicrosoftVTableContext::computeVBTableRelatedInformation(
-    const CXXRecordDecl *RD) {
+VirtualBaseInfo const &MicrosoftVTableContext::computeVBTableRelatedInformation(
+    CXXRecordDecl const *RD) {
   VirtualBaseInfo *VBI;
 
   {
@@ -3723,11 +3684,11 @@
   computeVTablePaths(/*ForVBTables=*/true, RD, VBI->VBPtrPaths);
 
   // First, see if the Derived class shared the vbptr with a non-virtual base.
-  const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
-  if (const CXXRecordDecl *VBPtrBase = Layout.getBaseSharingVBPtr()) {
+  ASTRecordLayout const &Layout = Context.getASTRecordLayout(RD);
+  if (CXXRecordDecl const *VBPtrBase = Layout.getBaseSharingVBPtr()) {
     // If the Derived class shares the vbptr with a non-virtual base, the shared
     // virtual bases come first so that the layout is the same.
-    const VirtualBaseInfo &BaseInfo =
+    VirtualBaseInfo const &BaseInfo =
         computeVBTableRelatedInformation(VBPtrBase);
     VBI->VBTableIndices.insert(BaseInfo.VBTableIndices.begin(),
                                BaseInfo.VBTableIndices.end());
@@ -3736,8 +3697,8 @@
   // New vbases are added to the end of the vbtable.
   // Skip the self entry and vbases visited in the non-virtual base, if any.
   unsigned VBTableIndex = 1 + VBI->VBTableIndices.size();
-  for (const auto &VB : RD->vbases()) {
-    const CXXRecordDecl *CurVBase = VB.getType()->getAsCXXRecordDecl();
+  for (auto const &VB : RD->vbases()) {
+    CXXRecordDecl const *CurVBase = VB.getType()->getAsCXXRecordDecl();
     if (!VBI->VBTableIndices.count(CurVBase))
       VBI->VBTableIndices[CurVBase] = VBTableIndex++;
   }
@@ -3745,28 +3706,28 @@
   return *VBI;
 }
 
-unsigned MicrosoftVTableContext::getVBTableIndex(const CXXRecordDecl *Derived,
-                                                 const CXXRecordDecl *VBase) {
-  const VirtualBaseInfo &VBInfo = computeVBTableRelatedInformation(Derived);
+unsigned MicrosoftVTableContext::getVBTableIndex(CXXRecordDecl const *Derived,
+                                                 CXXRecordDecl const *VBase) {
+  VirtualBaseInfo const &VBInfo = computeVBTableRelatedInformation(Derived);
   assert(VBInfo.VBTableIndices.count(VBase));
   return VBInfo.VBTableIndices.find(VBase)->second;
 }
 
-const VPtrInfoVector &
-MicrosoftVTableContext::enumerateVBTables(const CXXRecordDecl *RD) {
+VPtrInfoVector const &
+MicrosoftVTableContext::enumerateVBTables(CXXRecordDecl const *RD) {
   return computeVBTableRelatedInformation(RD).VBPtrPaths;
 }
 
-const VPtrInfoVector &
-MicrosoftVTableContext::getVFPtrOffsets(const CXXRecordDecl *RD) {
+VPtrInfoVector const &
+MicrosoftVTableContext::getVFPtrOffsets(CXXRecordDecl const *RD) {
   computeVTableRelatedInformation(RD);
 
   assert(VFPtrLocations.count(RD) && "Couldn't find vfptr locations");
   return *VFPtrLocations[RD];
 }
 
-const VTableLayout &
-MicrosoftVTableContext::getVFTableLayout(const CXXRecordDecl *RD,
+VTableLayout const &
+MicrosoftVTableContext::getVFTableLayout(CXXRecordDecl const *RD,
                                          CharUnits VFPtrOffset) {
   computeVTableRelatedInformation(RD);
 
@@ -3788,7 +3749,7 @@
   if (I != MethodVFTableLocations.end())
     return I->second;
 
-  const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
+  CXXRecordDecl const *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
 
   computeVTableRelatedInformation(RD);
 
Index: clang/lib/Basic/Attributes.cpp
===================================================================
--- clang/lib/Basic/Attributes.cpp
+++ clang/lib/Basic/Attributes.cpp
@@ -5,9 +5,9 @@
 #include "llvm/ADT/StringSwitch.h"
 using namespace clang;
 
-int clang::hasAttribute(AttrSyntax Syntax, const IdentifierInfo *Scope,
-                        const IdentifierInfo *Attr, const TargetInfo &Target,
-                        const LangOptions &LangOpts) {
+int clang::hasAttribute(AttrSyntax Syntax, IdentifierInfo const *Scope,
+                        IdentifierInfo const *Attr, TargetInfo const &Target,
+                        LangOptions const &LangOpts) {
   StringRef Name = Attr->getName();
   // Normalize the attribute name, __foo__ becomes foo.
   if (Name.size() >= 4 && Name.startswith("__") && Name.endswith("__"))
@@ -33,7 +33,7 @@
   return 0;
 }
 
-const char *attr::getSubjectMatchRuleSpelling(attr::SubjectMatchRule Rule) {
+char const *attr::getSubjectMatchRuleSpelling(attr::SubjectMatchRule Rule) {
   switch (Rule) {
 #define ATTR_MATCH_RULE(NAME, SPELLING, IsAbstract)                            \
   case attr::NAME:                                                             \
@@ -44,7 +44,7 @@
 }
 
 static StringRef
-normalizeAttrScopeName(const IdentifierInfo *Scope,
+normalizeAttrScopeName(IdentifierInfo const *Scope,
                        AttributeCommonInfo::Syntax SyntaxUsed) {
   if (!Scope)
     return "";
@@ -62,7 +62,7 @@
   return ScopeName;
 }
 
-static StringRef normalizeAttrName(const IdentifierInfo *Name,
+static StringRef normalizeAttrName(IdentifierInfo const *Name,
                                    StringRef NormalizedScopeName,
                                    AttributeCommonInfo::Syntax SyntaxUsed) {
   // Normalize the attribute name, __foo__ becomes foo. This is only allowable
@@ -87,8 +87,8 @@
 
 #include "clang/Sema/AttrParsedAttrKinds.inc"
 
-static SmallString<64> normalizeName(const IdentifierInfo *Name,
-                                     const IdentifierInfo *Scope,
+static SmallString<64> normalizeName(IdentifierInfo const *Name,
+                                     IdentifierInfo const *Scope,
                                      AttributeCommonInfo::Syntax SyntaxUsed) {
   StringRef ScopeName = normalizeAttrScopeName(Scope, SyntaxUsed);
   StringRef AttrName = normalizeAttrName(Name, ScopeName, SyntaxUsed);
@@ -105,8 +105,8 @@
 }
 
 AttributeCommonInfo::Kind
-AttributeCommonInfo::getParsedKind(const IdentifierInfo *Name,
-                                   const IdentifierInfo *ScopeName,
+AttributeCommonInfo::getParsedKind(IdentifierInfo const *Name,
+                                   IdentifierInfo const *ScopeName,
                                    Syntax SyntaxUsed) {
   return ::getAttrKind(normalizeName(Name, ScopeName, SyntaxUsed), SyntaxUsed);
 }
Index: clang/lib/Basic/Builtins.cpp
===================================================================
--- clang/lib/Basic/Builtins.cpp
+++ clang/lib/Basic/Builtins.cpp
@@ -18,17 +18,18 @@
 using namespace clang;
 
 static const Builtin::Info BuiltinInfo[] = {
-  { "not a builtin function", nullptr, nullptr, nullptr, ALL_LANGUAGES,nullptr},
+    {"not a builtin function", nullptr, nullptr, nullptr, ALL_LANGUAGES,
+     nullptr},
 #define BUILTIN(ID, TYPE, ATTRS)                                               \
-  { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
+  {#ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr},
 #define LANGBUILTIN(ID, TYPE, ATTRS, LANGS)                                    \
-  { #ID, TYPE, ATTRS, nullptr, LANGS, nullptr },
+  {#ID, TYPE, ATTRS, nullptr, LANGS, nullptr},
 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER, LANGS)                             \
-  { #ID, TYPE, ATTRS, HEADER, LANGS, nullptr },
+  {#ID, TYPE, ATTRS, HEADER, LANGS, nullptr},
 #include "clang/Basic/Builtins.def"
 };
 
-const Builtin::Info &Builtin::Context::getRecord(unsigned ID) const {
+Builtin::Info const &Builtin::Context::getRecord(unsigned ID) const {
   if (ID < Builtin::FirstTSBuiltin)
     return BuiltinInfo[ID];
   assert(((ID - Builtin::FirstTSBuiltin) <
@@ -39,8 +40,8 @@
   return TSRecords[ID - Builtin::FirstTSBuiltin];
 }
 
-void Builtin::Context::InitializeTarget(const TargetInfo &Target,
-                                        const TargetInfo *AuxTarget) {
+void Builtin::Context::InitializeTarget(TargetInfo const &Target,
+                                        TargetInfo const *AuxTarget) {
   assert(TSRecords.empty() && "Already initialized target?");
   TSRecords = Target.getTargetBuiltins();
   if (AuxTarget)
@@ -55,27 +56,28 @@
   return false;
 }
 
-bool Builtin::Context::builtinIsSupported(const Builtin::Info &BuiltinInfo,
-                                          const LangOptions &LangOpts) {
+bool Builtin::Context::builtinIsSupported(Builtin::Info const &BuiltinInfo,
+                                          LangOptions const &LangOpts) {
   bool BuiltinsUnsupported =
       (LangOpts.NoBuiltin || LangOpts.isNoBuiltinFunc(BuiltinInfo.Name)) &&
       strchr(BuiltinInfo.Attributes, 'f');
   bool CorBuiltinsUnsupported =
       !LangOpts.Coroutines && (BuiltinInfo.Langs & COR_LANG);
   bool MathBuiltinsUnsupported =
-    LangOpts.NoMathBuiltin && BuiltinInfo.HeaderName &&
-    llvm::StringRef(BuiltinInfo.HeaderName).equals("math.h");
+      LangOpts.NoMathBuiltin && BuiltinInfo.HeaderName &&
+      llvm::StringRef(BuiltinInfo.HeaderName).equals("math.h");
   bool GnuModeUnsupported = !LangOpts.GNUMode && (BuiltinInfo.Langs & GNU_LANG);
   bool MSModeUnsupported =
       !LangOpts.MicrosoftExt && (BuiltinInfo.Langs & MS_LANG);
   bool ObjCUnsupported = !LangOpts.ObjC && BuiltinInfo.Langs == OBJC_LANG;
-  bool OclC1Unsupported = (LangOpts.OpenCLVersion / 100) != 1 &&
-                          (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES ) ==  OCLC1X_LANG;
+  bool OclC1Unsupported =
+      (LangOpts.OpenCLVersion / 100) != 1 &&
+      (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES) == OCLC1X_LANG;
   bool OclC2Unsupported =
       (LangOpts.getOpenCLCompatibleVersion() != 200) &&
       (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES) == OCLC20_LANG;
-  bool OclCUnsupported = !LangOpts.OpenCL &&
-                         (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES);
+  bool OclCUnsupported =
+      !LangOpts.OpenCL && (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES);
   bool OpenMPUnsupported = !LangOpts.OpenMP && BuiltinInfo.Langs == OMP_LANG;
   bool CUDAUnsupported = !LangOpts.CUDA && BuiltinInfo.Langs == CUDA_LANG;
   bool CPlusPlusUnsupported =
@@ -91,9 +93,9 @@
 /// appropriate builtin ID # and mark any non-portable builtin identifiers as
 /// such.
 void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
-                                          const LangOptions& LangOpts) {
+                                          LangOptions const &LangOpts) {
   // Step #1: mark all target-independent builtins with their ID's.
-  for (unsigned i = Builtin::NotBuiltin+1; i != Builtin::FirstTSBuiltin; ++i)
+  for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin; ++i)
     if (builtinIsSupported(BuiltinInfo[i], LangOpts)) {
       Table.get(BuiltinInfo[i].Name).setBuiltinID(i);
     }
@@ -110,7 +112,7 @@
 }
 
 unsigned Builtin::Context::getRequiredVectorWidth(unsigned ID) const {
-  const char *WidthPos = ::strchr(getRecord(ID).Attributes, 'V');
+  char const *WidthPos = ::strchr(getRecord(ID).Attributes, 'V');
   if (!WidthPos)
     return 0;
 
@@ -126,14 +128,13 @@
 }
 
 bool Builtin::Context::isLike(unsigned ID, unsigned &FormatIdx,
-                              bool &HasVAListArg, const char *Fmt) const {
+                              bool &HasVAListArg, char const *Fmt) const {
   assert(Fmt && "Not passed a format string");
-  assert(::strlen(Fmt) == 2 &&
-         "Format string needs to be two characters long");
+  assert(::strlen(Fmt) == 2 && "Format string needs to be two characters long");
   assert(::toupper(Fmt[0]) == Fmt[1] &&
          "Format string is not in the form \"xX\"");
 
-  const char *Like = ::strpbrk(getRecord(ID).Attributes, Fmt);
+  char const *Like = ::strpbrk(getRecord(ID).Attributes, Fmt);
   if (!Like)
     return false;
 
@@ -160,7 +161,7 @@
 
 bool Builtin::Context::performsCallback(unsigned ID,
                                         SmallVectorImpl<int> &Encoding) const {
-  const char *CalleePos = ::strchr(getRecord(ID).Attributes, 'C');
+  char const *CalleePos = ::strchr(getRecord(ID).Attributes, 'C');
   if (!CalleePos)
     return false;
 
@@ -175,7 +176,7 @@
   Encoding.push_back(CalleeIdx);
 
   while (*EndPos == ',') {
-    const char *PayloadPos = EndPos + 1;
+    char const *PayloadPos = EndPos + 1;
 
     int PayloadIdx = ::strtol(PayloadPos, &EndPos, 10);
     Encoding.push_back(PayloadIdx);
@@ -186,8 +187,6 @@
 }
 
 bool Builtin::Context::canBeRedeclared(unsigned ID) const {
-  return ID == Builtin::NotBuiltin ||
-         ID == Builtin::BI__va_start ||
-         (!hasReferenceArgsOrResult(ID) &&
-          !hasCustomTypechecking(ID));
+  return ID == Builtin::NotBuiltin || ID == Builtin::BI__va_start ||
+         (!hasReferenceArgsOrResult(ID) && !hasCustomTypechecking(ID));
 }
Index: clang/lib/Basic/CharInfo.cpp
===================================================================
--- clang/lib/Basic/CharInfo.cpp
+++ clang/lib/Basic/CharInfo.cpp
@@ -13,68 +13,64 @@
 // Statically initialize CharInfo table based on ASCII character set
 // Reference: FreeBSD 7.2 /usr/share/misc/ascii
 const uint16_t clang::charinfo::InfoTable[256] = {
-  // 0 NUL         1 SOH         2 STX         3 ETX
-  // 4 EOT         5 ENQ         6 ACK         7 BEL
-  0           , 0           , 0           , 0           ,
-  0           , 0           , 0           , 0           ,
-  // 8 BS          9 HT         10 NL         11 VT
-  //12 NP         13 CR         14 SO         15 SI
-  0           , CHAR_HORZ_WS, CHAR_VERT_WS, CHAR_HORZ_WS,
-  CHAR_HORZ_WS, CHAR_VERT_WS, 0           , 0           ,
-  //16 DLE        17 DC1        18 DC2        19 DC3
-  //20 DC4        21 NAK        22 SYN        23 ETB
-  0           , 0           , 0           , 0           ,
-  0           , 0           , 0           , 0           ,
-  //24 CAN        25 EM         26 SUB        27 ESC
-  //28 FS         29 GS         30 RS         31 US
-  0           , 0           , 0           , 0           ,
-  0           , 0           , 0           , 0           ,
-  //32 SP         33  !         34  "         35  #
-  //36  $         37  %         38  &         39  '
-  CHAR_SPACE  , CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL ,
-  CHAR_PUNCT  , CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL ,
-  //40  (         41  )         42  *         43  +
-  //44  ,         45  -         46  .         47  /
-  CHAR_PUNCT  , CHAR_PUNCT  , CHAR_RAWDEL , CHAR_RAWDEL ,
-  CHAR_RAWDEL , CHAR_RAWDEL , CHAR_PERIOD , CHAR_RAWDEL ,
-  //48  0         49  1         50  2         51  3
-  //52  4         53  5         54  6         55  7
-  CHAR_DIGIT  , CHAR_DIGIT  , CHAR_DIGIT  , CHAR_DIGIT  ,
-  CHAR_DIGIT  , CHAR_DIGIT  , CHAR_DIGIT  , CHAR_DIGIT  ,
-  //56  8         57  9         58  :         59  ;
-  //60  <         61  =         62  >         63  ?
-  CHAR_DIGIT  , CHAR_DIGIT  , CHAR_RAWDEL , CHAR_RAWDEL ,
-  CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL ,
-  //64  @         65  A         66  B         67  C
-  //68  D         69  E         70  F         71  G
-  CHAR_PUNCT  , CHAR_XUPPER , CHAR_XUPPER , CHAR_XUPPER ,
-  CHAR_XUPPER , CHAR_XUPPER , CHAR_XUPPER , CHAR_UPPER  ,
-  //72  H         73  I         74  J         75  K
-  //76  L         77  M         78  N         79  O
-  CHAR_UPPER  , CHAR_UPPER  , CHAR_UPPER  , CHAR_UPPER  ,
-  CHAR_UPPER  , CHAR_UPPER  , CHAR_UPPER  , CHAR_UPPER  ,
-  //80  P         81  Q         82  R         83  S
-  //84  T         85  U         86  V         87  W
-  CHAR_UPPER  , CHAR_UPPER  , CHAR_UPPER  , CHAR_UPPER  ,
-  CHAR_UPPER  , CHAR_UPPER  , CHAR_UPPER  , CHAR_UPPER  ,
-  //88  X         89  Y         90  Z         91  [
-  //92  \         93  ]         94  ^         95  _
-  CHAR_UPPER  , CHAR_UPPER  , CHAR_UPPER  , CHAR_RAWDEL ,
-  CHAR_PUNCT  , CHAR_RAWDEL , CHAR_RAWDEL , CHAR_UNDER  ,
-  //96  `         97  a         98  b         99  c
-  //100  d       101  e        102  f        103  g
-  CHAR_PUNCT  , CHAR_XLOWER , CHAR_XLOWER , CHAR_XLOWER ,
-  CHAR_XLOWER , CHAR_XLOWER , CHAR_XLOWER , CHAR_LOWER  ,
-  //104  h       105  i        106  j        107  k
-  //108  l       109  m        110  n        111  o
-  CHAR_LOWER  , CHAR_LOWER  , CHAR_LOWER  , CHAR_LOWER  ,
-  CHAR_LOWER  , CHAR_LOWER  , CHAR_LOWER  , CHAR_LOWER  ,
-  //112  p       113  q        114  r        115  s
-  //116  t       117  u        118  v        119  w
-  CHAR_LOWER  , CHAR_LOWER  , CHAR_LOWER  , CHAR_LOWER  ,
-  CHAR_LOWER  , CHAR_LOWER  , CHAR_LOWER  , CHAR_LOWER  ,
-  //120  x       121  y        122  z        123  {
-  //124  |       125  }        126  ~        127 DEL
-  CHAR_LOWER  , CHAR_LOWER  , CHAR_LOWER  , CHAR_RAWDEL ,
-  CHAR_RAWDEL , CHAR_RAWDEL , CHAR_RAWDEL , 0
-};
+    // 0 NUL         1 SOH         2 STX         3 ETX
+    // 4 EOT         5 ENQ         6 ACK         7 BEL
+    0, 0, 0, 0, 0, 0, 0, 0,
+    // 8 BS          9 HT         10 NL         11 VT
+    // 12 NP         13 CR         14 SO         15 SI
+    0, CHAR_HORZ_WS, CHAR_VERT_WS, CHAR_HORZ_WS, CHAR_HORZ_WS, CHAR_VERT_WS, 0,
+    0,
+    // 16 DLE        17 DC1        18 DC2        19 DC3
+    // 20 DC4        21 NAK        22 SYN        23 ETB
+    0, 0, 0, 0, 0, 0, 0, 0,
+    // 24 CAN        25 EM         26 SUB        27 ESC
+    // 28 FS         29 GS         30 RS         31 US
+    0, 0, 0, 0, 0, 0, 0, 0,
+    // 32 SP         33  !         34  "         35  #
+    // 36  $         37  %         38  &         39  '
+    CHAR_SPACE, CHAR_RAWDEL, CHAR_RAWDEL, CHAR_RAWDEL, CHAR_PUNCT, CHAR_RAWDEL,
+    CHAR_RAWDEL, CHAR_RAWDEL,
+    // 40  (         41  )         42  *         43  +
+    // 44  ,         45  -         46  .         47  /
+    CHAR_PUNCT, CHAR_PUNCT, CHAR_RAWDEL, CHAR_RAWDEL, CHAR_RAWDEL, CHAR_RAWDEL,
+    CHAR_PERIOD, CHAR_RAWDEL,
+    // 48  0         49  1         50  2         51  3
+    // 52  4         53  5         54  6         55  7
+    CHAR_DIGIT, CHAR_DIGIT, CHAR_DIGIT, CHAR_DIGIT, CHAR_DIGIT, CHAR_DIGIT,
+    CHAR_DIGIT, CHAR_DIGIT,
+    // 56  8         57  9         58  :         59  ;
+    // 60  <         61  =         62  >         63  ?
+    CHAR_DIGIT, CHAR_DIGIT, CHAR_RAWDEL, CHAR_RAWDEL, CHAR_RAWDEL, CHAR_RAWDEL,
+    CHAR_RAWDEL, CHAR_RAWDEL,
+    // 64  @         65  A         66  B         67  C
+    // 68  D         69  E         70  F         71  G
+    CHAR_PUNCT, CHAR_XUPPER, CHAR_XUPPER, CHAR_XUPPER, CHAR_XUPPER, CHAR_XUPPER,
+    CHAR_XUPPER, CHAR_UPPER,
+    // 72  H         73  I         74  J         75  K
+    // 76  L         77  M         78  N         79  O
+    CHAR_UPPER, CHAR_UPPER, CHAR_UPPER, CHAR_UPPER, CHAR_UPPER, CHAR_UPPER,
+    CHAR_UPPER, CHAR_UPPER,
+    // 80  P         81  Q         82  R         83  S
+    // 84  T         85  U         86  V         87  W
+    CHAR_UPPER, CHAR_UPPER, CHAR_UPPER, CHAR_UPPER, CHAR_UPPER, CHAR_UPPER,
+    CHAR_UPPER, CHAR_UPPER,
+    // 88  X         89  Y         90  Z         91  [
+    // 92  \         93  ]         94  ^         95  _
+    CHAR_UPPER, CHAR_UPPER, CHAR_UPPER, CHAR_RAWDEL, CHAR_PUNCT, CHAR_RAWDEL,
+    CHAR_RAWDEL, CHAR_UNDER,
+    // 96  `         97  a         98  b         99  c
+    // 100  d       101  e        102  f        103  g
+    CHAR_PUNCT, CHAR_XLOWER, CHAR_XLOWER, CHAR_XLOWER, CHAR_XLOWER, CHAR_XLOWER,
+    CHAR_XLOWER, CHAR_LOWER,
+    // 104  h       105  i        106  j        107  k
+    // 108  l       109  m        110  n        111  o
+    CHAR_LOWER, CHAR_LOWER, CHAR_LOWER, CHAR_LOWER, CHAR_LOWER, CHAR_LOWER,
+    CHAR_LOWER, CHAR_LOWER,
+    // 112  p       113  q        114  r        115  s
+    // 116  t       117  u        118  v        119  w
+    CHAR_LOWER, CHAR_LOWER, CHAR_LOWER, CHAR_LOWER, CHAR_LOWER, CHAR_LOWER,
+    CHAR_LOWER, CHAR_LOWER,
+    // 120  x       121  y        122  z        123  {
+    // 124  |       125  }        126  ~        127 DEL
+    CHAR_LOWER, CHAR_LOWER, CHAR_LOWER, CHAR_RAWDEL, CHAR_RAWDEL, CHAR_RAWDEL,
+    CHAR_RAWDEL, 0};
Index: clang/lib/Basic/CodeGenOptions.cpp
===================================================================
--- clang/lib/Basic/CodeGenOptions.cpp
+++ clang/lib/Basic/CodeGenOptions.cpp
@@ -20,4 +20,4 @@
   memcpy(CoverageVersion, "408*", 4);
 }
 
-}  // end namespace clang
+} // end namespace clang
Index: clang/lib/Basic/Cuda.cpp
===================================================================
--- clang/lib/Basic/Cuda.cpp
+++ clang/lib/Basic/Cuda.cpp
@@ -8,7 +8,7 @@
 
 namespace clang {
 
-const char *CudaVersionToString(CudaVersion V) {
+char const *CudaVersionToString(CudaVersion V) {
   switch (V) {
   case CudaVersion::UNKNOWN:
     return "unknown";
@@ -46,7 +46,7 @@
   llvm_unreachable("invalid enum");
 }
 
-CudaVersion CudaStringToVersion(const llvm::Twine &S) {
+CudaVersion CudaStringToVersion(llvm::Twine const &S) {
   return llvm::StringSwitch<CudaVersion>(S.str())
       .Case("7.0", CudaVersion::CUDA_70)
       .Case("7.5", CudaVersion::CUDA_75)
@@ -68,8 +68,8 @@
 namespace {
 struct CudaArchToStringMap {
   CudaArch arch;
-  const char *arch_name;
-  const char *virtual_arch_name;
+  char const *arch_name;
+  char const *virtual_arch_name;
 };
 } // namespace
 
@@ -126,19 +126,19 @@
 #undef SM2
 #undef GFX
 
-const char *CudaArchToString(CudaArch A) {
+char const *CudaArchToString(CudaArch A) {
   auto result = std::find_if(
       std::begin(arch_names), std::end(arch_names),
-      [A](const CudaArchToStringMap &map) { return A == map.arch; });
+      [A](CudaArchToStringMap const &map) { return A == map.arch; });
   if (result == std::end(arch_names))
     return "unknown";
   return result->arch_name;
 }
 
-const char *CudaArchToVirtualArchString(CudaArch A) {
+char const *CudaArchToVirtualArchString(CudaArch A) {
   auto result = std::find_if(
       std::begin(arch_names), std::end(arch_names),
-      [A](const CudaArchToStringMap &map) { return A == map.arch; });
+      [A](CudaArchToStringMap const &map) { return A == map.arch; });
   if (result == std::end(arch_names))
     return "unknown";
   return result->virtual_arch_name;
@@ -147,7 +147,7 @@
 CudaArch StringToCudaArch(llvm::StringRef S) {
   auto result = std::find_if(
       std::begin(arch_names), std::end(arch_names),
-      [S](const CudaArchToStringMap &map) { return S == map.arch_name; });
+      [S](CudaArchToStringMap const &map) { return S == map.arch_name; });
   if (result == std::end(arch_names))
     return CudaArch::UNKNOWN;
   return result->arch;
@@ -210,9 +210,8 @@
 }
 
 CudaVersion ToCudaVersion(llvm::VersionTuple Version) {
-  int IVer =
-      Version.getMajor() * 10 + Version.getMinor().getValueOr(0);
-  switch(IVer) {
+  int IVer = Version.getMajor() * 10 + Version.getMinor().getValueOr(0);
+  switch (IVer) {
   case 70:
     return CudaVersion::CUDA_70;
   case 75:
@@ -246,7 +245,7 @@
   }
 }
 
-bool CudaFeatureEnabled(llvm::VersionTuple  Version, CudaFeature Feature) {
+bool CudaFeatureEnabled(llvm::VersionTuple Version, CudaFeature Feature) {
   return CudaFeatureEnabled(ToCudaVersion(Version), Feature);
 }
 
Index: clang/lib/Basic/DarwinSDKInfo.cpp
===================================================================
--- clang/lib/Basic/DarwinSDKInfo.cpp
+++ clang/lib/Basic/DarwinSDKInfo.cpp
@@ -15,7 +15,7 @@
 using namespace clang;
 
 Optional<VersionTuple> DarwinSDKInfo::RelatedTargetVersionMapping::map(
-    const VersionTuple &Key, const VersionTuple &MinimumValue,
+    VersionTuple const &Key, VersionTuple const &MinimumValue,
     Optional<VersionTuple> MaximumValue) const {
   if (Key < MinimumKeyVersion)
     return MinimumValue;
@@ -35,12 +35,12 @@
 
 Optional<DarwinSDKInfo::RelatedTargetVersionMapping>
 DarwinSDKInfo::RelatedTargetVersionMapping::parseJSON(
-    const llvm::json::Object &Obj, VersionTuple MaximumDeploymentTarget) {
+    llvm::json::Object const &Obj, VersionTuple MaximumDeploymentTarget) {
   VersionTuple Min = VersionTuple(std::numeric_limits<unsigned>::max());
   VersionTuple Max = VersionTuple(0);
   VersionTuple MinValue = Min;
   llvm::DenseMap<VersionTuple, VersionTuple> Mapping;
-  for (const auto &KV : Obj) {
+  for (auto const &KV : Obj) {
     if (auto Val = KV.getSecond().getAsString()) {
       llvm::VersionTuple KeyVersion;
       llvm::VersionTuple ValueVersion;
@@ -61,7 +61,7 @@
       Min, Max, MinValue, MaximumDeploymentTarget, std::move(Mapping));
 }
 
-static Optional<VersionTuple> getVersionKey(const llvm::json::Object &Obj,
+static Optional<VersionTuple> getVersionKey(llvm::json::Object const &Obj,
                                             StringRef Key) {
   auto Value = Obj.getString(Key);
   if (!Value)
@@ -73,7 +73,7 @@
 }
 
 Optional<DarwinSDKInfo>
-DarwinSDKInfo::parseDarwinSDKSettingsJSON(const llvm::json::Object *Obj) {
+DarwinSDKInfo::parseDarwinSDKSettingsJSON(llvm::json::Object const *Obj) {
   auto Version = getVersionKey(*Obj, "Version");
   if (!Version)
     return None;
@@ -83,8 +83,8 @@
     return None;
   llvm::DenseMap<OSEnvPair::StorageType, Optional<RelatedTargetVersionMapping>>
       VersionMappings;
-  if (const auto *VM = Obj->getObject("VersionMap")) {
-    if (const auto *Mapping = VM->getObject("macOS_iOSMac")) {
+  if (auto const *VM = Obj->getObject("VersionMap")) {
+    if (auto const *Mapping = VM->getObject("macOS_iOSMac")) {
       auto VersionMap = RelatedTargetVersionMapping::parseJSON(
           *Mapping, *MaximumDeploymentVersion);
       if (!VersionMap)
@@ -92,7 +92,7 @@
       VersionMappings[OSEnvPair::macOStoMacCatalystPair().Value] =
           std::move(VersionMap);
     }
-    if (const auto *Mapping = VM->getObject("iOSMac_macOS")) {
+    if (auto const *Mapping = VM->getObject("iOSMac_macOS")) {
       auto VersionMap = RelatedTargetVersionMapping::parseJSON(
           *Mapping, *MaximumDeploymentVersion);
       if (!VersionMap)
@@ -122,7 +122,7 @@
   if (!Result)
     return Result.takeError();
 
-  if (const auto *Obj = Result->getAsObject()) {
+  if (auto const *Obj = Result->getAsObject()) {
     if (auto SDKInfo = DarwinSDKInfo::parseDarwinSDKSettingsJSON(Obj))
       return std::move(SDKInfo);
   }
Index: clang/lib/Basic/Diagnostic.cpp
===================================================================
--- clang/lib/Basic/Diagnostic.cpp
+++ clang/lib/Basic/Diagnostic.cpp
@@ -40,7 +40,7 @@
 
 using namespace clang;
 
-const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
+StreamingDiagnostic const &clang::operator<<(StreamingDiagnostic const &DB,
                                              DiagNullabilityKind nullability) {
   StringRef string;
   switch (nullability.first) {
@@ -67,18 +67,18 @@
   return DB;
 }
 
-const StreamingDiagnostic &clang::operator<<(const StreamingDiagnostic &DB,
+StreamingDiagnostic const &clang::operator<<(StreamingDiagnostic const &DB,
                                              llvm::Error &&E) {
   DB.AddString(toString(std::move(E)));
   return DB;
 }
 
-static void DummyArgToStringFn(DiagnosticsEngine::ArgumentKind AK, intptr_t QT,
-                            StringRef Modifier, StringRef Argument,
-                            ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
-                            SmallVectorImpl<char> &Output,
-                            void *Cookie,
-                            ArrayRef<intptr_t> QualTypeVals) {
+static void
+DummyArgToStringFn(DiagnosticsEngine::ArgumentKind AK, intptr_t QT,
+                   StringRef Modifier, StringRef Argument,
+                   ArrayRef<DiagnosticsEngine::ArgumentValue> PrevArgs,
+                   SmallVectorImpl<char> &Output, void *Cookie,
+                   ArrayRef<intptr_t> QualTypeVals) {
   StringRef Str = "<can't format argument>";
   Output.append(Str.begin(), Str.end());
 }
@@ -100,9 +100,7 @@
   setClient(nullptr);
 }
 
-void DiagnosticsEngine::dump() const {
-  DiagStatesByLoc.dump(*SourceMgr);
-}
+void DiagnosticsEngine::dump() const { DiagStatesByLoc.dump(*SourceMgr); }
 
 void DiagnosticsEngine::dump(StringRef DiagName) const {
   DiagStatesByLoc.dump(*SourceMgr, DiagName);
@@ -212,14 +210,14 @@
     return FirstDiagState;
 
   std::pair<FileID, unsigned> Decomp = SrcMgr.getDecomposedLoc(Loc);
-  const File *F = getFile(SrcMgr, Decomp.first);
+  File const *F = getFile(SrcMgr, Decomp.first);
   return F->lookup(Decomp.second);
 }
 
 DiagnosticsEngine::DiagState *
 DiagnosticsEngine::DiagStateMap::File::lookup(unsigned Offset) const {
   auto OnePastIt =
-      llvm::partition_point(StateTransitions, [=](const DiagStatePoint &P) {
+      llvm::partition_point(StateTransitions, [=](DiagStatePoint const &P) {
         return P.Offset <= Offset;
       });
   assert(OnePastIt != StateTransitions.begin() && "missing initial state");
@@ -267,7 +265,8 @@
 
     bool PrintedOuterHeading = false;
     auto PrintOuterHeading = [&] {
-      if (PrintedOuterHeading) return;
+      if (PrintedOuterHeading)
+        return;
       PrintedOuterHeading = true;
 
       llvm::errs() << "File " << &File << " <FileID " << ID.getHashValue()
@@ -280,8 +279,8 @@
         llvm::errs() << " parent " << File.Parent << " <FileID "
                      << Decomp.first.getHashValue() << "> ";
         SrcMgr.getLocForStartOfFile(Decomp.first)
-              .getLocWithOffset(Decomp.second)
-              .print(llvm::errs(), SrcMgr);
+            .getLocWithOffset(Decomp.second)
+            .print(llvm::errs(), SrcMgr);
       }
       if (File.HasLocalTransitions)
         llvm::errs() << " has_local_transitions";
@@ -294,14 +293,15 @@
     for (DiagStatePoint &Transition : File.StateTransitions) {
       bool PrintedInnerHeading = false;
       auto PrintInnerHeading = [&] {
-        if (PrintedInnerHeading) return;
+        if (PrintedInnerHeading)
+          return;
         PrintedInnerHeading = true;
 
         PrintOuterHeading();
         llvm::errs() << "  ";
         SrcMgr.getLocForStartOfFile(ID)
-              .getLocWithOffset(Transition.Offset)
-              .print(llvm::errs(), SrcMgr);
+            .getLocWithOffset(Transition.Offset)
+            .print(llvm::errs(), SrcMgr);
         llvm::errs() << ": state " << Transition.State << ":\n";
       };
 
@@ -323,11 +323,21 @@
         llvm::errs() << ": ";
 
         switch (Mapping.second.getSeverity()) {
-        case diag::Severity::Ignored: llvm::errs() << "ignored"; break;
-        case diag::Severity::Remark: llvm::errs() << "remark"; break;
-        case diag::Severity::Warning: llvm::errs() << "warning"; break;
-        case diag::Severity::Error: llvm::errs() << "error"; break;
-        case diag::Severity::Fatal: llvm::errs() << "fatal"; break;
+        case diag::Severity::Ignored:
+          llvm::errs() << "ignored";
+          break;
+        case diag::Severity::Remark:
+          llvm::errs() << "remark";
+          break;
+        case diag::Severity::Warning:
+          llvm::errs() << "warning";
+          break;
+        case diag::Severity::Error:
+          llvm::errs() << "error";
+          break;
+        case diag::Severity::Fatal:
+          llvm::errs() << "fatal";
+          break;
         }
 
         if (!Mapping.second.isUser())
@@ -354,8 +364,7 @@
 
 void DiagnosticsEngine::setSeverity(diag::kind Diag, diag::Severity Map,
                                     SourceLocation L) {
-  assert(Diag < diag::DIAG_UPPER_LIMIT &&
-         "Can only map builtin diagnostics");
+  assert(Diag < diag::DIAG_UPPER_LIMIT && "Can only map builtin diagnostics");
   assert((Diags->isBuiltinWarningOrExtension(Diag) ||
           (Map == diag::Severity::Fatal || Map == diag::Severity::Error)) &&
          "Cannot map errors into warnings!");
@@ -482,7 +491,7 @@
       setSeverity(Diag, Map, Loc);
 }
 
-void DiagnosticsEngine::Report(const StoredDiagnostic &storedDiag) {
+void DiagnosticsEngine::Report(StoredDiagnostic const &storedDiag) {
   assert(CurDiagID == std::numeric_limits<unsigned>::max() &&
          "Multiple diagnostics in flight at once!");
 
@@ -518,8 +527,8 @@
     Diagnostic Info(this);
 
     // Figure out the diagnostic level of this message.
-    DiagnosticIDs::Level DiagLevel
-      = Diags->getDiagnosticLevel(Info.getID(), Info.getLocation(), *this);
+    DiagnosticIDs::Level DiagLevel =
+        Diags->getDiagnosticLevel(Info.getID(), Info.getLocation(), *this);
 
     Emitted = (DiagLevel != DiagnosticIDs::Ignored);
     if (Emitted) {
@@ -545,7 +554,7 @@
 DiagnosticConsumer::~DiagnosticConsumer() = default;
 
 void DiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
-                                        const Diagnostic &Info) {
+                                          Diagnostic const &Info) {
   if (!IncludeInDiagnosticCounts())
     return;
 
@@ -557,30 +566,35 @@
 
 /// ModifierIs - Return true if the specified modifier matches specified string.
 template <std::size_t StrLen>
-static bool ModifierIs(const char *Modifier, unsigned ModifierLen,
-                       const char (&Str)[StrLen]) {
-  return StrLen-1 == ModifierLen && memcmp(Modifier, Str, StrLen-1) == 0;
+static bool ModifierIs(char const *Modifier, unsigned ModifierLen,
+                       char const (&Str)[StrLen]) {
+  return StrLen - 1 == ModifierLen && memcmp(Modifier, Str, StrLen - 1) == 0;
 }
 
 /// ScanForward - Scans forward, looking for the given character, skipping
 /// nested clauses and escaped characters.
-static const char *ScanFormat(const char *I, const char *E, char Target) {
+static char const *ScanFormat(char const *I, char const *E, char Target) {
   unsigned Depth = 0;
 
-  for ( ; I != E; ++I) {
-    if (Depth == 0 && *I == Target) return I;
-    if (Depth != 0 && *I == '}') Depth--;
+  for (; I != E; ++I) {
+    if (Depth == 0 && *I == Target)
+      return I;
+    if (Depth != 0 && *I == '}')
+      Depth--;
 
     if (*I == '%') {
       I++;
-      if (I == E) break;
+      if (I == E)
+        break;
 
       // Escaped characters get implicitly skipped here.
 
       // Format specifier.
       if (!isDigit(*I) && !isPunctuation(*I)) {
-        for (I++; I != E && !isDigit(*I) && *I != '{'; I++) ;
-        if (I == E) break;
+        for (I++; I != E && !isDigit(*I) && *I != '{'; I++)
+          ;
+        if (I == E)
+          break;
         if (*I == '{')
           Depth++;
       }
@@ -594,22 +608,23 @@
 /// "%2" has a value from 0-2.  If the value is 0, the diagnostic prints 'foo'.
 /// If the value is 1, it prints 'bar'.  If it has the value 2, it prints 'baz'.
 /// This is very useful for certain classes of variant diagnostics.
-static void HandleSelectModifier(const Diagnostic &DInfo, unsigned ValNo,
-                                 const char *Argument, unsigned ArgumentLen,
+static void HandleSelectModifier(Diagnostic const &DInfo, unsigned ValNo,
+                                 char const *Argument, unsigned ArgumentLen,
                                  SmallVectorImpl<char> &OutStr) {
-  const char *ArgumentEnd = Argument+ArgumentLen;
+  char const *ArgumentEnd = Argument + ArgumentLen;
 
   // Skip over 'ValNo' |'s.
   while (ValNo) {
-    const char *NextVal = ScanFormat(Argument, ArgumentEnd, '|');
-    assert(NextVal != ArgumentEnd && "Value for integer select modifier was"
+    char const *NextVal = ScanFormat(Argument, ArgumentEnd, '|');
+    assert(NextVal != ArgumentEnd &&
+           "Value for integer select modifier was"
            " larger than the number of options in the diagnostic string!");
-    Argument = NextVal+1;  // Skip this string.
+    Argument = NextVal + 1; // Skip this string.
     --ValNo;
   }
 
   // Get the end of the value.  This is either the } or the |.
-  const char *EndPtr = ScanFormat(Argument, ArgumentEnd, '|');
+  char const *EndPtr = ScanFormat(Argument, ArgumentEnd, '|');
 
   // Recursively format the result of the select clause into the output string.
   DInfo.FormatDiagnostic(Argument, EndPtr, OutStr);
@@ -640,7 +655,7 @@
 }
 
 /// PluralNumber - Parse an unsigned integer and advance Start.
-static unsigned PluralNumber(const char *&Start, const char *End) {
+static unsigned PluralNumber(char const *&Start, char const *End) {
   // Programming 101: Parse a decimal number :-)
   unsigned Val = 0;
   while (Start != End && *Start >= '0' && *Start <= '9') {
@@ -652,7 +667,7 @@
 }
 
 /// TestPluralRange - Test if Val is in the parsed range. Modifies Start.
-static bool TestPluralRange(unsigned Val, const char *&Start, const char *End) {
+static bool TestPluralRange(unsigned Val, char const *&Start, char const *End) {
   if (*Start != '[') {
     unsigned Ref = PluralNumber(Start, End);
     return Ref == Val;
@@ -669,7 +684,7 @@
 }
 
 /// EvalPluralExpr - Actual expression evaluator for HandlePluralModifier.
-static bool EvalPluralExpr(unsigned ValNo, const char *Start, const char *End) {
+static bool EvalPluralExpr(unsigned ValNo, char const *Start, char const *End) {
   // Empty condition?
   if (*Start == ':')
     return true;
@@ -735,13 +750,13 @@
 /// {1:form0|[2,4]:form1|:form2}
 /// Polish (requires repeated form):
 /// {1:form0|%100=[10,20]:form2|%10=[2,4]:form1|:form2}
-static void HandlePluralModifier(const Diagnostic &DInfo, unsigned ValNo,
-                                 const char *Argument, unsigned ArgumentLen,
+static void HandlePluralModifier(Diagnostic const &DInfo, unsigned ValNo,
+                                 char const *Argument, unsigned ArgumentLen,
                                  SmallVectorImpl<char> &OutStr) {
-  const char *ArgumentEnd = Argument + ArgumentLen;
+  char const *ArgumentEnd = Argument + ArgumentLen;
   while (true) {
     assert(Argument < ArgumentEnd && "Plural expression didn't match.");
-    const char *ExprEnd = Argument;
+    char const *ExprEnd = Argument;
     while (*ExprEnd != ':') {
       assert(ExprEnd != ArgumentEnd && "Plural missing expression end");
       ++ExprEnd;
@@ -762,7 +777,7 @@
 /// Returns the friendly description for a token kind that will appear
 /// without quotes in diagnostic messages. These strings may be translatable in
 /// future.
-static const char *getTokenDescForDiagnostic(tok::TokenKind Kind) {
+static char const *getTokenDescForDiagnostic(tok::TokenKind Kind) {
   switch (Kind) {
   case tok::identifier:
     return "identifier";
@@ -774,29 +789,26 @@
 /// FormatDiagnostic - Format this diagnostic into a string, substituting the
 /// formal arguments into the %0 slots.  The result is appended onto the Str
 /// array.
-void Diagnostic::
-FormatDiagnostic(SmallVectorImpl<char> &OutStr) const {
+void Diagnostic::FormatDiagnostic(SmallVectorImpl<char> &OutStr) const {
   if (!StoredDiagMessage.empty()) {
     OutStr.append(StoredDiagMessage.begin(), StoredDiagMessage.end());
     return;
   }
 
-  StringRef Diag =
-    getDiags()->getDiagnosticIDs()->getDescription(getID());
+  StringRef Diag = getDiags()->getDiagnosticIDs()->getDescription(getID());
 
   FormatDiagnostic(Diag.begin(), Diag.end(), OutStr);
 }
 
-void Diagnostic::
-FormatDiagnostic(const char *DiagStr, const char *DiagEnd,
-                 SmallVectorImpl<char> &OutStr) const {
+void Diagnostic::FormatDiagnostic(char const *DiagStr, char const *DiagEnd,
+                                  SmallVectorImpl<char> &OutStr) const {
   // When the diagnostic string is only "%0", the entire string is being given
   // by an outside source.  Remove unprintable characters from this string
   // and skip all the other string processing.
   if (DiagEnd - DiagStr == 2 &&
       StringRef(DiagStr, DiagEnd - DiagStr).equals("%0") &&
       getArgKind(0) == DiagnosticsEngine::ak_std_string) {
-    const std::string &S = getArgStdStr(0);
+    std::string const &S = getArgStdStr(0);
     for (char c : S) {
       if (llvm::sys::locale::isPrint(c) || c == '\t') {
         OutStr.push_back(c);
@@ -823,12 +835,12 @@
   while (DiagStr != DiagEnd) {
     if (DiagStr[0] != '%') {
       // Append non-%0 substrings to Str if we have one.
-      const char *StrEnd = std::find(DiagStr, DiagEnd, '%');
+      char const *StrEnd = std::find(DiagStr, DiagEnd, '%');
       OutStr.append(DiagStr, StrEnd);
       DiagStr = StrEnd;
       continue;
     } else if (isPunctuation(DiagStr[1])) {
-      OutStr.push_back(DiagStr[1]);  // %% -> %.
+      OutStr.push_back(DiagStr[1]); // %% -> %.
       DiagStr += 2;
       continue;
     }
@@ -841,16 +853,15 @@
     // The digit is a number from 0-9 indicating which argument this comes from.
     // The modifier is a string of digits from the set [-a-z]+, arguments is a
     // brace enclosed string.
-    const char *Modifier = nullptr, *Argument = nullptr;
+    char const *Modifier = nullptr, *Argument = nullptr;
     unsigned ModifierLen = 0, ArgumentLen = 0;
 
     // Check to see if we have a modifier.  If so eat it.
     if (!isDigit(DiagStr[0])) {
       Modifier = DiagStr;
-      while (DiagStr[0] == '-' ||
-             (DiagStr[0] >= 'a' && DiagStr[0] <= 'z'))
+      while (DiagStr[0] == '-' || (DiagStr[0] >= 'a' && DiagStr[0] <= 'z'))
         ++DiagStr;
-      ModifierLen = DiagStr-Modifier;
+      ModifierLen = DiagStr - Modifier;
 
       // If we have an argument, get it next.
       if (DiagStr[0] == '{') {
@@ -859,8 +870,8 @@
 
         DiagStr = ScanFormat(DiagStr, DiagEnd, '}');
         assert(DiagStr != DiagEnd && "Mismatched {}'s in diagnostic string!");
-        ArgumentLen = DiagStr-Argument;
-        ++DiagStr;  // Skip }.
+        ArgumentLen = DiagStr - Argument;
+        ++DiagStr; // Skip }.
       }
     }
 
@@ -874,7 +885,7 @@
     if (ModifierIs(Modifier, ModifierLen, "diff")) {
       assert(*DiagStr == ',' && isDigit(*(DiagStr + 1)) &&
              "Invalid format for diff modifier");
-      ++DiagStr;  // Comma.
+      ++DiagStr; // Comma.
       ArgNo2 = *DiagStr++ - '0';
       DiagnosticsEngine::ArgumentKind Kind2 = getArgKind(ArgNo2);
       if (Kind == DiagnosticsEngine::ak_qualtype &&
@@ -886,14 +897,14 @@
         //   "%diff{compare $ to $|other text}1,2"
         // treat it as:
         //   "compare %1 to %2"
-        const char *ArgumentEnd = Argument + ArgumentLen;
-        const char *Pipe = ScanFormat(Argument, ArgumentEnd, '|');
+        char const *ArgumentEnd = Argument + ArgumentLen;
+        char const *Pipe = ScanFormat(Argument, ArgumentEnd, '|');
         assert(ScanFormat(Pipe + 1, ArgumentEnd, '|') == ArgumentEnd &&
                "Found too many '|'s in a %diff modifier!");
-        const char *FirstDollar = ScanFormat(Argument, Pipe, '$');
-        const char *SecondDollar = ScanFormat(FirstDollar + 1, Pipe, '$');
-        const char ArgStr1[] = { '%', static_cast<char>('0' + ArgNo) };
-        const char ArgStr2[] = { '%', static_cast<char>('0' + ArgNo2) };
+        char const *FirstDollar = ScanFormat(Argument, Pipe, '$');
+        char const *SecondDollar = ScanFormat(FirstDollar + 1, Pipe, '$');
+        char const ArgStr1[] = {'%', static_cast<char>('0' + ArgNo)};
+        char const ArgStr2[] = {'%', static_cast<char>('0' + ArgNo2)};
         FormatDiagnostic(Argument, FirstDollar, OutStr);
         FormatDiagnostic(ArgStr1, ArgStr1 + 2, OutStr);
         FormatDiagnostic(FirstDollar + 1, SecondDollar, OutStr);
@@ -906,13 +917,13 @@
     switch (Kind) {
     // ---- STRINGS ----
     case DiagnosticsEngine::ak_std_string: {
-      const std::string &S = getArgStdStr(ArgNo);
+      std::string const &S = getArgStdStr(ArgNo);
       assert(ModifierLen == 0 && "No modifiers for strings yet");
       OutStr.append(S.begin(), S.end());
       break;
     }
     case DiagnosticsEngine::ak_c_string: {
-      const char *S = getArgCStr(ArgNo);
+      char const *S = getArgCStr(ArgNo);
       assert(ModifierLen == 0 && "No modifiers for strings yet");
 
       // Don't crash if get passed a null pointer by accident.
@@ -966,16 +977,16 @@
       assert(ModifierLen == 0 && "No modifiers for token kinds yet");
 
       llvm::raw_svector_ostream Out(OutStr);
-      if (const char *S = tok::getPunctuatorSpelling(Kind))
+      if (char const *S = tok::getPunctuatorSpelling(Kind))
         // Quoted token spelling for punctuators.
         Out << '\'' << S << '\'';
-      else if (const char *S = tok::getKeywordSpelling(Kind))
+      else if (char const *S = tok::getKeywordSpelling(Kind))
         // Unquoted token spelling for keywords.
         Out << S;
-      else if (const char *S = getTokenDescForDiagnostic(Kind))
+      else if (char const *S = getTokenDescForDiagnostic(Kind))
         // Unquoted translatable token name.
         Out << S;
-      else if (const char *S = tok::getTokenName(Kind))
+      else if (char const *S = tok::getTokenName(Kind))
         // Debug name, shouldn't appear in user-facing diagnostics.
         Out << '<' << S << '>';
       else
@@ -984,12 +995,12 @@
     }
     // ---- NAMES and TYPES ----
     case DiagnosticsEngine::ak_identifierinfo: {
-      const IdentifierInfo *II = getArgIdentifier(ArgNo);
+      IdentifierInfo const *II = getArgIdentifier(ArgNo);
       assert(ModifierLen == 0 && "No modifiers for strings yet");
 
       // Don't crash if get passed a null pointer by accident.
       if (!II) {
-        const char *S = "(null)";
+        char const *S = "(null)";
         OutStr.append(S, S + strlen(S));
         continue;
       }
@@ -1008,8 +1019,7 @@
       getDiags()->ConvertArgToString(Kind, getRawArg(ArgNo),
                                      StringRef(Modifier, ModifierLen),
                                      StringRef(Argument, ArgumentLen),
-                                     FormattedArgs,
-                                     OutStr, QualTypeVals);
+                                     FormattedArgs, OutStr, QualTypeVals);
       break;
     case DiagnosticsEngine::ak_qualtype_pair: {
       // Create a struct with all the info needed for printing.
@@ -1021,8 +1031,8 @@
       TDT.TemplateDiffUsed = false;
       intptr_t val = reinterpret_cast<intptr_t>(&TDT);
 
-      const char *ArgumentEnd = Argument + ArgumentLen;
-      const char *Pipe = ScanFormat(Argument, ArgumentEnd, '|');
+      char const *ArgumentEnd = Argument + ArgumentLen;
+      char const *Pipe = ScanFormat(Argument, ArgumentEnd, '|');
 
       // Print the tree.  If this diagnostic already has a tree, skip the
       // second tree.
@@ -1032,8 +1042,7 @@
         getDiags()->ConvertArgToString(Kind, val,
                                        StringRef(Modifier, ModifierLen),
                                        StringRef(Argument, ArgumentLen),
-                                       FormattedArgs,
-                                       Tree, QualTypeVals);
+                                       FormattedArgs, Tree, QualTypeVals);
         // If there is no tree information, fall back to regular printing.
         if (!Tree.empty()) {
           FormatDiagnostic(Pipe + 1, ArgumentEnd, OutStr);
@@ -1043,8 +1052,8 @@
 
       // Non-tree printing, also the fall-back when tree printing fails.
       // The fall-back is triggered when the types compared are not templates.
-      const char *FirstDollar = ScanFormat(Argument, ArgumentEnd, '$');
-      const char *SecondDollar = ScanFormat(FirstDollar + 1, ArgumentEnd, '$');
+      char const *FirstDollar = ScanFormat(Argument, ArgumentEnd, '$');
+      char const *SecondDollar = ScanFormat(FirstDollar + 1, ArgumentEnd, '$');
 
       // Append before text
       FormatDiagnostic(Argument, FirstDollar, OutStr);
@@ -1055,11 +1064,10 @@
       getDiags()->ConvertArgToString(Kind, val,
                                      StringRef(Modifier, ModifierLen),
                                      StringRef(Argument, ArgumentLen),
-                                     FormattedArgs,
-                                     OutStr, QualTypeVals);
+                                     FormattedArgs, OutStr, QualTypeVals);
       if (!TDT.TemplateDiffUsed)
-        FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_qualtype,
-                                               TDT.FromType));
+        FormattedArgs.push_back(
+            std::make_pair(DiagnosticsEngine::ak_qualtype, TDT.FromType));
 
       // Append middle text
       FormatDiagnostic(FirstDollar + 1, SecondDollar, OutStr);
@@ -1069,11 +1077,10 @@
       getDiags()->ConvertArgToString(Kind, val,
                                      StringRef(Modifier, ModifierLen),
                                      StringRef(Argument, ArgumentLen),
-                                     FormattedArgs,
-                                     OutStr, QualTypeVals);
+                                     FormattedArgs, OutStr, QualTypeVals);
       if (!TDT.TemplateDiffUsed)
-        FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_qualtype,
-                                               TDT.ToType));
+        FormattedArgs.push_back(
+            std::make_pair(DiagnosticsEngine::ak_qualtype, TDT.ToType));
 
       // Append end text
       FormatDiagnostic(SecondDollar + 1, Pipe, OutStr);
@@ -1089,8 +1096,9 @@
     else if (Kind != DiagnosticsEngine::ak_std_string)
       FormattedArgs.push_back(std::make_pair(Kind, getRawArg(ArgNo)));
     else
-      FormattedArgs.push_back(std::make_pair(DiagnosticsEngine::ak_c_string,
-                                        (intptr_t)getArgStdStr(ArgNo).c_str()));
+      FormattedArgs.push_back(
+          std::make_pair(DiagnosticsEngine::ak_c_string,
+                         (intptr_t)getArgStdStr(ArgNo).c_str()));
   }
 
   // Append the type tree to the end of the diagnostics.
@@ -1102,10 +1110,11 @@
     : ID(ID), Level(Level), Message(Message) {}
 
 StoredDiagnostic::StoredDiagnostic(DiagnosticsEngine::Level Level,
-                                   const Diagnostic &Info)
+                                   Diagnostic const &Info)
     : ID(Info.getID()), Level(Level) {
-  assert((Info.getLocation().isInvalid() || Info.hasSourceManager()) &&
-       "Valid source location without setting a source manager for diagnostic");
+  assert(
+      (Info.getLocation().isInvalid() || Info.hasSourceManager()) &&
+      "Valid source location without setting a source manager for diagnostic");
   if (Info.getLocation().isValid())
     Loc = FullSourceLoc(Info.getLocation(), Info.getSourceManager());
   SmallString<64> Message;
@@ -1120,9 +1129,8 @@
                                    ArrayRef<CharSourceRange> Ranges,
                                    ArrayRef<FixItHint> FixIts)
     : ID(ID), Level(Level), Loc(Loc), Message(Message),
-      Ranges(Ranges.begin(), Ranges.end()), FixIts(FixIts.begin(), FixIts.end())
-{
-}
+      Ranges(Ranges.begin(), Ranges.end()),
+      FixIts(FixIts.begin(), FixIts.end()) {}
 
 /// IncludeInDiagnosticCounts - This method (whose default implementation
 ///  returns true) indicates whether the diagnostics handled by this
@@ -1135,8 +1143,7 @@
 ForwardingDiagnosticConsumer::~ForwardingDiagnosticConsumer() = default;
 
 void ForwardingDiagnosticConsumer::HandleDiagnostic(
-       DiagnosticsEngine::Level DiagLevel,
-       const Diagnostic &Info) {
+    DiagnosticsEngine::Level DiagLevel, Diagnostic const &Info) {
   Target.HandleDiagnostic(DiagLevel, Info);
 }
 
Index: clang/lib/Basic/DiagnosticIDs.cpp
===================================================================
--- clang/lib/Basic/DiagnosticIDs.cpp
+++ clang/lib/Basic/DiagnosticIDs.cpp
@@ -69,7 +69,7 @@
 #include "clang/Basic/DiagnosticSemaKinds.inc"
 #include "clang/Basic/DiagnosticAnalysisKinds.inc"
 #include "clang/Basic/DiagnosticRefactoringKinds.inc"
-  // clang-format on
+// clang-format on
 #undef DIAG
 };
 
@@ -94,17 +94,17 @@
 #include "clang/Basic/DiagnosticSemaKinds.inc"
 #include "clang/Basic/DiagnosticAnalysisKinds.inc"
 #include "clang/Basic/DiagnosticRefactoringKinds.inc"
-  // clang-format on
+// clang-format on
 #undef DIAG
 };
 
 // Diagnostic classes.
 enum {
-  CLASS_NOTE       = 0x01,
-  CLASS_REMARK     = 0x02,
-  CLASS_WARNING    = 0x03,
-  CLASS_EXTENSION  = 0x04,
-  CLASS_ERROR      = 0x05
+  CLASS_NOTE = 0x01,
+  CLASS_REMARK = 0x02,
+  CLASS_WARNING = 0x03,
+  CLASS_EXTENSION = 0x04,
+  CLASS_ERROR = 0x05
 };
 
 struct StaticDiagInfoRec {
@@ -121,14 +121,13 @@
 
   uint16_t DescriptionLen;
 
-  unsigned getOptionGroupIndex() const {
-    return OptionGroupIndex;
-  }
+  unsigned getOptionGroupIndex() const { return OptionGroupIndex; }
 
   StringRef getDescription() const {
     size_t MyIndex = this - &StaticDiagInfo[0];
     uint32_t StringOffset = StaticDiagInfoDescriptionOffsets[MyIndex];
-    const char* Table = reinterpret_cast<const char*>(&StaticDiagInfoDescriptions);
+    char const *Table =
+        reinterpret_cast<char const *>(&StaticDiagInfoDescriptions);
     return StringRef(&Table[StringOffset], DescriptionLen);
   }
 
@@ -137,7 +136,7 @@
                                  : diag::Flavor::WarningOrError;
   }
 
-  bool operator<(const StaticDiagInfoRec &RHS) const {
+  bool operator<(StaticDiagInfoRec const &RHS) const {
     return DiagID < RHS.DiagID;
   }
 };
@@ -200,11 +199,11 @@
 
 } // namespace
 
-static const unsigned StaticDiagInfoSize = llvm::array_lengthof(StaticDiagInfo);
+static unsigned const StaticDiagInfoSize = llvm::array_lengthof(StaticDiagInfo);
 
 /// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID,
 /// or null if the ID is invalid.
-static const StaticDiagInfoRec *GetDiagInfo(unsigned DiagID) {
+static StaticDiagInfoRec const *GetDiagInfo(unsigned DiagID) {
   // Out of bounds diag. Can't be in the table.
   using namespace diag;
   if (DiagID >= DIAG_UPPER_LIMIT || DiagID <= DIAG_START_COMMON)
@@ -220,22 +219,22 @@
   // memory at all.
   unsigned Offset = 0;
   unsigned ID = DiagID - DIAG_START_COMMON - 1;
-#define CATEGORY(NAME, PREV) \
-  if (DiagID > DIAG_START_##NAME) { \
-    Offset += NUM_BUILTIN_##PREV##_DIAGNOSTICS - DIAG_START_##PREV - 1; \
-    ID -= DIAG_START_##NAME - DIAG_START_##PREV; \
+#define CATEGORY(NAME, PREV)                                                   \
+  if (DiagID > DIAG_START_##NAME) {                                            \
+    Offset += NUM_BUILTIN_##PREV##_DIAGNOSTICS - DIAG_START_##PREV - 1;        \
+    ID -= DIAG_START_##NAME - DIAG_START_##PREV;                               \
   }
-CATEGORY(DRIVER, COMMON)
-CATEGORY(FRONTEND, DRIVER)
-CATEGORY(SERIALIZATION, FRONTEND)
-CATEGORY(LEX, SERIALIZATION)
-CATEGORY(PARSE, LEX)
-CATEGORY(AST, PARSE)
-CATEGORY(COMMENT, AST)
-CATEGORY(CROSSTU, COMMENT)
-CATEGORY(SEMA, CROSSTU)
-CATEGORY(ANALYSIS, SEMA)
-CATEGORY(REFACTORING, ANALYSIS)
+  CATEGORY(DRIVER, COMMON)
+  CATEGORY(FRONTEND, DRIVER)
+  CATEGORY(SERIALIZATION, FRONTEND)
+  CATEGORY(LEX, SERIALIZATION)
+  CATEGORY(PARSE, LEX)
+  CATEGORY(AST, PARSE)
+  CATEGORY(COMMENT, AST)
+  CATEGORY(CROSSTU, COMMENT)
+  CATEGORY(SEMA, CROSSTU)
+  CATEGORY(ANALYSIS, SEMA)
+  CATEGORY(REFACTORING, ANALYSIS)
 #undef CATEGORY
 
   // Avoid out of bounds reads.
@@ -244,7 +243,7 @@
 
   assert(ID < StaticDiagInfoSize && Offset < StaticDiagInfoSize);
 
-  const StaticDiagInfoRec *Found = &StaticDiagInfo[ID + Offset];
+  StaticDiagInfoRec const *Found = &StaticDiagInfo[ID + Offset];
   // If the diag id doesn't match we found a different diag, abort. This can
   // happen when this function is called with an ID that points into a hole in
   // the diagID space.
@@ -257,7 +256,7 @@
   DiagnosticMapping Info = DiagnosticMapping::Make(
       diag::Severity::Fatal, /*IsUser=*/false, /*IsPragma=*/false);
 
-  if (const StaticDiagInfoRec *StaticInfo = GetDiagInfo(DiagID)) {
+  if (StaticDiagInfoRec const *StaticInfo = GetDiagInfo(DiagID)) {
     Info.setSeverity((diag::Severity)StaticInfo->DefaultSeverity);
 
     if (StaticInfo->WarnNoWerror) {
@@ -273,22 +272,20 @@
 /// getCategoryNumberForDiag - Return the category number that a specified
 /// DiagID belongs to, or 0 if no category.
 unsigned DiagnosticIDs::getCategoryNumberForDiag(unsigned DiagID) {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+  if (StaticDiagInfoRec const *Info = GetDiagInfo(DiagID))
     return Info->Category;
   return 0;
 }
 
 namespace {
-  // The diagnostic category names.
-  struct StaticDiagCategoryRec {
-    const char *NameStr;
-    uint8_t NameLen;
+// The diagnostic category names.
+struct StaticDiagCategoryRec {
+  char const *NameStr;
+  uint8_t NameLen;
 
-    StringRef getName() const {
-      return StringRef(NameStr, NameLen);
-    }
-  };
-}
+  StringRef getName() const { return StringRef(NameStr, NameLen); }
+};
+} // namespace
 
 // Unfortunately, the split between DiagnosticIDs and Diagnostic is not
 // particularly clean, but for now we just implement this method here so we can
@@ -307,11 +304,10 @@
 
 static const StaticDiagCategoryRec CategoryNameTable[] = {
 #define GET_CATEGORY_TABLE
-#define CATEGORY(X, ENUM) { X, STR_SIZE(X, uint8_t) },
+#define CATEGORY(X, ENUM) {X, STR_SIZE(X, uint8_t)},
 #include "clang/Basic/DiagnosticGroups.inc"
 #undef GET_CATEGORY_TABLE
-  { nullptr, 0 }
-};
+    {nullptr, 0}};
 
 /// getNumberOfCategories - Return the number of categories
 unsigned DiagnosticIDs::getNumberOfCategories() {
@@ -323,21 +319,19 @@
 /// invalid.
 StringRef DiagnosticIDs::getCategoryNameFromID(unsigned CategoryID) {
   if (CategoryID >= getNumberOfCategories())
-   return StringRef();
+    return StringRef();
   return CategoryNameTable[CategoryID].getName();
 }
 
-
-
 DiagnosticIDs::SFINAEResponse
 DiagnosticIDs::getDiagnosticSFINAEResponse(unsigned DiagID) {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+  if (StaticDiagInfoRec const *Info = GetDiagInfo(DiagID))
     return static_cast<DiagnosticIDs::SFINAEResponse>(Info->SFINAE);
   return SFINAE_Report;
 }
 
 bool DiagnosticIDs::isDeferrable(unsigned DiagID) {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+  if (StaticDiagInfoRec const *Info = GetDiagInfo(DiagID))
     return Info->Deferrable;
   return false;
 }
@@ -345,7 +339,7 @@
 /// getBuiltinDiagClass - Return the class field of the diagnostic.
 ///
 static unsigned getBuiltinDiagClass(unsigned DiagID) {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+  if (StaticDiagInfoRec const *Info = GetDiagInfo(DiagID))
     return Info->Class;
   return ~0U;
 }
@@ -355,47 +349,46 @@
 //===----------------------------------------------------------------------===//
 
 namespace clang {
-  namespace diag {
-    class CustomDiagInfo {
-      typedef std::pair<DiagnosticIDs::Level, std::string> DiagDesc;
-      std::vector<DiagDesc> DiagInfo;
-      std::map<DiagDesc, unsigned> DiagIDs;
-    public:
-
-      /// getDescription - Return the description of the specified custom
-      /// diagnostic.
-      StringRef getDescription(unsigned DiagID) const {
-        assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() &&
-               "Invalid diagnostic ID");
-        return DiagInfo[DiagID-DIAG_UPPER_LIMIT].second;
-      }
-
-      /// getLevel - Return the level of the specified custom diagnostic.
-      DiagnosticIDs::Level getLevel(unsigned DiagID) const {
-        assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() &&
-               "Invalid diagnostic ID");
-        return DiagInfo[DiagID-DIAG_UPPER_LIMIT].first;
-      }
-
-      unsigned getOrCreateDiagID(DiagnosticIDs::Level L, StringRef Message,
-                                 DiagnosticIDs &Diags) {
-        DiagDesc D(L, std::string(Message));
-        // Check to see if it already exists.
-        std::map<DiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D);
-        if (I != DiagIDs.end() && I->first == D)
-          return I->second;
-
-        // If not, assign a new ID.
-        unsigned ID = DiagInfo.size()+DIAG_UPPER_LIMIT;
-        DiagIDs.insert(std::make_pair(D, ID));
-        DiagInfo.push_back(D);
-        return ID;
-      }
-    };
-
-  } // end diag namespace
-} // end clang namespace
+namespace diag {
+class CustomDiagInfo {
+  typedef std::pair<DiagnosticIDs::Level, std::string> DiagDesc;
+  std::vector<DiagDesc> DiagInfo;
+  std::map<DiagDesc, unsigned> DiagIDs;
+
+public:
+  /// getDescription - Return the description of the specified custom
+  /// diagnostic.
+  StringRef getDescription(unsigned DiagID) const {
+    assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() &&
+           "Invalid diagnostic ID");
+    return DiagInfo[DiagID - DIAG_UPPER_LIMIT].second;
+  }
+
+  /// getLevel - Return the level of the specified custom diagnostic.
+  DiagnosticIDs::Level getLevel(unsigned DiagID) const {
+    assert(DiagID - DIAG_UPPER_LIMIT < DiagInfo.size() &&
+           "Invalid diagnostic ID");
+    return DiagInfo[DiagID - DIAG_UPPER_LIMIT].first;
+  }
+
+  unsigned getOrCreateDiagID(DiagnosticIDs::Level L, StringRef Message,
+                             DiagnosticIDs &Diags) {
+    DiagDesc D(L, std::string(Message));
+    // Check to see if it already exists.
+    std::map<DiagDesc, unsigned>::iterator I = DiagIDs.lower_bound(D);
+    if (I != DiagIDs.end() && I->first == D)
+      return I->second;
+
+    // If not, assign a new ID.
+    unsigned ID = DiagInfo.size() + DIAG_UPPER_LIMIT;
+    DiagIDs.insert(std::make_pair(D, ID));
+    DiagInfo.push_back(D);
+    return ID;
+  }
+};
 
+} // namespace diag
+} // namespace clang
 
 //===----------------------------------------------------------------------===//
 // Common Diagnostic implementation
@@ -417,7 +410,6 @@
   return CustomDiagInfo->getOrCreateDiagID(L, FormatString, *this);
 }
 
-
 /// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic
 /// level of the specified diagnostic ID is a Warning or Extension.
 /// This only works on builtin diagnostics, not custom ones, and is not legal to
@@ -431,7 +423,7 @@
 /// Note.
 bool DiagnosticIDs::isBuiltinNote(unsigned DiagID) {
   return DiagID < diag::DIAG_UPPER_LIMIT &&
-    getBuiltinDiagClass(DiagID) == CLASS_NOTE;
+         getBuiltinDiagClass(DiagID) == CLASS_NOTE;
 }
 
 /// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
@@ -440,7 +432,7 @@
 /// which case -pedantic enables it) or treated as a warning/error by default.
 ///
 bool DiagnosticIDs::isBuiltinExtensionDiag(unsigned DiagID,
-                                        bool &EnabledByDefault) {
+                                           bool &EnabledByDefault) {
   if (DiagID >= diag::DIAG_UPPER_LIMIT ||
       getBuiltinDiagClass(DiagID) != CLASS_EXTENSION)
     return false;
@@ -460,7 +452,7 @@
 /// getDescription - Given a diagnostic ID, return a description of the
 /// issue.
 StringRef DiagnosticIDs::getDescription(unsigned DiagID) const {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+  if (StaticDiagInfoRec const *Info = GetDiagInfo(DiagID))
     return Info->getDescription();
   assert(CustomDiagInfo && "Invalid CustomDiagInfo");
   return CustomDiagInfo->getDescription(DiagID);
@@ -487,7 +479,7 @@
 /// by consumable the DiagnosticClient.
 DiagnosticIDs::Level
 DiagnosticIDs::getDiagnosticLevel(unsigned DiagID, SourceLocation Loc,
-                                  const DiagnosticsEngine &Diag) const {
+                                  DiagnosticsEngine const &Diag) const {
   // Handle custom diagnostics, which cannot be mapped.
   if (DiagID >= diag::DIAG_UPPER_LIMIT) {
     assert(CustomDiagInfo && "Invalid CustomDiagInfo");
@@ -495,7 +487,8 @@
   }
 
   unsigned DiagClass = getBuiltinDiagClass(DiagID);
-  if (DiagClass == CLASS_NOTE) return DiagnosticIDs::Note;
+  if (DiagClass == CLASS_NOTE)
+    return DiagnosticIDs::Note;
   return toLevel(getDiagnosticSeverity(DiagID, Loc, Diag));
 }
 
@@ -507,7 +500,7 @@
 /// diagnostic state. Can be null in order to query the latest state.
 diag::Severity
 DiagnosticIDs::getDiagnosticSeverity(unsigned DiagID, SourceLocation Loc,
-                                     const DiagnosticsEngine &Diag) const {
+                                     DiagnosticsEngine const &Diag) const {
   assert(getBuiltinDiagClass(DiagID) != CLASS_NOTE);
 
   // Specific non-error diagnostics may be mapped to various levels from ignored
@@ -594,18 +587,18 @@
 #undef GET_DIAG_ARRAYS
 
 namespace {
-  struct WarningOption {
-    uint16_t NameOffset;
-    uint16_t Members;
-    uint16_t SubGroups;
-
-    // String is stored with a pascal-style length byte.
-    StringRef getName() const {
-      return StringRef(DiagGroupNames + NameOffset + 1,
-                       DiagGroupNames[NameOffset]);
-    }
-  };
-}
+struct WarningOption {
+  uint16_t NameOffset;
+  uint16_t Members;
+  uint16_t SubGroups;
+
+  // String is stored with a pascal-style length byte.
+  StringRef getName() const {
+    return StringRef(DiagGroupNames + NameOffset + 1,
+                     DiagGroupNames[NameOffset]);
+  }
+};
+} // namespace
 
 // Second the table of options, sorted by name for fast binary lookup.
 static const WarningOption OptionTable[] = {
@@ -618,7 +611,7 @@
 /// enables the specified diagnostic.  If there is no -Wfoo flag that controls
 /// the diagnostic, this returns null.
 StringRef DiagnosticIDs::getWarningOptionForDiag(unsigned DiagID) {
-  if (const StaticDiagInfoRec *Info = GetDiagInfo(DiagID))
+  if (StaticDiagInfoRec const *Info = GetDiagInfo(DiagID))
     return OptionTable[Info->getOptionGroupIndex()].getName();
   return StringRef();
 }
@@ -638,7 +631,7 @@
 /// Return \c true if any diagnostics were found in this group, even if they
 /// were filtered out due to having the wrong flavor.
 static bool getDiagnosticsInGroup(diag::Flavor Flavor,
-                                  const WarningOption *Group,
+                                  WarningOption const *Group,
                                   SmallVectorImpl<diag::kind> &Diags) {
   // An empty group is considered to be a warning group: we have empty groups
   // for GCC compatibility, and GCC does not have remarks.
@@ -648,7 +641,7 @@
   bool NotFound = true;
 
   // Add the members of the option diagnostic set.
-  const int16_t *Member = DiagArrays + Group->Members;
+  int16_t const *Member = DiagArrays + Group->Members;
   for (; *Member != -1; ++Member) {
     if (GetDiagInfo(*Member)->getFlavor() == Flavor) {
       NotFound = false;
@@ -657,19 +650,19 @@
   }
 
   // Add the members of the subgroups.
-  const int16_t *SubGroups = DiagSubGroups + Group->SubGroups;
+  int16_t const *SubGroups = DiagSubGroups + Group->SubGroups;
   for (; *SubGroups != (int16_t)-1; ++SubGroups)
-    NotFound &= getDiagnosticsInGroup(Flavor, &OptionTable[(short)*SubGroups],
-                                      Diags);
+    NotFound &=
+        getDiagnosticsInGroup(Flavor, &OptionTable[(short)*SubGroups], Diags);
 
   return NotFound;
 }
 
-bool
-DiagnosticIDs::getDiagnosticsInGroup(diag::Flavor Flavor, StringRef Group,
-                                     SmallVectorImpl<diag::kind> &Diags) const {
+bool DiagnosticIDs::getDiagnosticsInGroup(
+    diag::Flavor Flavor, StringRef Group,
+    SmallVectorImpl<diag::kind> &Diags) const {
   auto Found = llvm::partition_point(
-      OptionTable, [=](const WarningOption &O) { return O.getName() < Group; });
+      OptionTable, [=](WarningOption const &O) { return O.getName() < Group; });
   if (Found == std::end(OptionTable) || Found->getName() != Group)
     return true; // Option not found.
 
@@ -687,7 +680,7 @@
                                           StringRef Group) {
   StringRef Best;
   unsigned BestDistance = Group.size() + 1; // Sanity threshold.
-  for (const WarningOption &O : OptionTable) {
+  for (WarningOption const &O : OptionTable) {
     // Don't suggest ignored warning flags.
     if (!O.Members && !O.SubGroups)
       continue;
@@ -723,8 +716,8 @@
 
   // Figure out the diagnostic level of this message.
   unsigned DiagID = Info.getID();
-  DiagnosticIDs::Level DiagLevel
-    = getDiagnosticLevel(DiagID, Info.getLocation(), Diag);
+  DiagnosticIDs::Level DiagLevel =
+      getDiagnosticLevel(DiagID, Info.getLocation(), Diag);
 
   // Update counts for DiagnosticErrorTrap even if a fatal error occurred
   // or diagnostics are suppressed.
@@ -799,7 +792,8 @@
 
 void DiagnosticIDs::EmitDiag(DiagnosticsEngine &Diag, Level DiagLevel) const {
   Diagnostic Info(&Diag);
-  assert(DiagLevel != DiagnosticIDs::Ignored && "Cannot emit ignored diagnostics!");
+  assert(DiagLevel != DiagnosticIDs::Ignored &&
+         "Cannot emit ignored diagnostics!");
 
   Diag.Client->HandleDiagnostic((DiagnosticsEngine::Level)DiagLevel, Info);
   if (Diag.Client->IncludeInDiagnosticCounts()) {
Index: clang/lib/Basic/ExpressionTraits.cpp
===================================================================
--- clang/lib/Basic/ExpressionTraits.cpp
+++ clang/lib/Basic/ExpressionTraits.cpp
@@ -15,22 +15,22 @@
 #include <cassert>
 using namespace clang;
 
-static constexpr const char *ExpressionTraitNames[] = {
+static constexpr char const *ExpressionTraitNames[] = {
 #define EXPRESSION_TRAIT(Spelling, Name, Key) #Name,
 #include "clang/Basic/TokenKinds.def"
 };
 
-static constexpr const char *ExpressionTraitSpellings[] = {
+static constexpr char const *ExpressionTraitSpellings[] = {
 #define EXPRESSION_TRAIT(Spelling, Name, Key) #Spelling,
 #include "clang/Basic/TokenKinds.def"
 };
 
-const char *clang::getTraitName(ExpressionTrait T) {
+char const *clang::getTraitName(ExpressionTrait T) {
   assert(T <= ET_Last && "invalid enum value!");
   return ExpressionTraitNames[T];
 }
 
-const char *clang::getTraitSpelling(ExpressionTrait T) {
+char const *clang::getTraitSpelling(ExpressionTrait T) {
   assert(T <= ET_Last && "invalid enum value!");
   return ExpressionTraitSpellings[T];
 }
Index: clang/lib/Basic/FileManager.cpp
===================================================================
--- clang/lib/Basic/FileManager.cpp
+++ clang/lib/Basic/FileManager.cpp
@@ -48,7 +48,7 @@
 // Common logic.
 //===----------------------------------------------------------------------===//
 
-FileManager::FileManager(const FileSystemOptions &FSO,
+FileManager::FileManager(FileSystemOptions const &FSO,
                          IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS)
     : FS(std::move(FS)), FileSystemOpts(FSO), SeenDirEntries(64),
       SeenFileEntries(64), NextFileUID(0) {
@@ -94,8 +94,9 @@
   if (DirName.empty())
     DirName = ".";
 
-  auto &NamedDirEnt = *SeenDirEntries.insert(
-        {DirName, std::errc::no_such_file_or_directory}).first;
+  auto &NamedDirEnt =
+      *SeenDirEntries.insert({DirName, std::errc::no_such_file_or_directory})
+           .first;
 
   // When caching a virtual directory, we always cache its ancestors
   // at the same time.  Therefore, if DirName is already in the cache,
@@ -119,10 +120,9 @@
   // stat doesn't like trailing separators except for root directory.
   // At least, on Win32 MSVCRT, stat() cannot strip trailing '/'.
   // (though it can strip '\\')
-  if (DirName.size() > 1 &&
-      DirName != llvm::sys::path::root_path(DirName) &&
+  if (DirName.size() > 1 && DirName != llvm::sys::path::root_path(DirName) &&
       llvm::sys::path::is_separator(DirName.back()))
-    DirName = DirName.substr(0, DirName.size()-1);
+    DirName = DirName.substr(0, DirName.size() - 1);
 #ifdef _WIN32
   // Fixing a problem with "clang C:test.c" on Windows.
   // Stat("C:") does not recognize "C:" as a valid directory
@@ -157,8 +157,8 @@
 
   // Check to see if the directory exists.
   llvm::vfs::Status Status;
-  auto statError = getStatValue(InterndDirName, Status, false,
-                                nullptr /*directory lookup*/);
+  auto statError =
+      getStatValue(InterndDirName, Status, false, nullptr /*directory lookup*/);
   if (statError) {
     // There's no real directory at the given path.
     if (CacheFailure)
@@ -178,13 +178,13 @@
   if (UDE.getName().empty()) {
     // We don't have this directory yet, add it.  We use the string
     // key from the SeenDirEntries map as the string.
-    UDE.Name  = InterndDirName;
+    UDE.Name = InterndDirName;
   }
 
   return DirectoryEntryRef(NamedDirEnt);
 }
 
-llvm::ErrorOr<const DirectoryEntry *>
+llvm::ErrorOr<DirectoryEntry const *>
 FileManager::getDirectory(StringRef DirName, bool CacheFailure) {
   auto Result = getDirectoryRef(DirName, CacheFailure);
   if (Result)
@@ -192,7 +192,7 @@
   return llvm::errorToErrorCode(Result.takeError());
 }
 
-llvm::ErrorOr<const FileEntry *>
+llvm::ErrorOr<FileEntry const *>
 FileManager::getFile(StringRef Filename, bool openFile, bool CacheFailure) {
   auto Result = getFileRef(Filename, openFile, CacheFailure);
   if (Result)
@@ -216,8 +216,8 @@
     FileEntryRef::MapValue Value = *SeenFileInsertResult.first->second;
     if (LLVM_LIKELY(Value.V.is<FileEntry *>()))
       return FileEntryRef(*SeenFileInsertResult.first);
-    return FileEntryRef(*reinterpret_cast<const FileEntryRef::MapEntry *>(
-        Value.V.get<const void *>()));
+    return FileEntryRef(*reinterpret_cast<FileEntryRef::MapEntry const *>(
+        Value.V.get<void const *>()));
   }
 
   // We've not seen this before. Fill it in.
@@ -252,8 +252,8 @@
   // Check to see if the file exists.
   std::unique_ptr<llvm::vfs::File> F;
   llvm::vfs::Status Status;
-  auto statError = getStatValue(InterndFileName, Status, true,
-                                openFile ? &F : nullptr);
+  auto statError =
+      getStatValue(InterndFileName, Status, true, openFile ? &F : nullptr);
   if (statError) {
     // There's no real file at the given path.
     if (CacheFailure)
@@ -331,10 +331,10 @@
 
   // Otherwise, we don't have this file yet, add it.
   UFE.LastRef = ReturnedRef;
-  UFE.Size    = Status.getSize();
+  UFE.Size = Status.getSize();
   UFE.ModTime = llvm::sys::toTimeT(Status.getLastModificationTime());
-  UFE.Dir     = &DirInfo.getDirEntry();
-  UFE.UID     = NextFileUID++;
+  UFE.Dir = &DirInfo.getDirEntry();
+  UFE.UID = NextFileUID++;
   UFE.UniqueID = Status.getUniqueID();
   UFE.IsNamedPipe = Status.getType() == llvm::sys::fs::file_type::fifo_file;
   UFE.File = std::move(F);
@@ -369,7 +369,7 @@
   return *STDIN;
 }
 
-const FileEntry *FileManager::getVirtualFile(StringRef Filename, off_t Size,
+FileEntry const *FileManager::getVirtualFile(StringRef Filename, off_t Size,
                                              time_t ModificationTime) {
   return &getVirtualFileRef(Filename, Size, ModificationTime).getFileEntry();
 }
@@ -379,14 +379,15 @@
   ++NumFileLookups;
 
   // See if there is already an entry in the map for an existing file.
-  auto &NamedFileEnt = *SeenFileEntries.insert(
-      {Filename, std::errc::no_such_file_or_directory}).first;
+  auto &NamedFileEnt =
+      *SeenFileEntries.insert({Filename, std::errc::no_such_file_or_directory})
+           .first;
   if (NamedFileEnt.second) {
     FileEntryRef::MapValue Value = *NamedFileEnt.second;
     if (LLVM_LIKELY(Value.V.is<FileEntry *>()))
       return FileEntryRef(NamedFileEnt);
-    return FileEntryRef(*reinterpret_cast<const FileEntryRef::MapEntry *>(
-        Value.V.get<const void *>()));
+    return FileEntryRef(*reinterpret_cast<FileEntryRef::MapEntry const *>(
+        Value.V.get<void const *>()));
   }
 
   // We've not seen this before, or the file is cached as non-existent.
@@ -407,14 +408,13 @@
 
   // Check to see if the file exists. If so, drop the virtual file
   llvm::vfs::Status Status;
-  const char *InterndFileName = NamedFileEnt.first().data();
+  char const *InterndFileName = NamedFileEnt.first().data();
   if (!getStatValue(InterndFileName, Status, true, nullptr)) {
     UFE = &UniqueRealFiles[Status.getUniqueID()];
-    Status = llvm::vfs::Status(
-      Status.getName(), Status.getUniqueID(),
-      llvm::sys::toTimePoint(ModificationTime),
-      Status.getUser(), Status.getGroup(), Size,
-      Status.getType(), Status.getPermissions());
+    Status = llvm::vfs::Status(Status.getName(), Status.getUniqueID(),
+                               llvm::sys::toTimePoint(ModificationTime),
+                               Status.getUser(), Status.getGroup(), Size,
+                               Status.getType(), Status.getPermissions());
 
     NamedFileEnt.second = FileEntryRef::MapValue(*UFE, *DirInfo);
 
@@ -441,10 +441,10 @@
   }
 
   UFE->LastRef = FileEntryRef(NamedFileEnt);
-  UFE->Size    = Size;
+  UFE->Size = Size;
   UFE->ModTime = ModificationTime;
-  UFE->Dir     = &DirInfo->getDirEntry();
-  UFE->UID     = NextFileUID++;
+  UFE->Dir = &DirInfo->getDirEntry();
+  UFE->UID = NextFileUID++;
   UFE->IsValid = true;
   UFE->File.reset();
   return FileEntryRef(NamedFileEnt);
@@ -468,7 +468,7 @@
 
   // Fill in the new entry from the stat.
   BypassFileEntries.push_back(std::make_unique<FileEntry>());
-  const FileEntry &VFE = VF.getFileEntry();
+  FileEntry const &VFE = VF.getFileEntry();
   FileEntry &BFE = *BypassFileEntries.back();
   Insertion.first->second = FileEntryRef::MapValue(BFE, VF.getDir());
   BFE.LastRef = FileEntryRef(*Insertion.first);
@@ -485,8 +485,8 @@
 bool FileManager::FixupRelativePath(SmallVectorImpl<char> &path) const {
   StringRef pathRef(path.data(), path.size());
 
-  if (FileSystemOpts.WorkingDir.empty()
-      || llvm::sys::path::is_absolute(pathRef))
+  if (FileSystemOpts.WorkingDir.empty() ||
+      llvm::sys::path::is_absolute(pathRef))
     return false;
 
   SmallString<128> NewPath(FileSystemOpts.WorkingDir);
@@ -518,7 +518,7 @@
 }
 
 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
-FileManager::getBufferForFile(const FileEntry *Entry, bool isVolatile,
+FileManager::getBufferForFile(FileEntry const *Entry, bool isVolatile,
                               bool RequiresNullTerminator) {
   // If the content is living on the file entry, return a reference to it.
   if (Entry->Content)
@@ -563,14 +563,15 @@
 /// if the path points to a virtual file or does not exist, or returns
 /// false if it's an existent real file.  If FileDescriptor is NULL,
 /// do directory look-up instead of file look-up.
-std::error_code
-FileManager::getStatValue(StringRef Path, llvm::vfs::Status &Status,
-                          bool isFile, std::unique_ptr<llvm::vfs::File> *F) {
+std::error_code FileManager::getStatValue(StringRef Path,
+                                          llvm::vfs::Status &Status,
+                                          bool isFile,
+                                          std::unique_ptr<llvm::vfs::File> *F) {
   // FIXME: FileSystemOpts shouldn't be passed in here, all paths should be
   // absolute!
   if (FileSystemOpts.WorkingDir.empty())
-    return FileSystemStatCache::get(Path, Status, isFile, F,
-                                    StatCache.get(), *FS);
+    return FileSystemStatCache::get(Path, Status, isFile, F, StatCache.get(),
+                                    *FS);
 
   SmallString<128> FilePath(Path);
   FixupRelativePath(FilePath);
@@ -579,9 +580,8 @@
                                   StatCache.get(), *FS);
 }
 
-std::error_code
-FileManager::getNoncachedStatValue(StringRef Path,
-                                   llvm::vfs::Status &Result) {
+std::error_code FileManager::getNoncachedStatValue(StringRef Path,
+                                                   llvm::vfs::Status &Result) {
   SmallString<128> FilePath(Path);
   FixupRelativePath(FilePath);
 
@@ -593,7 +593,7 @@
 }
 
 void FileManager::GetUniqueIDMapping(
-                   SmallVectorImpl<const FileEntry *> &UIDToFiles) const {
+    SmallVectorImpl<FileEntry const *> &UIDToFiles) const {
   UIDToFiles.clear();
   UIDToFiles.resize(NextFileUID);
 
@@ -604,18 +604,18 @@
            FEEnd = SeenFileEntries.end();
        FE != FEEnd; ++FE)
     if (llvm::ErrorOr<FileEntryRef::MapValue> Entry = FE->getValue()) {
-      if (const auto *FE = Entry->V.dyn_cast<FileEntry *>())
+      if (auto const *FE = Entry->V.dyn_cast<FileEntry *>())
         UIDToFiles[FE->getUID()] = FE;
     }
 
   // Map virtual file entries
-  for (const auto &VFE : VirtualFileEntries)
+  for (auto const &VFE : VirtualFileEntries)
     UIDToFiles[VFE->getUID()] = VFE.get();
 }
 
-StringRef FileManager::getCanonicalName(const DirectoryEntry *Dir) {
-  llvm::DenseMap<const void *, llvm::StringRef>::iterator Known
-    = CanonicalNames.find(Dir);
+StringRef FileManager::getCanonicalName(DirectoryEntry const *Dir) {
+  llvm::DenseMap<void const *, llvm::StringRef>::iterator Known =
+      CanonicalNames.find(Dir);
   if (Known != CanonicalNames.end())
     return Known->second;
 
@@ -629,9 +629,9 @@
   return CanonicalName;
 }
 
-StringRef FileManager::getCanonicalName(const FileEntry *File) {
-  llvm::DenseMap<const void *, llvm::StringRef>::iterator Known
-    = CanonicalNames.find(File);
+StringRef FileManager::getCanonicalName(FileEntry const *File) {
+  llvm::DenseMap<void const *, llvm::StringRef>::iterator Known =
+      CanonicalNames.find(File);
   if (Known != CanonicalNames.end())
     return Known->second;
 
@@ -651,10 +651,10 @@
                << UniqueRealDirs.size() << " real dirs found.\n";
   llvm::errs() << VirtualFileEntries.size() << " virtual files found, "
                << VirtualDirectoryEntries.size() << " virtual dirs found.\n";
-  llvm::errs() << NumDirLookups << " dir lookups, "
-               << NumDirCacheMisses << " dir cache misses.\n";
-  llvm::errs() << NumFileLookups << " file lookups, "
-               << NumFileCacheMisses << " file cache misses.\n";
+  llvm::errs() << NumDirLookups << " dir lookups, " << NumDirCacheMisses
+               << " dir cache misses.\n";
+  llvm::errs() << NumFileLookups << " file lookups, " << NumFileCacheMisses
+               << " file cache misses.\n";
 
-  //llvm::errs() << PagesMapped << BytesOfPagesMapped << FSLookups;
+  // llvm::errs() << PagesMapped << BytesOfPagesMapped << FSLookups;
 }
Index: clang/lib/Basic/FileSystemStatCache.cpp
===================================================================
--- clang/lib/Basic/FileSystemStatCache.cpp
+++ clang/lib/Basic/FileSystemStatCache.cpp
@@ -30,11 +30,11 @@
 /// success for directories (not files).  On a successful file lookup, the
 /// implementation can optionally fill in FileDescriptor with a valid
 /// descriptor and the client guarantees that it will close it.
-std::error_code
-FileSystemStatCache::get(StringRef Path, llvm::vfs::Status &Status,
-                         bool isFile, std::unique_ptr<llvm::vfs::File> *F,
-                         FileSystemStatCache *Cache,
-                         llvm::vfs::FileSystem &FS) {
+std::error_code FileSystemStatCache::get(StringRef Path,
+                                         llvm::vfs::Status &Status, bool isFile,
+                                         std::unique_ptr<llvm::vfs::File> *F,
+                                         FileSystemStatCache *Cache,
+                                         llvm::vfs::FileSystem &FS) {
   bool isForDir = !isFile;
   std::error_code RetCode;
 
@@ -90,19 +90,19 @@
     // If not, close the file if opened.
     if (F)
       *F = nullptr;
-    return std::make_error_code(
-        Status.isDirectory() ?
-            std::errc::is_a_directory : std::errc::not_a_directory);
+    return std::make_error_code(Status.isDirectory()
+                                    ? std::errc::is_a_directory
+                                    : std::errc::not_a_directory);
   }
 
   return std::error_code();
 }
 
-std::error_code
-MemorizeStatCalls::getStat(StringRef Path, llvm::vfs::Status &Status,
-                           bool isFile,
-                           std::unique_ptr<llvm::vfs::File> *F,
-                           llvm::vfs::FileSystem &FS) {
+std::error_code MemorizeStatCalls::getStat(StringRef Path,
+                                           llvm::vfs::Status &Status,
+                                           bool isFile,
+                                           std::unique_ptr<llvm::vfs::File> *F,
+                                           llvm::vfs::FileSystem &FS) {
   auto err = get(Path, Status, isFile, F, nullptr, FS);
   if (err) {
     // Do not cache failed stats, it is easy to construct common inconsistent
Index: clang/lib/Basic/IdentifierTable.cpp
===================================================================
--- clang/lib/Basic/IdentifierTable.cpp
+++ clang/lib/Basic/IdentifierTable.cpp
@@ -51,8 +51,7 @@
 
 /// A simple identifier lookup iterator that represents an
 /// empty sequence of identifiers.
-class EmptyLookupIterator : public IdentifierIterator
-{
+class EmptyLookupIterator : public IdentifierIterator {
 public:
   StringRef Next() override { return StringRef(); }
 };
@@ -67,7 +66,7 @@
     : HashTable(8192), // Start with space for 8K identifiers.
       ExternalLookup(ExternalLookup) {}
 
-IdentifierTable::IdentifierTable(const LangOptions &LangOpts,
+IdentifierTable::IdentifierTable(LangOptions const &LangOpts,
                                  IdentifierInfoLookup *ExternalLookup)
     : IdentifierTable(ExternalLookup) {
   // Populate the identifier table with info about keywords for the current
@@ -82,78 +81,101 @@
 // Constants for TokenKinds.def
 namespace {
 
-  enum {
-    KEYC99        = 0x1,
-    KEYCXX        = 0x2,
-    KEYCXX11      = 0x4,
-    KEYGNU        = 0x8,
-    KEYMS         = 0x10,
-    BOOLSUPPORT   = 0x20,
-    KEYALTIVEC    = 0x40,
-    KEYNOCXX      = 0x80,
-    KEYBORLAND    = 0x100,
-    KEYOPENCLC    = 0x200,
-    KEYC11        = 0x400,
-    KEYNOMS18     = 0x800,
-    KEYNOOPENCL   = 0x1000,
-    WCHARSUPPORT  = 0x2000,
-    HALFSUPPORT   = 0x4000,
-    CHAR8SUPPORT  = 0x8000,
-    KEYCONCEPTS   = 0x10000,
-    KEYOBJC       = 0x20000,
-    KEYZVECTOR    = 0x40000,
-    KEYCOROUTINES = 0x80000,
-    KEYMODULES    = 0x100000,
-    KEYCXX20      = 0x200000,
-    KEYOPENCLCXX  = 0x400000,
-    KEYMSCOMPAT   = 0x800000,
-    KEYSYCL       = 0x1000000,
-    KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX20,
-    KEYALL = (0x1ffffff & ~KEYNOMS18 &
-              ~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude.
-  };
-
-  /// How a keyword is treated in the selected standard.
-  enum KeywordStatus {
-    KS_Disabled,    // Disabled
-    KS_Extension,   // Is an extension
-    KS_Enabled,     // Enabled
-    KS_Future       // Is a keyword in future standard
-  };
+enum {
+  KEYC99 = 0x1,
+  KEYCXX = 0x2,
+  KEYCXX11 = 0x4,
+  KEYGNU = 0x8,
+  KEYMS = 0x10,
+  BOOLSUPPORT = 0x20,
+  KEYALTIVEC = 0x40,
+  KEYNOCXX = 0x80,
+  KEYBORLAND = 0x100,
+  KEYOPENCLC = 0x200,
+  KEYC11 = 0x400,
+  KEYNOMS18 = 0x800,
+  KEYNOOPENCL = 0x1000,
+  WCHARSUPPORT = 0x2000,
+  HALFSUPPORT = 0x4000,
+  CHAR8SUPPORT = 0x8000,
+  KEYCONCEPTS = 0x10000,
+  KEYOBJC = 0x20000,
+  KEYZVECTOR = 0x40000,
+  KEYCOROUTINES = 0x80000,
+  KEYMODULES = 0x100000,
+  KEYCXX20 = 0x200000,
+  KEYOPENCLCXX = 0x400000,
+  KEYMSCOMPAT = 0x800000,
+  KEYSYCL = 0x1000000,
+  KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX20,
+  KEYALL = (0x1ffffff & ~KEYNOMS18 &
+            ~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude.
+};
+
+/// How a keyword is treated in the selected standard.
+enum KeywordStatus {
+  KS_Disabled,  // Disabled
+  KS_Extension, // Is an extension
+  KS_Enabled,   // Enabled
+  KS_Future     // Is a keyword in future standard
+};
 
 } // namespace
 
 /// Translates flags as specified in TokenKinds.def into keyword status
 /// in the given language standard.
-static KeywordStatus getKeywordStatus(const LangOptions &LangOpts,
+static KeywordStatus getKeywordStatus(LangOptions const &LangOpts,
                                       unsigned Flags) {
-  if (Flags == KEYALL) return KS_Enabled;
-  if (LangOpts.CPlusPlus && (Flags & KEYCXX)) return KS_Enabled;
-  if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11)) return KS_Enabled;
-  if (LangOpts.CPlusPlus20 && (Flags & KEYCXX20)) return KS_Enabled;
-  if (LangOpts.C99 && (Flags & KEYC99)) return KS_Enabled;
-  if (LangOpts.GNUKeywords && (Flags & KEYGNU)) return KS_Extension;
-  if (LangOpts.MicrosoftExt && (Flags & KEYMS)) return KS_Extension;
-  if (LangOpts.MSVCCompat && (Flags & KEYMSCOMPAT)) return KS_Enabled;
-  if (LangOpts.Borland && (Flags & KEYBORLAND)) return KS_Extension;
-  if (LangOpts.Bool && (Flags & BOOLSUPPORT)) return KS_Enabled;
-  if (LangOpts.Half && (Flags & HALFSUPPORT)) return KS_Enabled;
-  if (LangOpts.WChar && (Flags & WCHARSUPPORT)) return KS_Enabled;
-  if (LangOpts.Char8 && (Flags & CHAR8SUPPORT)) return KS_Enabled;
-  if (LangOpts.AltiVec && (Flags & KEYALTIVEC)) return KS_Enabled;
-  if (LangOpts.ZVector && (Flags & KEYZVECTOR)) return KS_Enabled;
+  if (Flags == KEYALL)
+    return KS_Enabled;
+  if (LangOpts.CPlusPlus && (Flags & KEYCXX))
+    return KS_Enabled;
+  if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11))
+    return KS_Enabled;
+  if (LangOpts.CPlusPlus20 && (Flags & KEYCXX20))
+    return KS_Enabled;
+  if (LangOpts.C99 && (Flags & KEYC99))
+    return KS_Enabled;
+  if (LangOpts.GNUKeywords && (Flags & KEYGNU))
+    return KS_Extension;
+  if (LangOpts.MicrosoftExt && (Flags & KEYMS))
+    return KS_Extension;
+  if (LangOpts.MSVCCompat && (Flags & KEYMSCOMPAT))
+    return KS_Enabled;
+  if (LangOpts.Borland && (Flags & KEYBORLAND))
+    return KS_Extension;
+  if (LangOpts.Bool && (Flags & BOOLSUPPORT))
+    return KS_Enabled;
+  if (LangOpts.Half && (Flags & HALFSUPPORT))
+    return KS_Enabled;
+  if (LangOpts.WChar && (Flags & WCHARSUPPORT))
+    return KS_Enabled;
+  if (LangOpts.Char8 && (Flags & CHAR8SUPPORT))
+    return KS_Enabled;
+  if (LangOpts.AltiVec && (Flags & KEYALTIVEC))
+    return KS_Enabled;
+  if (LangOpts.ZVector && (Flags & KEYZVECTOR))
+    return KS_Enabled;
   if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLC))
     return KS_Enabled;
-  if (LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLCXX)) return KS_Enabled;
-  if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) return KS_Enabled;
-  if (LangOpts.C11 && (Flags & KEYC11)) return KS_Enabled;
+  if (LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLCXX))
+    return KS_Enabled;
+  if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX))
+    return KS_Enabled;
+  if (LangOpts.C11 && (Flags & KEYC11))
+    return KS_Enabled;
   // We treat bridge casts as objective-C keywords so we can warn on them
   // in non-arc mode.
-  if (LangOpts.ObjC && (Flags & KEYOBJC)) return KS_Enabled;
-  if (LangOpts.CPlusPlus20 && (Flags & KEYCONCEPTS)) return KS_Enabled;
-  if (LangOpts.Coroutines && (Flags & KEYCOROUTINES)) return KS_Enabled;
-  if (LangOpts.ModulesTS && (Flags & KEYMODULES)) return KS_Enabled;
-  if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future;
+  if (LangOpts.ObjC && (Flags & KEYOBJC))
+    return KS_Enabled;
+  if (LangOpts.CPlusPlus20 && (Flags & KEYCONCEPTS))
+    return KS_Enabled;
+  if (LangOpts.Coroutines && (Flags & KEYCOROUTINES))
+    return KS_Enabled;
+  if (LangOpts.ModulesTS && (Flags & KEYMODULES))
+    return KS_Enabled;
+  if (LangOpts.CPlusPlus && (Flags & KEYALLCXX))
+    return KS_Future;
   if (LangOpts.CPlusPlus && !LangOpts.CPlusPlus20 && (Flags & CHAR8SUPPORT))
     return KS_Future;
   if (LangOpts.isSYCL() && (Flags & KEYSYCL))
@@ -164,9 +186,9 @@
 /// AddKeyword - This method is used to associate a token ID with specific
 /// identifiers because they are language keywords.  This causes the lexer to
 /// automatically map matching identifiers to specialized token codes.
-static void AddKeyword(StringRef Keyword,
-                       tok::TokenKind TokenCode, unsigned Flags,
-                       const LangOptions &LangOpts, IdentifierTable &Table) {
+static void AddKeyword(StringRef Keyword, tok::TokenKind TokenCode,
+                       unsigned Flags, LangOptions const &LangOpts,
+                       IdentifierTable &Table) {
   KeywordStatus AddResult = getKeywordStatus(LangOpts, Flags);
 
   // Don't add this keyword under MSVCCompat.
@@ -179,7 +201,8 @@
     return;
 
   // Don't add this keyword if disabled in this language.
-  if (AddResult == KS_Disabled) return;
+  if (AddResult == KS_Disabled)
+    return;
 
   IdentifierInfo &Info =
       Table.get(Keyword, AddResult == KS_Future ? tok::identifier : TokenCode);
@@ -189,8 +212,7 @@
 
 /// AddCXXOperatorKeyword - Register a C++ operator keyword alternative
 /// representations.
-static void AddCXXOperatorKeyword(StringRef Keyword,
-                                  tok::TokenKind TokenCode,
+static void AddCXXOperatorKeyword(StringRef Keyword, tok::TokenKind TokenCode,
                                   IdentifierTable &Table) {
   IdentifierInfo &Info = Table.get(Keyword, TokenCode);
   Info.setIsCPlusPlusOperatorKeyword();
@@ -198,34 +220,31 @@
 
 /// AddObjCKeyword - Register an Objective-C \@keyword like "class" "selector"
 /// or "property".
-static void AddObjCKeyword(StringRef Name,
-                           tok::ObjCKeywordKind ObjCID,
+static void AddObjCKeyword(StringRef Name, tok::ObjCKeywordKind ObjCID,
                            IdentifierTable &Table) {
   Table.get(Name).setObjCKeywordID(ObjCID);
 }
 
 /// AddKeywords - Add all keywords to the symbol table.
 ///
-void IdentifierTable::AddKeywords(const LangOptions &LangOpts) {
+void IdentifierTable::AddKeywords(LangOptions const &LangOpts) {
   // Add keywords and tokens for the current language.
-#define KEYWORD(NAME, FLAGS) \
-  AddKeyword(StringRef(#NAME), tok::kw_ ## NAME,  \
-             FLAGS, LangOpts, *this);
-#define ALIAS(NAME, TOK, FLAGS) \
-  AddKeyword(StringRef(NAME), tok::kw_ ## TOK,  \
-             FLAGS, LangOpts, *this);
-#define CXX_KEYWORD_OPERATOR(NAME, ALIAS) \
-  if (LangOpts.CXXOperatorNames)          \
+#define KEYWORD(NAME, FLAGS)                                                   \
+  AddKeyword(StringRef(#NAME), tok::kw_##NAME, FLAGS, LangOpts, *this);
+#define ALIAS(NAME, TOK, FLAGS)                                                \
+  AddKeyword(StringRef(NAME), tok::kw_##TOK, FLAGS, LangOpts, *this);
+#define CXX_KEYWORD_OPERATOR(NAME, ALIAS)                                      \
+  if (LangOpts.CXXOperatorNames)                                               \
     AddCXXOperatorKeyword(StringRef(#NAME), tok::ALIAS, *this);
-#define OBJC_AT_KEYWORD(NAME)  \
-  if (LangOpts.ObjC)           \
+#define OBJC_AT_KEYWORD(NAME)                                                  \
+  if (LangOpts.ObjC)                                                           \
     AddObjCKeyword(StringRef(#NAME), tok::objc_##NAME, *this);
 #define TESTING_KEYWORD(NAME, FLAGS)
 #include "clang/Basic/TokenKinds.def"
 
   if (LangOpts.ParseUnknownAnytype)
-    AddKeyword("__unknown_anytype", tok::kw___unknown_anytype, KEYALL,
-               LangOpts, *this);
+    AddKeyword("__unknown_anytype", tok::kw___unknown_anytype, KEYALL, LangOpts,
+               *this);
 
   if (LangOpts.DeclSpecKeyword)
     AddKeyword("__declspec", tok::kw___declspec, KEYALL, LangOpts, *this);
@@ -240,19 +259,21 @@
 /// Checks if the specified token kind represents a keyword in the
 /// specified language.
 /// \returns Status of the keyword in the language.
-static KeywordStatus getTokenKwStatus(const LangOptions &LangOpts,
+static KeywordStatus getTokenKwStatus(LangOptions const &LangOpts,
                                       tok::TokenKind K) {
   switch (K) {
-#define KEYWORD(NAME, FLAGS) \
-  case tok::kw_##NAME: return getKeywordStatus(LangOpts, FLAGS);
+#define KEYWORD(NAME, FLAGS)                                                   \
+  case tok::kw_##NAME:                                                         \
+    return getKeywordStatus(LangOpts, FLAGS);
 #include "clang/Basic/TokenKinds.def"
-  default: return KS_Disabled;
+  default:
+    return KS_Disabled;
   }
 }
 
 /// Returns true if the identifier represents a keyword in the
 /// specified language.
-bool IdentifierInfo::isKeyword(const LangOptions &LangOpts) const {
+bool IdentifierInfo::isKeyword(LangOptions const &LangOpts) const {
   switch (getTokenKwStatus(LangOpts, getTokenID())) {
   case KS_Enabled:
   case KS_Extension:
@@ -264,7 +285,7 @@
 
 /// Returns true if the identifier represents a C++ keyword in the
 /// specified language.
-bool IdentifierInfo::isCPlusPlusKeyword(const LangOptions &LangOpts) const {
+bool IdentifierInfo::isCPlusPlusKeyword(LangOptions const &LangOpts) const {
   if (!LangOpts.CPlusPlus || !isKeyword(LangOpts))
     return false;
   // This is a C++ keyword if this identifier is not a keyword when checked
@@ -277,7 +298,7 @@
 }
 
 ReservedIdentifierStatus
-IdentifierInfo::isReserved(const LangOptions &LangOpts) const {
+IdentifierInfo::isReserved(LangOptions const &LangOpts) const {
   StringRef Name = getName();
 
   // '_' is a reserved identifier, but its use is so common (e.g. to store
@@ -315,48 +336,50 @@
   // collisions (if there were, the switch below would complain about duplicate
   // case values).  Note that this depends on 'if' being null terminated.
 
-#define HASH(LEN, FIRST, THIRD) \
-  (LEN << 5) + (((FIRST-'a') + (THIRD-'a')) & 31)
-#define CASE(LEN, FIRST, THIRD, NAME) \
-  case HASH(LEN, FIRST, THIRD): \
-    return memcmp(Name, #NAME, LEN) ? tok::pp_not_keyword : tok::pp_ ## NAME
+#define HASH(LEN, FIRST, THIRD)                                                \
+  (LEN << 5) + (((FIRST - 'a') + (THIRD - 'a')) & 31)
+#define CASE(LEN, FIRST, THIRD, NAME)                                          \
+  case HASH(LEN, FIRST, THIRD):                                                \
+    return memcmp(Name, #NAME, LEN) ? tok::pp_not_keyword : tok::pp_##NAME
 
   unsigned Len = getLength();
-  if (Len < 2) return tok::pp_not_keyword;
-  const char *Name = getNameStart();
+  if (Len < 2)
+    return tok::pp_not_keyword;
+  char const *Name = getNameStart();
   switch (HASH(Len, Name[0], Name[2])) {
-  default: return tok::pp_not_keyword;
-  CASE( 2, 'i', '\0', if);
-  CASE( 4, 'e', 'i', elif);
-  CASE( 4, 'e', 's', else);
-  CASE( 4, 'l', 'n', line);
-  CASE( 4, 's', 'c', sccs);
-  CASE( 5, 'e', 'd', endif);
-  CASE( 5, 'e', 'r', error);
-  CASE( 5, 'i', 'e', ident);
-  CASE( 5, 'i', 'd', ifdef);
-  CASE( 5, 'u', 'd', undef);
-
-  CASE( 6, 'a', 's', assert);
-  CASE( 6, 'd', 'f', define);
-  CASE( 6, 'i', 'n', ifndef);
-  CASE( 6, 'i', 'p', import);
-  CASE( 6, 'p', 'a', pragma);
-
-  CASE( 7, 'd', 'f', defined);
-  CASE( 7, 'e', 'i', elifdef);
-  CASE( 7, 'i', 'c', include);
-  CASE( 7, 'w', 'r', warning);
-
-  CASE( 8, 'e', 'i', elifndef);
-  CASE( 8, 'u', 'a', unassert);
-  CASE(12, 'i', 'c', include_next);
-
-  CASE(14, '_', 'p', __public_macro);
-
-  CASE(15, '_', 'p', __private_macro);
-
-  CASE(16, '_', 'i', __include_macros);
+  default:
+    return tok::pp_not_keyword;
+    CASE(2, 'i', '\0', if);
+    CASE(4, 'e', 'i', elif);
+    CASE(4, 'e', 's', else);
+    CASE(4, 'l', 'n', line);
+    CASE(4, 's', 'c', sccs);
+    CASE(5, 'e', 'd', endif);
+    CASE(5, 'e', 'r', error);
+    CASE(5, 'i', 'e', ident);
+    CASE(5, 'i', 'd', ifdef);
+    CASE(5, 'u', 'd', undef);
+
+    CASE(6, 'a', 's', assert);
+    CASE(6, 'd', 'f', define);
+    CASE(6, 'i', 'n', ifndef);
+    CASE(6, 'i', 'p', import);
+    CASE(6, 'p', 'a', pragma);
+
+    CASE(7, 'd', 'f', defined);
+    CASE(7, 'e', 'i', elifdef);
+    CASE(7, 'i', 'c', include);
+    CASE(7, 'w', 'r', warning);
+
+    CASE(8, 'e', 'i', elifndef);
+    CASE(8, 'u', 'a', unassert);
+    CASE(12, 'i', 'c', include_next);
+
+    CASE(14, '_', 'p', __public_macro);
+
+    CASE(15, '_', 'p', __private_macro);
+
+    CASE(16, '_', 'i', __include_macros);
 #undef CASE
 #undef HASH
   }
@@ -371,13 +394,15 @@
 void IdentifierTable::PrintStats() const {
   unsigned NumBuckets = HashTable.getNumBuckets();
   unsigned NumIdentifiers = HashTable.getNumItems();
-  unsigned NumEmptyBuckets = NumBuckets-NumIdentifiers;
+  unsigned NumEmptyBuckets = NumBuckets - NumIdentifiers;
   unsigned AverageIdentifierSize = 0;
   unsigned MaxIdentifierLength = 0;
 
   // TODO: Figure out maximum times an identifier had to probe for -stats.
-  for (llvm::StringMap<IdentifierInfo*, llvm::BumpPtrAllocator>::const_iterator
-       I = HashTable.begin(), E = HashTable.end(); I != E; ++I) {
+  for (llvm::StringMap<IdentifierInfo *, llvm::BumpPtrAllocator>::const_iterator
+           I = HashTable.begin(),
+           E = HashTable.end();
+       I != E; ++I) {
     unsigned IdLen = I->getKeyLength();
     AverageIdentifierSize += IdLen;
     if (MaxIdentifierLength < IdLen)
@@ -388,9 +413,9 @@
   fprintf(stderr, "# Identifiers:   %d\n", NumIdentifiers);
   fprintf(stderr, "# Empty Buckets: %d\n", NumEmptyBuckets);
   fprintf(stderr, "Hash density (#identifiers per bucket): %f\n",
-          NumIdentifiers/(double)NumBuckets);
+          NumIdentifiers / (double)NumBuckets);
   fprintf(stderr, "Ave identifier length: %f\n",
-          (AverageIdentifierSize/(double)NumIdentifiers));
+          (AverageIdentifierSize / (double)NumIdentifiers));
   fprintf(stderr, "Max identifier length: %d\n", MaxIdentifierLength);
 
   // Compute statistics about the memory allocated for identifiers.
@@ -402,7 +427,7 @@
 //===----------------------------------------------------------------------===//
 
 unsigned llvm::DenseMapInfo<clang::Selector>::getHashValue(clang::Selector S) {
-  return DenseMapInfo<void*>::getHashValue(S.getAsOpaquePtr());
+  return DenseMapInfo<void *>::getHashValue(S.getAsOpaquePtr());
 }
 
 namespace clang {
@@ -539,9 +564,7 @@
   return getMultiKeywordSelector()->getName();
 }
 
-void Selector::print(llvm::raw_ostream &OS) const {
-  OS << getAsString();
-}
+void Selector::print(llvm::raw_ostream &OS) const { OS << getAsString(); }
 
 LLVM_DUMP_METHOD void Selector::dump() const { print(llvm::errs()); }
 
@@ -549,25 +572,35 @@
 /// conventions, determine whether the given string starts with the
 /// given "word", which is assumed to end in a lowercase letter.
 static bool startsWithWord(StringRef name, StringRef word) {
-  if (name.size() < word.size()) return false;
+  if (name.size() < word.size())
+    return false;
   return ((name.size() == word.size() || !isLowercase(name[word.size()])) &&
           name.startswith(word));
 }
 
 ObjCMethodFamily Selector::getMethodFamilyImpl(Selector sel) {
   IdentifierInfo *first = sel.getIdentifierInfoForSlot(0);
-  if (!first) return OMF_None;
+  if (!first)
+    return OMF_None;
 
   StringRef name = first->getName();
   if (sel.isUnarySelector()) {
-    if (name == "autorelease") return OMF_autorelease;
-    if (name == "dealloc") return OMF_dealloc;
-    if (name == "finalize") return OMF_finalize;
-    if (name == "release") return OMF_release;
-    if (name == "retain") return OMF_retain;
-    if (name == "retainCount") return OMF_retainCount;
-    if (name == "self") return OMF_self;
-    if (name == "initialize") return OMF_initialize;
+    if (name == "autorelease")
+      return OMF_autorelease;
+    if (name == "dealloc")
+      return OMF_dealloc;
+    if (name == "finalize")
+      return OMF_finalize;
+    if (name == "release")
+      return OMF_release;
+    if (name == "retain")
+      return OMF_retain;
+    if (name == "retainCount")
+      return OMF_retainCount;
+    if (name == "self")
+      return OMF_self;
+    if (name == "initialize")
+      return OMF_initialize;
   }
 
   if (name == "performSelector" || name == "performSelectorInBackground" ||
@@ -578,22 +611,28 @@
   while (!name.empty() && name.front() == '_')
     name = name.substr(1);
 
-  if (name.empty()) return OMF_None;
+  if (name.empty())
+    return OMF_None;
   switch (name.front()) {
   case 'a':
-    if (startsWithWord(name, "alloc")) return OMF_alloc;
+    if (startsWithWord(name, "alloc"))
+      return OMF_alloc;
     break;
   case 'c':
-    if (startsWithWord(name, "copy")) return OMF_copy;
+    if (startsWithWord(name, "copy"))
+      return OMF_copy;
     break;
   case 'i':
-    if (startsWithWord(name, "init")) return OMF_init;
+    if (startsWithWord(name, "init"))
+      return OMF_init;
     break;
   case 'm':
-    if (startsWithWord(name, "mutableCopy")) return OMF_mutableCopy;
+    if (startsWithWord(name, "mutableCopy"))
+      return OMF_mutableCopy;
     break;
   case 'n':
-    if (startsWithWord(name, "new")) return OMF_new;
+    if (startsWithWord(name, "new"))
+      return OMF_new;
     break;
   default:
     break;
@@ -604,55 +643,67 @@
 
 ObjCInstanceTypeFamily Selector::getInstTypeMethodFamily(Selector sel) {
   IdentifierInfo *first = sel.getIdentifierInfoForSlot(0);
-  if (!first) return OIT_None;
+  if (!first)
+    return OIT_None;
 
   StringRef name = first->getName();
 
-  if (name.empty()) return OIT_None;
+  if (name.empty())
+    return OIT_None;
   switch (name.front()) {
-    case 'a':
-      if (startsWithWord(name, "array")) return OIT_Array;
-      break;
-    case 'd':
-      if (startsWithWord(name, "default")) return OIT_ReturnsSelf;
-      if (startsWithWord(name, "dictionary")) return OIT_Dictionary;
-      break;
-    case 's':
-      if (startsWithWord(name, "shared")) return OIT_ReturnsSelf;
-      if (startsWithWord(name, "standard")) return OIT_Singleton;
-      break;
-    case 'i':
-      if (startsWithWord(name, "init")) return OIT_Init;
-      break;
-    default:
-      break;
+  case 'a':
+    if (startsWithWord(name, "array"))
+      return OIT_Array;
+    break;
+  case 'd':
+    if (startsWithWord(name, "default"))
+      return OIT_ReturnsSelf;
+    if (startsWithWord(name, "dictionary"))
+      return OIT_Dictionary;
+    break;
+  case 's':
+    if (startsWithWord(name, "shared"))
+      return OIT_ReturnsSelf;
+    if (startsWithWord(name, "standard"))
+      return OIT_Singleton;
+    break;
+  case 'i':
+    if (startsWithWord(name, "init"))
+      return OIT_Init;
+    break;
+  default:
+    break;
   }
   return OIT_None;
 }
 
 ObjCStringFormatFamily Selector::getStringFormatFamilyImpl(Selector sel) {
   IdentifierInfo *first = sel.getIdentifierInfoForSlot(0);
-  if (!first) return SFF_None;
+  if (!first)
+    return SFF_None;
 
   StringRef name = first->getName();
 
   switch (name.front()) {
-    case 'a':
-      if (name == "appendFormat") return SFF_NSString;
-      break;
-
-    case 'i':
-      if (name == "initWithFormat") return SFF_NSString;
-      break;
-
-    case 'l':
-      if (name == "localizedStringWithFormat") return SFF_NSString;
-      break;
-
-    case 's':
-      if (name == "stringByAppendingFormat" ||
-          name == "stringWithFormat") return SFF_NSString;
-      break;
+  case 'a':
+    if (name == "appendFormat")
+      return SFF_NSString;
+    break;
+
+  case 'i':
+    if (name == "initWithFormat")
+      return SFF_NSString;
+    break;
+
+  case 'l':
+    if (name == "localizedStringWithFormat")
+      return SFF_NSString;
+    break;
+
+  case 's':
+    if (name == "stringByAppendingFormat" || name == "stringWithFormat")
+      return SFF_NSString;
+    break;
   }
   return SFF_None;
 }
@@ -667,23 +718,21 @@
 } // namespace
 
 static SelectorTableImpl &getSelectorTableImpl(void *P) {
-  return *static_cast<SelectorTableImpl*>(P);
+  return *static_cast<SelectorTableImpl *>(P);
 }
 
-SmallString<64>
-SelectorTable::constructSetterName(StringRef Name) {
+SmallString<64> SelectorTable::constructSetterName(StringRef Name) {
   SmallString<64> SetterName("set");
   SetterName += Name;
   SetterName[3] = toUppercase(SetterName[3]);
   return SetterName;
 }
 
-Selector
-SelectorTable::constructSetterSelector(IdentifierTable &Idents,
-                                       SelectorTable &SelTable,
-                                       const IdentifierInfo *Name) {
+Selector SelectorTable::constructSetterSelector(IdentifierTable &Idents,
+                                                SelectorTable &SelTable,
+                                                IdentifierInfo const *Name) {
   IdentifierInfo *SetterName =
-    &Idents.get(constructSetterName(Name->getName()));
+      &Idents.get(constructSetterName(Name->getName()));
   return SelTable.getUnarySelector(SetterName);
 }
 
@@ -710,12 +759,13 @@
 
   void *InsertPos = nullptr;
   if (MultiKeywordSelector *SI =
-        SelTabImpl.Table.FindNodeOrInsertPos(ID, InsertPos))
+          SelTabImpl.Table.FindNodeOrInsertPos(ID, InsertPos))
     return Selector(SI);
 
   // MultiKeywordSelector objects are not allocated with new because they have a
   // variable size array (for parameter types) at the end of them.
-  unsigned Size = sizeof(MultiKeywordSelector) + nKeys*sizeof(IdentifierInfo *);
+  unsigned Size =
+      sizeof(MultiKeywordSelector) + nKeys * sizeof(IdentifierInfo *);
   MultiKeywordSelector *SI =
       (MultiKeywordSelector *)SelTabImpl.Allocator.Allocate(
           Size, alignof(MultiKeywordSelector));
@@ -724,22 +774,19 @@
   return Selector(SI);
 }
 
-SelectorTable::SelectorTable() {
-  Impl = new SelectorTableImpl();
-}
+SelectorTable::SelectorTable() { Impl = new SelectorTableImpl(); }
 
-SelectorTable::~SelectorTable() {
-  delete &getSelectorTableImpl(Impl);
-}
+SelectorTable::~SelectorTable() { delete &getSelectorTableImpl(Impl); }
 
-const char *clang::getOperatorSpelling(OverloadedOperatorKind Operator) {
+char const *clang::getOperatorSpelling(OverloadedOperatorKind Operator) {
   switch (Operator) {
   case OO_None:
   case NUM_OVERLOADED_OPERATORS:
     return nullptr;
 
-#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
-  case OO_##Name: return Spelling;
+#define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly)  \
+  case OO_##Name:                                                              \
+    return Spelling;
 #include "clang/Basic/OperatorKinds.def"
   }
 
Index: clang/lib/Basic/LangOptions.cpp
===================================================================
--- clang/lib/Basic/LangOptions.cpp
+++ clang/lib/Basic/LangOptions.cpp
@@ -25,7 +25,7 @@
 void LangOptions::resetNonModularOptions() {
 #define LANGOPT(Name, Bits, Default, Description)
 #define BENIGN_LANGOPT(Name, Bits, Default, Description) Name = Default;
-#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
+#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)            \
   Name = static_cast<unsigned>(Default);
 #include "clang/Basic/LangOptions.def"
 
@@ -46,7 +46,7 @@
 }
 
 VersionTuple LangOptions::getOpenCLVersionTuple() const {
-  const int Ver = OpenCLCPlusPlus ? OpenCLCPlusPlusVersion : OpenCLVersion;
+  int const Ver = OpenCLCPlusPlus ? OpenCLCPlusPlusVersion : OpenCLVersion;
   if (OpenCLCPlusPlus && Ver != 100)
     return VersionTuple(Ver / 100);
   return VersionTuple(Ver / 100, (Ver % 100) / 10);
@@ -63,7 +63,7 @@
 }
 
 void LangOptions::remapPathPrefix(SmallString<256> &Path) const {
-  for (const auto &Entry : MacroPrefixMap)
+  for (auto const &Entry : MacroPrefixMap)
     if (llvm::sys::path::replace_path_prefix(Path, Entry.first, Entry.second))
       break;
 }
@@ -78,7 +78,7 @@
   return Result;
 }
 
-FPOptions FPOptions::defaultWithoutTrailingStorage(const LangOptions &LO) {
+FPOptions FPOptions::defaultWithoutTrailingStorage(LangOptions const &LO) {
   FPOptions result(LO);
   return result;
 }
Index: clang/lib/Basic/LangStandards.cpp
===================================================================
--- clang/lib/Basic/LangStandards.cpp
+++ clang/lib/Basic/LangStandards.cpp
@@ -15,12 +15,13 @@
   static const LangStandard Lang_##id = {name, desc, features, Language::lang};
 #include "clang/Basic/LangStandards.def"
 
-const LangStandard &LangStandard::getLangStandardForKind(Kind K) {
+LangStandard const &LangStandard::getLangStandardForKind(Kind K) {
   switch (K) {
   case lang_unspecified:
     llvm::report_fatal_error("getLangStandardForKind() on unspecified kind");
-#define LANGSTANDARD(id, name, lang, desc, features) \
-    case lang_##id: return Lang_##id;
+#define LANGSTANDARD(id, name, lang, desc, features)                           \
+  case lang_##id:                                                              \
+    return Lang_##id;
 #include "clang/Basic/LangStandards.def"
   }
   llvm_unreachable("Invalid language kind!");
@@ -34,12 +35,10 @@
       .Default(lang_unspecified);
 }
 
-const LangStandard *LangStandard::getLangStandardForName(StringRef Name) {
+LangStandard const *LangStandard::getLangStandardForName(StringRef Name) {
   Kind K = getLangKind(Name);
   if (K == lang_unspecified)
     return nullptr;
 
   return &getLangStandardForKind(K);
 }
-
-
Index: clang/lib/Basic/Module.cpp
===================================================================
--- clang/lib/Basic/Module.cpp
+++ clang/lib/Basic/Module.cpp
@@ -65,7 +65,7 @@
   }
 }
 
-static bool isPlatformEnvironment(const TargetInfo &Target, StringRef Feature) {
+static bool isPlatformEnvironment(TargetInfo const &Target, StringRef Feature) {
   StringRef Platform = Target.getPlatformName();
   StringRef Env = Target.getTriple().getEnvironmentName();
 
@@ -79,7 +79,7 @@
     if (Pos == StringRef::npos)
       return false;
     SmallString<128> NewLHS = LHS.slice(0, Pos);
-    NewLHS += LHS.slice(Pos+1, LHS.size());
+    NewLHS += LHS.slice(Pos + 1, LHS.size());
     return NewLHS == RHS;
   };
 
@@ -98,8 +98,8 @@
 
 /// Determine whether a translation unit built using the current
 /// language options has the given feature.
-static bool hasFeature(StringRef Feature, const LangOptions &LangOpts,
-                       const TargetInfo &Target) {
+static bool hasFeature(StringRef Feature, LangOptions const &LangOpts,
+                       TargetInfo const &Target) {
   bool HasFeature = llvm::StringSwitch<bool>(Feature)
                         .Case("altivec", LangOpts.AltiVec)
                         .Case("blocks", LangOpts.Blocks)
@@ -127,20 +127,20 @@
   return HasFeature;
 }
 
-bool Module::isUnimportable(const LangOptions &LangOpts,
-                            const TargetInfo &Target, Requirement &Req,
+bool Module::isUnimportable(LangOptions const &LangOpts,
+                            TargetInfo const &Target, Requirement &Req,
                             Module *&ShadowingModule) const {
   if (!IsUnimportable)
     return false;
 
-  for (const Module *Current = this; Current; Current = Current->Parent) {
+  for (Module const *Current = this; Current; Current = Current->Parent) {
     if (Current->ShadowingModule) {
       ShadowingModule = Current->ShadowingModule;
       return true;
     }
     for (unsigned I = 0, N = Current->Requirements.size(); I != N; ++I) {
       if (hasFeature(Current->Requirements[I].first, LangOpts, Target) !=
-              Current->Requirements[I].second) {
+          Current->Requirements[I].second) {
         Req = Current->Requirements[I];
         return true;
       }
@@ -150,7 +150,7 @@
   llvm_unreachable("could not find a reason why module is unimportable");
 }
 
-bool Module::isAvailable(const LangOptions &LangOpts, const TargetInfo &Target,
+bool Module::isAvailable(LangOptions const &LangOpts, TargetInfo const &Target,
                          Requirement &Req,
                          UnresolvedHeaderDirective &MissingHeader,
                          Module *&ShadowingModule) const {
@@ -162,7 +162,7 @@
 
   // FIXME: All missing headers are listed on the top-level module. Should we
   // just look there?
-  for (const Module *Current = this; Current; Current = Current->Parent) {
+  for (Module const *Current = this; Current; Current = Current->Parent) {
     if (!Current->MissingHeaders.empty()) {
       MissingHeader = Current->MissingHeaders.front();
       return false;
@@ -172,7 +172,7 @@
   llvm_unreachable("could not find a reason why module is unavailable");
 }
 
-bool Module::isSubModuleOf(const Module *Other) const {
+bool Module::isSubModuleOf(Module const *Other) const {
   for (auto *Parent = this; Parent; Parent = Parent->Parent) {
     if (Parent == Other)
       return true;
@@ -180,8 +180,8 @@
   return false;
 }
 
-const Module *Module::getTopLevelModule() const {
-  const Module *Result = this;
+Module const *Module::getTopLevelModule() const {
+  Module const *Result = this;
   while (Result->Parent)
     Result = Result->Parent;
 
@@ -189,13 +189,13 @@
 }
 
 static StringRef getModuleNameFromComponent(
-    const std::pair<std::string, SourceLocation> &IdComponent) {
+    std::pair<std::string, SourceLocation> const &IdComponent) {
   return IdComponent.first;
 }
 
 static StringRef getModuleNameFromComponent(StringRef R) { return R; }
 
-template<typename InputIter>
+template <typename InputIter>
 static void printModuleId(raw_ostream &OS, InputIter Begin, InputIter End,
                           bool AllowStringLiterals = true) {
   for (InputIter It = Begin; It != End; ++It) {
@@ -213,8 +213,8 @@
   }
 }
 
-template<typename Container>
-static void printModuleId(raw_ostream &OS, const Container &C) {
+template <typename Container>
+static void printModuleId(raw_ostream &OS, Container const &C) {
   return printModuleId(OS, C.begin(), C.end());
 }
 
@@ -222,7 +222,7 @@
   SmallVector<StringRef, 2> Names;
 
   // Build up the set of module names (from innermost to outermost).
-  for (const Module *M = this; M; M = M->Parent)
+  for (Module const *M = this; M; M = M->Parent)
     Names.push_back(M->Name);
 
   std::string Result;
@@ -235,7 +235,7 @@
 }
 
 bool Module::fullModuleNameIs(ArrayRef<StringRef> nameParts) const {
-  for (const Module *M = this; M; M = M->Parent) {
+  for (Module const *M = this; M; M = M->Parent) {
     if (nameParts.empty() || M->Name != nameParts.back())
       return false;
     nameParts = nameParts.drop_back();
@@ -248,18 +248,19 @@
     return {"", "", U.Entry->getDir()};
 
   return {UmbrellaAsWritten, UmbrellaRelativeToRootModuleDirectory,
-          Umbrella.dyn_cast<const DirectoryEntry *>()};
+          Umbrella.dyn_cast<DirectoryEntry const *>()};
 }
 
-void Module::addTopHeader(const FileEntry *File) {
+void Module::addTopHeader(FileEntry const *File) {
   assert(File);
   TopHeaders.insert(File);
 }
 
-ArrayRef<const FileEntry *> Module::getTopHeaders(FileManager &FileMgr) {
+ArrayRef<FileEntry const *> Module::getTopHeaders(FileManager &FileMgr) {
   if (!TopHeaderNames.empty()) {
-    for (std::vector<std::string>::iterator
-           I = TopHeaderNames.begin(), E = TopHeaderNames.end(); I != E; ++I) {
+    for (std::vector<std::string>::iterator I = TopHeaderNames.begin(),
+                                            E = TopHeaderNames.end();
+         I != E; ++I) {
       if (auto FE = FileMgr.getFile(*I))
         TopHeaders.insert(*FE);
     }
@@ -269,7 +270,7 @@
   return llvm::makeArrayRef(TopHeaders.begin(), TopHeaders.end());
 }
 
-bool Module::directlyUses(const Module *Requested) const {
+bool Module::directlyUses(Module const *Requested) const {
   auto *Top = getTopLevelModule();
 
   // A top-level module implicitly uses itself.
@@ -288,15 +289,15 @@
 }
 
 void Module::addRequirement(StringRef Feature, bool RequiredState,
-                            const LangOptions &LangOpts,
-                            const TargetInfo &Target) {
+                            LangOptions const &LangOpts,
+                            TargetInfo const &Target) {
   Requirements.push_back(Requirement(std::string(Feature), RequiredState));
 
   // If this feature is currently available, we're done.
   if (hasFeature(Feature, LangOpts, Target) == RequiredState)
     return;
 
-  markUnavailable(/*Unimportable*/true);
+  markUnavailable(/*Unimportable*/ true);
 }
 
 void Module::markUnavailable(bool Unimportable) {
@@ -319,7 +320,7 @@
     Current->IsAvailable = false;
     Current->IsUnimportable |= Unimportable;
     for (submodule_iterator Sub = Current->submodule_begin(),
-                         SubEnd = Current->submodule_end();
+                            SubEnd = Current->submodule_end();
          Sub != SubEnd; ++Sub) {
       if (needUpdate(*Sub))
         Stack.push_back(*Sub);
@@ -341,7 +342,8 @@
     return SubModules[Pos->getValue()];
   if (!InferSubmodules)
     return nullptr;
-  Module *Result = new Module(Name, SourceLocation(), this, false, InferExplicitSubmodules, 0);
+  Module *Result = new Module(Name, SourceLocation(), this, false,
+                              InferExplicitSubmodules, 0);
   Result->InferExplicitSubmodules = InferExplicitSubmodules;
   Result->InferSubmodules = InferSubmodules;
   Result->InferExportWildcard = InferExportWildcard;
@@ -502,8 +504,8 @@
       OS.indent(Indent + 2);
       OS << K.Prefix << "header \"";
       OS.write_escaped(H.NameAsWritten);
-      OS << "\" { size " << H.Entry->getSize()
-         << " mtime " << H.Entry->getModificationTime() << " }\n";
+      OS << "\" { size " << H.Entry->getSize() << " mtime "
+         << H.Entry->getModificationTime() << " }\n";
     }
   }
   for (auto *Unresolved : {&UnresolvedHeaders, &MissingHeaders}) {
@@ -626,9 +628,7 @@
   OS << "}\n";
 }
 
-LLVM_DUMP_METHOD void Module::dump() const {
-  print(llvm::errs(), 0, true);
-}
+LLVM_DUMP_METHOD void Module::dump() const { print(llvm::errs(), 0, true); }
 
 void VisibleModuleSet::setVisible(Module *M, SourceLocation Loc,
                                   VisibleCallback Vis, ConflictCallback Cb) {
@@ -665,7 +665,7 @@
 
     for (auto &C : V.M->Conflicts) {
       if (isVisible(C.Other)) {
-        llvm::SmallVector<Module*, 8> Path;
+        llvm::SmallVector<Module *, 8> Path;
         for (Visiting *I = &V; I; I = I->ExportedBy)
           Path.push_back(I->M);
         Cb(Path, C.Other, C.Message);
Index: clang/lib/Basic/NoSanitizeList.cpp
===================================================================
--- clang/lib/Basic/NoSanitizeList.cpp
+++ clang/lib/Basic/NoSanitizeList.cpp
@@ -19,7 +19,7 @@
 
 using namespace clang;
 
-NoSanitizeList::NoSanitizeList(const std::vector<std::string> &NoSanitizePaths,
+NoSanitizeList::NoSanitizeList(std::vector<std::string> const &NoSanitizePaths,
                                SourceManager &SM)
     : SSCL(SanitizerSpecialCaseList::createOrDie(
           NoSanitizePaths, SM.getFileManager().getVirtualFileSystem())),
Index: clang/lib/Basic/ObjCRuntime.cpp
===================================================================
--- clang/lib/Basic/ObjCRuntime.cpp
+++ clang/lib/Basic/ObjCRuntime.cpp
@@ -29,15 +29,29 @@
   return Result;
 }
 
-raw_ostream &clang::operator<<(raw_ostream &out, const ObjCRuntime &value) {
+raw_ostream &clang::operator<<(raw_ostream &out, ObjCRuntime const &value) {
   switch (value.getKind()) {
-  case ObjCRuntime::MacOSX: out << "macosx"; break;
-  case ObjCRuntime::FragileMacOSX: out << "macosx-fragile"; break;
-  case ObjCRuntime::iOS: out << "ios"; break;
-  case ObjCRuntime::WatchOS: out << "watchos"; break;
-  case ObjCRuntime::GNUstep: out << "gnustep"; break;
-  case ObjCRuntime::GCC: out << "gcc"; break;
-  case ObjCRuntime::ObjFW: out << "objfw"; break;
+  case ObjCRuntime::MacOSX:
+    out << "macosx";
+    break;
+  case ObjCRuntime::FragileMacOSX:
+    out << "macosx-fragile";
+    break;
+  case ObjCRuntime::iOS:
+    out << "ios";
+    break;
+  case ObjCRuntime::WatchOS:
+    out << "watchos";
+    break;
+  case ObjCRuntime::GNUstep:
+    out << "gnustep";
+    break;
+  case ObjCRuntime::GCC:
+    out << "gcc";
+    break;
+  case ObjCRuntime::ObjFW:
+    out << "objfw";
+    break;
   }
   if (value.getVersion() > VersionTuple(0)) {
     out << '-' << value.getVersion();
@@ -53,7 +67,7 @@
   // version to be omitted, so if we see a dash not followed by a
   // digit then we need to ignore it.
   if (dash != StringRef::npos && dash + 1 != input.size() &&
-      (input[dash+1] < '0' || input[dash+1] > '9')) {
+      (input[dash + 1] < '0' || input[dash + 1] > '9')) {
     dash = StringRef::npos;
   }
 
Index: clang/lib/Basic/OpenCLOptions.cpp
===================================================================
--- clang/lib/Basic/OpenCLOptions.cpp
+++ clang/lib/Basic/OpenCLOptions.cpp
@@ -17,7 +17,7 @@
 }
 
 bool OpenCLOptions::isAvailableOption(llvm::StringRef Ext,
-                                      const LangOptions &LO) const {
+                                      LangOptions const &LO) const {
   if (!isKnown(Ext))
     return false;
 
@@ -39,33 +39,33 @@
 }
 
 bool OpenCLOptions::isSupported(llvm::StringRef Ext,
-                                const LangOptions &LO) const {
+                                LangOptions const &LO) const {
   auto I = OptMap.find(Ext);
   return I != OptMap.end() && I->getValue().Supported &&
          I->getValue().isAvailableIn(LO);
 }
 
 bool OpenCLOptions::isSupportedCore(llvm::StringRef Ext,
-                                    const LangOptions &LO) const {
+                                    LangOptions const &LO) const {
   auto I = OptMap.find(Ext);
   return I != OptMap.end() && I->getValue().Supported &&
          I->getValue().isCoreIn(LO);
 }
 
 bool OpenCLOptions::isSupportedOptionalCore(llvm::StringRef Ext,
-                                            const LangOptions &LO) const {
+                                            LangOptions const &LO) const {
   auto I = OptMap.find(Ext);
   return I != OptMap.end() && I->getValue().Supported &&
          I->getValue().isOptionalCoreIn(LO);
 }
 
 bool OpenCLOptions::isSupportedCoreOrOptionalCore(llvm::StringRef Ext,
-                                                  const LangOptions &LO) const {
+                                                  LangOptions const &LO) const {
   return isSupportedCore(Ext, LO) || isSupportedOptionalCore(Ext, LO);
 }
 
 bool OpenCLOptions::isSupportedExtension(llvm::StringRef Ext,
-                                         const LangOptions &LO) const {
+                                         LangOptions const &LO) const {
   auto I = OptMap.find(Ext);
   return I != OptMap.end() && I->getValue().Supported &&
          I->getValue().isAvailableIn(LO) &&
@@ -92,10 +92,10 @@
 #include "clang/Basic/OpenCLExtensions.def"
 }
 
-void OpenCLOptions::addSupport(const llvm::StringMap<bool> &FeaturesMap,
-                               const LangOptions &Opts) {
-  for (const auto &F : FeaturesMap) {
-    const auto &Name = F.getKey();
+void OpenCLOptions::addSupport(llvm::StringMap<bool> const &FeaturesMap,
+                               LangOptions const &Opts) {
+  for (auto const &F : FeaturesMap) {
+    auto const &Name = F.getKey();
     if (F.getValue() && isKnown(Name) && OptMap[Name].isAvailableIn(Opts))
       support(Name);
   }
@@ -107,7 +107,7 @@
 }
 
 bool OpenCLOptions::diagnoseUnsupportedFeatureDependencies(
-    const TargetInfo &TI, DiagnosticsEngine &Diags) {
+    TargetInfo const &TI, DiagnosticsEngine &Diags) {
   // Feature pairs. First feature in a pair requires the second one to be
   // supported.
   static const llvm::StringMap<llvm::StringRef> DependentFeaturesMap = {
@@ -129,7 +129,7 @@
 }
 
 bool OpenCLOptions::diagnoseFeatureExtensionDifferences(
-    const TargetInfo &TI, DiagnosticsEngine &Diags) {
+    TargetInfo const &TI, DiagnosticsEngine &Diags) {
   // Extensions and equivalent feature pairs.
   static const llvm::StringMap<llvm::StringRef> FeatureExtensionMap = {
       {"cl_khr_fp64", "__opencl_c_fp64"},
Index: clang/lib/Basic/OpenMPKinds.cpp
===================================================================
--- clang/lib/Basic/OpenMPKinds.cpp
+++ clang/lib/Basic/OpenMPKinds.cpp
@@ -21,7 +21,7 @@
 using namespace llvm::omp;
 
 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, StringRef Str,
-                                          const LangOptions &LangOpts) {
+                                          LangOptions const &LangOpts) {
   switch (Kind) {
   case OMPC_default:
     return llvm::StringSwitch<unsigned>(Str)
@@ -58,7 +58,7 @@
 #define OPENMP_MAP_MODIFIER_KIND(Name)                                         \
   .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name))
 #include "clang/Basic/OpenMPKinds.def"
-        .Default(OMPC_MAP_unknown);
+                        .Default(OMPC_MAP_unknown);
     if (LangOpts.OpenMP < 51 && Type == OMPC_MAP_MODIFIER_present)
       return OMPC_MAP_MODIFIER_unknown;
     if (!LangOpts.OpenMPExtensions && Type == OMPC_MAP_MODIFIER_ompx_hold)
@@ -71,7 +71,7 @@
 #define OPENMP_MOTION_MODIFIER_KIND(Name)                                      \
   .Case(#Name, static_cast<unsigned>(OMPC_MOTION_MODIFIER_##Name))
 #include "clang/Basic/OpenMPKinds.def"
-        .Default(OMPC_MOTION_MODIFIER_unknown);
+                        .Default(OMPC_MOTION_MODIFIER_unknown);
     if (LangOpts.OpenMP < 51 && Type == OMPC_MOTION_MODIFIER_present)
       return OMPC_MOTION_MODIFIER_unknown;
     return Type;
@@ -90,8 +90,8 @@
 #include "clang/Basic/OpenMPKinds.def"
         .Default(OMPC_DEFAULTMAP_unknown);
   case OMPC_atomic_default_mem_order:
-     return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str)
-#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)       \
+    return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str)
+#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)                             \
   .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name)
 #include "clang/Basic/OpenMPKinds.def"
         .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown);
@@ -192,7 +192,7 @@
   llvm_unreachable("Invalid OpenMP simple clause kind");
 }
 
-const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
+char const *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
                                                  unsigned Type) {
   switch (Kind) {
   case OMPC_default:
@@ -217,11 +217,11 @@
     case OMPC_SCHEDULE_MODIFIER_last:
       return "unknown";
 #define OPENMP_SCHEDULE_KIND(Name)                                             \
-    case OMPC_SCHEDULE_##Name:                                                 \
-      return #Name;
+  case OMPC_SCHEDULE_##Name:                                                   \
+    return #Name;
 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
-    case OMPC_SCHEDULE_MODIFIER_##Name:                                        \
-      return #Name;
+  case OMPC_SCHEDULE_MODIFIER_##Name:                                          \
+    return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     }
     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
@@ -229,8 +229,8 @@
     switch (Type) {
     case OMPC_DEPEND_unknown:
       return "unknown";
-#define OPENMP_DEPEND_KIND(Name)                                             \
-  case OMPC_DEPEND_##Name:                                                   \
+#define OPENMP_DEPEND_KIND(Name)                                               \
+  case OMPC_DEPEND_##Name:                                                     \
     return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     }
@@ -239,8 +239,8 @@
     switch (Type) {
     case OMPC_LINEAR_unknown:
       return "unknown";
-#define OPENMP_LINEAR_KIND(Name)                                             \
-  case OMPC_LINEAR_##Name:                                                   \
+#define OPENMP_LINEAR_KIND(Name)                                               \
+  case OMPC_LINEAR_##Name:                                                     \
     return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     }
@@ -250,11 +250,11 @@
     case OMPC_MAP_unknown:
     case OMPC_MAP_MODIFIER_last:
       return "unknown";
-#define OPENMP_MAP_KIND(Name)                                                \
-  case OMPC_MAP_##Name:                                                      \
+#define OPENMP_MAP_KIND(Name)                                                  \
+  case OMPC_MAP_##Name:                                                        \
     return #Name;
-#define OPENMP_MAP_MODIFIER_KIND(Name)                                       \
-  case OMPC_MAP_MODIFIER_##Name:                                             \
+#define OPENMP_MAP_MODIFIER_KIND(Name)                                         \
+  case OMPC_MAP_MODIFIER_##Name:                                               \
     return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     default:
@@ -278,8 +278,8 @@
     switch (Type) {
     case OMPC_DIST_SCHEDULE_unknown:
       return "unknown";
-#define OPENMP_DIST_SCHEDULE_KIND(Name)                                      \
-  case OMPC_DIST_SCHEDULE_##Name:                                            \
+#define OPENMP_DIST_SCHEDULE_KIND(Name)                                        \
+  case OMPC_DIST_SCHEDULE_##Name:                                              \
     return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     }
@@ -289,12 +289,12 @@
     case OMPC_DEFAULTMAP_unknown:
     case OMPC_DEFAULTMAP_MODIFIER_last:
       return "unknown";
-#define OPENMP_DEFAULTMAP_KIND(Name)                                         \
-    case OMPC_DEFAULTMAP_##Name:                                             \
-      return #Name;
-#define OPENMP_DEFAULTMAP_MODIFIER(Name)                                     \
-    case OMPC_DEFAULTMAP_MODIFIER_##Name:                                    \
-      return #Name;
+#define OPENMP_DEFAULTMAP_KIND(Name)                                           \
+  case OMPC_DEFAULTMAP_##Name:                                                 \
+    return #Name;
+#define OPENMP_DEFAULTMAP_MODIFIER(Name)                                       \
+  case OMPC_DEFAULTMAP_MODIFIER_##Name:                                        \
+    return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     }
     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
@@ -302,19 +302,19 @@
     switch (Type) {
     case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown:
       return "unknown";
-#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)                           \
-    case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name:                               \
-      return #Name;
+#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)                             \
+  case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name:                                   \
+    return #Name;
 #include "clang/Basic/OpenMPKinds.def"
-}
+    }
     llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
   case OMPC_device_type:
     switch (Type) {
     case OMPC_DEVICE_TYPE_unknown:
       return "unknown";
 #define OPENMP_DEVICE_TYPE_KIND(Name)                                          \
-    case OMPC_DEVICE_TYPE_##Name:                                              \
-      return #Name;
+  case OMPC_DEVICE_TYPE_##Name:                                                \
+    return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     }
     llvm_unreachable("Invalid OpenMP 'device_type' clause type");
@@ -323,8 +323,8 @@
     case OMPC_LASTPRIVATE_unknown:
       return "unknown";
 #define OPENMP_LASTPRIVATE_KIND(Name)                                          \
-    case OMPC_LASTPRIVATE_##Name:                                              \
-      return #Name;
+  case OMPC_LASTPRIVATE_##Name:                                                \
+    return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     }
     llvm_unreachable("Invalid OpenMP 'lastprivate' clause type");
@@ -333,8 +333,8 @@
     case OMPC_ORDER_unknown:
       return "unknown";
 #define OPENMP_ORDER_KIND(Name)                                                \
-    case OMPC_ORDER_##Name:                                                    \
-      return #Name;
+  case OMPC_ORDER_##Name:                                                      \
+    return #Name;
 #include "clang/Basic/OpenMPKinds.def"
     }
     llvm_unreachable("Invalid OpenMP 'order' clause type");
@@ -519,8 +519,8 @@
 }
 
 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
-  return isOpenMPNestingTeamsDirective(DKind) ||
-         DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
+  return isOpenMPNestingTeamsDirective(DKind) || DKind == OMPD_target_teams ||
+         DKind == OMPD_target_teams_distribute ||
          DKind == OMPD_target_teams_distribute_parallel_for ||
          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
          DKind == OMPD_target_teams_distribute_simd;
Index: clang/lib/Basic/OperatorPrecedence.cpp
===================================================================
--- clang/lib/Basic/OperatorPrecedence.cpp
+++ clang/lib/Basic/OperatorPrecedence.cpp
@@ -37,8 +37,10 @@
       return prec::Shift;
     return prec::Unknown;
 
-  default:                        return prec::Unknown;
-  case tok::comma:                return prec::Comma;
+  default:
+    return prec::Unknown;
+  case tok::comma:
+    return prec::Comma;
   case tok::equal:
   case tok::starequal:
   case tok::slashequal:
@@ -49,29 +51,43 @@
   case tok::greatergreaterequal:
   case tok::ampequal:
   case tok::caretequal:
-  case tok::pipeequal:            return prec::Assignment;
-  case tok::question:             return prec::Conditional;
-  case tok::pipepipe:             return prec::LogicalOr;
+  case tok::pipeequal:
+    return prec::Assignment;
+  case tok::question:
+    return prec::Conditional;
+  case tok::pipepipe:
+    return prec::LogicalOr;
   case tok::caretcaret:
-  case tok::ampamp:               return prec::LogicalAnd;
-  case tok::pipe:                 return prec::InclusiveOr;
-  case tok::caret:                return prec::ExclusiveOr;
-  case tok::amp:                  return prec::And;
+  case tok::ampamp:
+    return prec::LogicalAnd;
+  case tok::pipe:
+    return prec::InclusiveOr;
+  case tok::caret:
+    return prec::ExclusiveOr;
+  case tok::amp:
+    return prec::And;
   case tok::exclaimequal:
-  case tok::equalequal:           return prec::Equality;
+  case tok::equalequal:
+    return prec::Equality;
   case tok::lessequal:
   case tok::less:
-  case tok::greaterequal:         return prec::Relational;
-  case tok::spaceship:            return prec::Spaceship;
-  case tok::lessless:             return prec::Shift;
+  case tok::greaterequal:
+    return prec::Relational;
+  case tok::spaceship:
+    return prec::Spaceship;
+  case tok::lessless:
+    return prec::Shift;
   case tok::plus:
-  case tok::minus:                return prec::Additive;
+  case tok::minus:
+    return prec::Additive;
   case tok::percent:
   case tok::slash:
-  case tok::star:                 return prec::Multiplicative;
+  case tok::star:
+    return prec::Multiplicative;
   case tok::periodstar:
-  case tok::arrowstar:            return prec::PointerToMember;
+  case tok::arrowstar:
+    return prec::PointerToMember;
   }
 }
 
-}  // namespace clang
+} // namespace clang
Index: clang/lib/Basic/ProfileList.cpp
===================================================================
--- clang/lib/Basic/ProfileList.cpp
+++ clang/lib/Basic/ProfileList.cpp
@@ -25,11 +25,11 @@
 class ProfileSpecialCaseList : public llvm::SpecialCaseList {
 public:
   static std::unique_ptr<ProfileSpecialCaseList>
-  create(const std::vector<std::string> &Paths, llvm::vfs::FileSystem &VFS,
+  create(std::vector<std::string> const &Paths, llvm::vfs::FileSystem &VFS,
          std::string &Error);
 
   static std::unique_ptr<ProfileSpecialCaseList>
-  createOrDie(const std::vector<std::string> &Paths,
+  createOrDie(std::vector<std::string> const &Paths,
               llvm::vfs::FileSystem &VFS);
 
   bool isEmpty() const { return Sections.empty(); }
@@ -43,9 +43,8 @@
 };
 
 std::unique_ptr<ProfileSpecialCaseList>
-ProfileSpecialCaseList::create(const std::vector<std::string> &Paths,
-                               llvm::vfs::FileSystem &VFS,
-                               std::string &Error) {
+ProfileSpecialCaseList::create(std::vector<std::string> const &Paths,
+                               llvm::vfs::FileSystem &VFS, std::string &Error) {
   auto PSCL = std::make_unique<ProfileSpecialCaseList>();
   if (PSCL->createInternal(Paths, VFS, Error))
     return PSCL;
@@ -53,7 +52,7 @@
 }
 
 std::unique_ptr<ProfileSpecialCaseList>
-ProfileSpecialCaseList::createOrDie(const std::vector<std::string> &Paths,
+ProfileSpecialCaseList::createOrDie(std::vector<std::string> const &Paths,
                                     llvm::vfs::FileSystem &VFS) {
   std::string Error;
   if (auto PSCL = create(Paths, VFS, Error))
@@ -61,7 +60,7 @@
   llvm::report_fatal_error(Error);
 }
 
-}
+} // namespace clang
 
 ProfileList::ProfileList(ArrayRef<std::string> Paths, SourceManager &SM)
     : SCL(ProfileSpecialCaseList::createOrDie(
Index: clang/lib/Basic/SanitizerSpecialCaseList.cpp
===================================================================
--- clang/lib/Basic/SanitizerSpecialCaseList.cpp
+++ clang/lib/Basic/SanitizerSpecialCaseList.cpp
@@ -15,7 +15,7 @@
 using namespace clang;
 
 std::unique_ptr<SanitizerSpecialCaseList>
-SanitizerSpecialCaseList::create(const std::vector<std::string> &Paths,
+SanitizerSpecialCaseList::create(std::vector<std::string> const &Paths,
                                  llvm::vfs::FileSystem &VFS,
                                  std::string &Error) {
   std::unique_ptr<clang::SanitizerSpecialCaseList> SSCL(
@@ -28,7 +28,7 @@
 }
 
 std::unique_ptr<SanitizerSpecialCaseList>
-SanitizerSpecialCaseList::createOrDie(const std::vector<std::string> &Paths,
+SanitizerSpecialCaseList::createOrDie(std::vector<std::string> const &Paths,
                                       llvm::vfs::FileSystem &VFS) {
   std::string Error;
   if (auto SSCL = create(Paths, VFS, Error))
Index: clang/lib/Basic/Sanitizers.cpp
===================================================================
--- clang/lib/Basic/Sanitizers.cpp
+++ clang/lib/Basic/Sanitizers.cpp
@@ -32,7 +32,7 @@
 #define SANITIZER_GROUP(NAME, ID, ALIAS)                                       \
   .Case(NAME, AllowGroups ? SanitizerKind::ID##Group : SanitizerMask())
 #include "clang/Basic/Sanitizers.def"
-    .Default(SanitizerMask());
+                                 .Default(SanitizerMask());
   return ParsedKind;
 }
 
@@ -60,12 +60,12 @@
 namespace clang {
 unsigned SanitizerMask::countPopulation() const {
   unsigned total = 0;
-  for (const auto &Val : maskLoToHigh)
+  for (auto const &Val : maskLoToHigh)
     total += llvm::countPopulation(Val);
   return total;
 }
 
-llvm::hash_code hash_value(const clang::SanitizerMask &Arg) {
+llvm::hash_code hash_value(clang::SanitizerMask const &Arg) {
   return Arg.hash_value();
 }
 
Index: clang/lib/Basic/SourceLocation.cpp
===================================================================
--- clang/lib/Basic/SourceLocation.cpp
+++ clang/lib/Basic/SourceLocation.cpp
@@ -55,11 +55,11 @@
 }
 
 void llvm::FoldingSetTrait<SourceLocation>::Profile(
-    const SourceLocation &X, llvm::FoldingSetNodeID &ID) {
+    SourceLocation const &X, llvm::FoldingSetNodeID &ID) {
   ID.AddInteger(X.ID);
 }
 
-void SourceLocation::print(raw_ostream &OS, const SourceManager &SM)const{
+void SourceLocation::print(raw_ostream &OS, SourceManager const &SM) const {
   if (!isValid()) {
     OS << "<invalid loc>";
     return;
@@ -73,8 +73,8 @@
       return;
     }
     // The macro expansion and spelling pos is identical for file locs.
-    OS << PLoc.getFilename() << ':' << PLoc.getLine()
-       << ':' << PLoc.getColumn();
+    OS << PLoc.getFilename() << ':' << PLoc.getLine() << ':'
+       << PLoc.getColumn();
     return;
   }
 
@@ -86,24 +86,24 @@
 }
 
 LLVM_DUMP_METHOD std::string
-SourceLocation::printToString(const SourceManager &SM) const {
+SourceLocation::printToString(SourceManager const &SM) const {
   std::string S;
   llvm::raw_string_ostream OS(S);
   print(OS, SM);
   return OS.str();
 }
 
-LLVM_DUMP_METHOD void SourceLocation::dump(const SourceManager &SM) const {
+LLVM_DUMP_METHOD void SourceLocation::dump(SourceManager const &SM) const {
   print(llvm::errs(), SM);
   llvm::errs() << '\n';
 }
 
-LLVM_DUMP_METHOD void SourceRange::dump(const SourceManager &SM) const {
+LLVM_DUMP_METHOD void SourceRange::dump(SourceManager const &SM) const {
   print(llvm::errs(), SM);
   llvm::errs() << '\n';
 }
 
-static PresumedLoc PrintDifference(raw_ostream &OS, const SourceManager &SM,
+static PresumedLoc PrintDifference(raw_ostream &OS, SourceManager const &SM,
                                    SourceLocation Loc, PresumedLoc Previous) {
   if (Loc.isFileID()) {
 
@@ -133,7 +133,7 @@
   return PrintedLoc;
 }
 
-void SourceRange::print(raw_ostream &OS, const SourceManager &SM) const {
+void SourceRange::print(raw_ostream &OS, SourceManager const &SM) const {
 
   OS << '<';
   auto PrintedLoc = PrintDifference(OS, SM, B, {});
@@ -145,7 +145,7 @@
 }
 
 LLVM_DUMP_METHOD std::string
-SourceRange::printToString(const SourceManager &SM) const {
+SourceRange::printToString(SourceManager const &SM) const {
   std::string S;
   llvm::raw_string_ostream OS(S);
   print(OS, SM);
@@ -218,7 +218,7 @@
   return SrcMgr->getColumnNumber(getFileID(), getFileOffset(), Invalid);
 }
 
-const FileEntry *FullSourceLoc::getFileEntry() const {
+FileEntry const *FullSourceLoc::getFileEntry() const {
   assert(isValid());
   return SrcMgr->getFileEntryForID(getFileID());
 }
@@ -257,7 +257,7 @@
   SourceLocation::dump(*SrcMgr);
 }
 
-const char *FullSourceLoc::getCharacterData(bool *Invalid) const {
+char const *FullSourceLoc::getCharacterData(bool *Invalid) const {
   assert(isValid());
   return SrcMgr->getCharacterData(*this, Invalid);
 }
Index: clang/lib/Basic/SourceManager.cpp
===================================================================
--- clang/lib/Basic/SourceManager.cpp
+++ clang/lib/Basic/SourceManager.cpp
@@ -77,12 +77,12 @@
                 : (unsigned)ContentsEntry->getSize();
 }
 
-const char *ContentCache::getInvalidBOM(StringRef BufStr) {
+char const *ContentCache::getInvalidBOM(StringRef BufStr) {
   // If the buffer is valid, check to see if it has a UTF Byte Order Mark
   // (BOM).  We only support UTF-8 with and without a BOM right now.  See
   // http://en.wikipedia.org/wiki/Byte_order_mark for more information.
-  const char *InvalidBOM =
-      llvm::StringSwitch<const char *>(BufStr)
+  char const *InvalidBOM =
+      llvm::StringSwitch<char const *>(BufStr)
           .StartsWith(llvm::StringLiteral::withInnerNUL("\x00\x00\xFE\xFF"),
                       "UTF-32 (BE)")
           .StartsWith(llvm::StringLiteral::withInnerNUL("\xFF\xFE\x00\x00"),
@@ -151,8 +151,7 @@
       Diag.SetDelayedDiagnostic(diag::err_file_too_large,
                                 ContentsEntry->getName());
     else
-      Diag.Report(Loc, diag::err_file_too_large)
-        << ContentsEntry->getName();
+      Diag.Report(Loc, diag::err_file_too_large) << ContentsEntry->getName();
 
     return None;
   }
@@ -166,8 +165,7 @@
       Diag.SetDelayedDiagnostic(diag::err_file_modified,
                                 ContentsEntry->getName());
     else
-      Diag.Report(Loc, diag::err_file_modified)
-        << ContentsEntry->getName();
+      Diag.Report(Loc, diag::err_file_modified) << ContentsEntry->getName();
 
     return None;
   }
@@ -176,11 +174,11 @@
   // (BOM).  We only support UTF-8 with and without a BOM right now.  See
   // http://en.wikipedia.org/wiki/Byte_order_mark for more information.
   StringRef BufStr = Buffer->getBuffer();
-  const char *InvalidBOM = getInvalidBOM(BufStr);
+  char const *InvalidBOM = getInvalidBOM(BufStr);
 
   if (InvalidBOM) {
     Diag.Report(Loc, diag::err_unsupported_bom)
-      << InvalidBOM << ContentsEntry->getName();
+        << InvalidBOM << ContentsEntry->getName();
     return None;
   }
 
@@ -216,30 +214,31 @@
          "Adding line entries out of order!");
 
   unsigned IncludeOffset = 0;
-  if (EntryExit == 0) {  // No #include stack change.
+  if (EntryExit == 0) { // No #include stack change.
     IncludeOffset = Entries.empty() ? 0 : Entries.back().IncludeOffset;
   } else if (EntryExit == 1) {
-    IncludeOffset = Offset-1;
+    IncludeOffset = Offset - 1;
   } else if (EntryExit == 2) {
     assert(!Entries.empty() && Entries.back().IncludeOffset &&
-       "PPDirectives should have caught case when popping empty include stack");
+           "PPDirectives should have caught case when popping empty include "
+           "stack");
 
     // Get the include loc of the last entries' include loc as our include loc.
     IncludeOffset = 0;
-    if (const LineEntry *PrevEntry =
-          FindNearestLineEntry(FID, Entries.back().IncludeOffset))
+    if (LineEntry const *PrevEntry =
+            FindNearestLineEntry(FID, Entries.back().IncludeOffset))
       IncludeOffset = PrevEntry->IncludeOffset;
   }
 
-  Entries.push_back(LineEntry::get(Offset, LineNo, FilenameID, FileKind,
-                                   IncludeOffset));
+  Entries.push_back(
+      LineEntry::get(Offset, LineNo, FilenameID, FileKind, IncludeOffset));
 }
 
 /// FindNearestLineEntry - Find the line entry nearest to FID that is before
 /// it.  If there is no line entry before Offset in FID, return null.
-const LineEntry *LineTableInfo::FindNearestLineEntry(FileID FID,
+LineEntry const *LineTableInfo::FindNearestLineEntry(FileID FID,
                                                      unsigned Offset) {
-  const std::vector<LineEntry> &Entries = LineEntries[FID];
+  std::vector<LineEntry> const &Entries = LineEntries[FID];
   assert(!Entries.empty() && "No #line entries for this FID after all!");
 
   // It is very common for the query to be after the last #line, check this
@@ -257,7 +256,7 @@
 /// Add a new line entry that has already been encoded into
 /// the internal representation of the line table.
 void LineTableInfo::AddEntry(FileID FID,
-                             const std::vector<LineEntry> &Entries) {
+                             std::vector<LineEntry> const &Entries) {
   LineEntries[FID] = Entries;
 }
 
@@ -276,16 +275,16 @@
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
 
   bool Invalid = false;
-  const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
+  SLocEntry const &Entry = getSLocEntry(LocInfo.first, &Invalid);
   if (!Entry.isFile() || Invalid)
     return;
 
-  const SrcMgr::FileInfo &FileInfo = Entry.getFile();
+  SrcMgr::FileInfo const &FileInfo = Entry.getFile();
 
   // Remember that this file has #line directives now if it doesn't already.
-  const_cast<SrcMgr::FileInfo&>(FileInfo).setHasLineDirectives();
+  const_cast<SrcMgr::FileInfo &>(FileInfo).setHasLineDirectives();
 
-  (void) getLineTable();
+  (void)getLineTable();
 
   unsigned EntryExit = 0;
   if (IsFileEntry)
@@ -309,7 +308,7 @@
 
 SourceManager::SourceManager(DiagnosticsEngine &Diag, FileManager &FileMgr,
                              bool UserFilesAreVolatile)
-  : Diag(Diag), FileMgr(FileMgr), UserFilesAreVolatile(UserFilesAreVolatile) {
+    : Diag(Diag), FileMgr(FileMgr), UserFilesAreVolatile(UserFilesAreVolatile) {
   clearIDTables();
   Diag.setSourceManager(this);
 }
@@ -324,8 +323,10 @@
       ContentCacheAlloc.Deallocate(MemBufferInfos[i]);
     }
   }
-  for (llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*>::iterator
-       I = FileInfos.begin(), E = FileInfos.end(); I != E; ++I) {
+  for (llvm::DenseMap<FileEntry const *, SrcMgr::ContentCache *>::iterator
+           I = FileInfos.begin(),
+           E = FileInfos.end();
+       I != E; ++I) {
     if (I->second) {
       I->second->~ContentCache();
       ContentCacheAlloc.Deallocate(I->second);
@@ -351,17 +352,17 @@
   createExpansionLoc(SourceLocation(), SourceLocation(), SourceLocation(), 1);
 }
 
-bool SourceManager::isMainFile(const FileEntry &SourceFile) {
+bool SourceManager::isMainFile(FileEntry const &SourceFile) {
   assert(MainFileID.isValid() && "expected initialized SourceManager");
   if (auto *FE = getFileEntryForID(MainFileID))
     return FE->getUID() == SourceFile.getUID();
   return false;
 }
 
-void SourceManager::initializeForReplay(const SourceManager &Old) {
+void SourceManager::initializeForReplay(SourceManager const &Old) {
   assert(MainFileID.isInvalid() && "expected uninitialized SourceManager");
 
-  auto CloneContentCache = [&](const ContentCache *Cache) -> ContentCache * {
+  auto CloneContentCache = [&](ContentCache const *Cache) -> ContentCache * {
     auto *Clone = new (ContentCacheAlloc.Allocate<ContentCache>()) ContentCache;
     Clone->OrigEntry = Cache->OrigEntry;
     Clone->ContentsEntry = Cache->ContentsEntry;
@@ -399,14 +400,14 @@
   if (OverriddenFilesInfo) {
     // If the file contents are overridden with contents from another file,
     // pass that file to ContentCache.
-    llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
-        overI = OverriddenFilesInfo->OverriddenFiles.find(FileEnt);
+    llvm::DenseMap<FileEntry const *, FileEntry const *>::iterator overI =
+        OverriddenFilesInfo->OverriddenFiles.find(FileEnt);
     if (overI == OverriddenFilesInfo->OverriddenFiles.end())
       new (Entry) ContentCache(FileEnt);
     else
-      new (Entry) ContentCache(OverridenFilesKeepOriginalName ? FileEnt
-                                                              : overI->second,
-                               overI->second);
+      new (Entry)
+          ContentCache(OverridenFilesKeepOriginalName ? FileEnt : overI->second,
+                       overI->second);
   } else {
     new (Entry) ContentCache(FileEnt);
   }
@@ -430,7 +431,7 @@
   return *Entry;
 }
 
-const SrcMgr::SLocEntry &SourceManager::loadSLocEntry(unsigned Index,
+SrcMgr::SLocEntry const &SourceManager::loadSLocEntry(unsigned Index,
                                                       bool *Invalid) const {
   assert(!SLocEntryLoaded[Index]);
   if (ExternalSLocEntries->ReadSLocEntry(-(static_cast<int>(Index) + 2))) {
@@ -495,13 +496,13 @@
     return FileID();
 
   if (ID > 0) {
-    if (ID-1 == 0)
+    if (ID - 1 == 0)
       return FileID();
-  } else if (unsigned(-(ID-1) - 2) >= LoadedSLocEntryTable.size()) {
+  } else if (unsigned(-(ID - 1) - 2) >= LoadedSLocEntryTable.size()) {
     return FileID();
   }
 
-  return FileID::get(ID-1);
+  return FileID::get(ID - 1);
 }
 
 /// Returns the next in-order FileID or an invalid FileID if there is
@@ -512,13 +513,13 @@
 
   int ID = FID.ID;
   if (ID > 0) {
-    if (unsigned(ID+1) >= local_sloc_entry_size())
+    if (unsigned(ID + 1) >= local_sloc_entry_size())
       return FileID();
-  } else if (ID+1 >= -1) {
+  } else if (ID + 1 >= -1) {
     return FileID();
   }
 
-  return FileID::get(ID+1);
+  return FileID::get(ID + 1);
 }
 
 //===----------------------------------------------------------------------===//
@@ -529,7 +530,7 @@
 /// being \#included from the specified IncludePosition.
 ///
 /// This translates NULL into standard input.
-FileID SourceManager::createFileID(const FileEntry *SourceFile,
+FileID SourceManager::createFileID(FileEntry const *SourceFile,
                                    SourceLocation IncludePos,
                                    SrcMgr::CharacteristicKind FileCharacter,
                                    int LoadedID,
@@ -543,8 +544,8 @@
                                    SrcMgr::CharacteristicKind FileCharacter,
                                    int LoadedID,
                                    SourceLocation::UIntTy LoadedOffset) {
-  SrcMgr::ContentCache &IR = getOrCreateContentCache(SourceFile,
-                                                     isSystem(FileCharacter));
+  SrcMgr::ContentCache &IR =
+      getOrCreateContentCache(SourceFile, isSystem(FileCharacter));
 
   // If this is a named pipe, immediately load the buffer to ensure subsequent
   // calls to ContentCache::getSize() are accurate.
@@ -573,7 +574,7 @@
 ///
 /// This does not take ownership of the MemoryBuffer. The memory buffer must
 /// outlive the SourceManager.
-FileID SourceManager::createFileID(const llvm::MemoryBufferRef &Buffer,
+FileID SourceManager::createFileID(llvm::MemoryBufferRef const &Buffer,
                                    SrcMgr::CharacteristicKind FileCharacter,
                                    int LoadedID,
                                    SourceLocation::UIntTy LoadedOffset,
@@ -585,11 +586,12 @@
 /// Get the FileID for \p SourceFile if it exists. Otherwise, create a
 /// new FileID for the \p SourceFile.
 FileID
-SourceManager::getOrCreateFileID(const FileEntry *SourceFile,
+SourceManager::getOrCreateFileID(FileEntry const *SourceFile,
                                  SrcMgr::CharacteristicKind FileCharacter) {
   FileID ID = translateFile(SourceFile);
-  return ID.isValid() ? ID : createFileID(SourceFile, SourceLocation(),
-					  FileCharacter);
+  return ID.isValid()
+             ? ID
+             : createFileID(SourceFile, SourceLocation(), FileCharacter);
 }
 
 /// createFileID - Create a new FileID for the specified ContentCache and
@@ -625,7 +627,7 @@
 
   // Set LastFileIDLookup to the newly created file.  The next getFileID call is
   // almost guaranteed to be from that file.
-  FileID FID = FileID::get(LocalSLocEntryTable.size()-1);
+  FileID FID = FileID::get(LocalSLocEntryTable.size() - 1);
   return LastFileIDLookup = FID;
 }
 
@@ -633,8 +635,8 @@
 SourceManager::createMacroArgExpansionLoc(SourceLocation SpellingLoc,
                                           SourceLocation ExpansionLoc,
                                           unsigned TokLength) {
-  ExpansionInfo Info = ExpansionInfo::createForMacroArg(SpellingLoc,
-                                                        ExpansionLoc);
+  ExpansionInfo Info =
+      ExpansionInfo::createForMacroArg(SpellingLoc, ExpansionLoc);
   return createExpansionLocImpl(Info, TokLength);
 }
 
@@ -659,7 +661,7 @@
 }
 
 SourceLocation
-SourceManager::createExpansionLocImpl(const ExpansionInfo &Info,
+SourceManager::createExpansionLocImpl(ExpansionInfo const &Info,
                                       unsigned TokLength, int LoadedID,
                                       SourceLocation::UIntTy LoadedOffset) {
   if (LoadedID < 0) {
@@ -681,13 +683,13 @@
 }
 
 llvm::Optional<llvm::MemoryBufferRef>
-SourceManager::getMemoryBufferForFileOrNone(const FileEntry *File) {
+SourceManager::getMemoryBufferForFileOrNone(FileEntry const *File) {
   SrcMgr::ContentCache &IR = getOrCreateContentCache(File->getLastRef());
   return IR.getBufferOrNone(Diag, getFileManager(), SourceLocation());
 }
 
 void SourceManager::overrideFileContents(
-    const FileEntry *SourceFile, std::unique_ptr<llvm::MemoryBuffer> Buffer) {
+    FileEntry const *SourceFile, std::unique_ptr<llvm::MemoryBuffer> Buffer) {
   SrcMgr::ContentCache &IR = getOrCreateContentCache(SourceFile->getLastRef());
 
   IR.setBuffer(std::move(Buffer));
@@ -696,8 +698,8 @@
   getOverriddenFilesInfo().OverriddenFilesWithBuffer.insert(SourceFile);
 }
 
-void SourceManager::overrideFileContents(const FileEntry *SourceFile,
-                                         const FileEntry *NewFile) {
+void SourceManager::overrideFileContents(FileEntry const *SourceFile,
+                                         FileEntry const *NewFile) {
   assert(SourceFile->getSize() == NewFile->getSize() &&
          "Different sizes, use the FileManager to create a virtual file with "
          "the correct size");
@@ -720,13 +722,13 @@
   return BypassFile;
 }
 
-void SourceManager::setFileIsTransient(const FileEntry *File) {
+void SourceManager::setFileIsTransient(FileEntry const *File) {
   getOrCreateContentCache(File->getLastRef()).IsTransient = true;
 }
 
 Optional<StringRef>
 SourceManager::getNonBuiltinFilenameForID(FileID FID) const {
-  if (const SrcMgr::SLocEntry *Entry = getSLocEntryForFile(FID))
+  if (SrcMgr::SLocEntry const *Entry = getSLocEntryForFile(FID))
     if (Entry->getFile().getContentCache().OrigEntry)
       return Entry->getFile().getName();
   return None;
@@ -741,13 +743,13 @@
 
 llvm::Optional<StringRef>
 SourceManager::getBufferDataIfLoaded(FileID FID) const {
-  if (const SrcMgr::SLocEntry *Entry = getSLocEntryForFile(FID))
+  if (SrcMgr::SLocEntry const *Entry = getSLocEntryForFile(FID))
     return Entry->getFile().getContentCache().getBufferDataIfLoaded();
   return None;
 }
 
 llvm::Optional<StringRef> SourceManager::getBufferDataOrNone(FileID FID) const {
-  if (const SrcMgr::SLocEntry *Entry = getSLocEntryForFile(FID))
+  if (SrcMgr::SLocEntry const *Entry = getSLocEntryForFile(FID))
     if (auto B = Entry->getFile().getContentCache().getBufferOrNone(
             Diag, getFileManager(), SourceLocation()))
       return B->getBuffer();
@@ -792,7 +794,7 @@
 
   // See if this is near the file point - worst case we start scanning from the
   // most newly created FileID.
-  const SrcMgr::SLocEntry *I;
+  SrcMgr::SLocEntry const *I;
 
   if (LastFileIDLookup.ID < 0 ||
       LocalSLocEntryTable[LastFileIDLookup.ID].getOffset() < SLocOffset) {
@@ -800,7 +802,7 @@
     I = LocalSLocEntryTable.end();
   } else {
     // Perhaps it is near the file point.
-    I = LocalSLocEntryTable.begin()+LastFileIDLookup.ID;
+    I = LocalSLocEntryTable.begin() + LastFileIDLookup.ID;
   }
 
   // Find the FileID that contains this.  "I" is an iterator that points to a
@@ -812,7 +814,7 @@
       FileID Res = FileID::get(int(I - LocalSLocEntryTable.begin()));
       // Remember it.  We have good locality across FileID lookups.
       LastFileIDLookup = Res;
-      NumLinearScans += NumProbes+1;
+      NumLinearScans += NumProbes + 1;
       return Res;
     }
     if (++NumProbes == 8)
@@ -828,7 +830,7 @@
   unsigned LessIndex = 0;
   NumProbes = 0;
   while (true) {
-    unsigned MiddleIndex = (GreaterIndex-LessIndex)/2+LessIndex;
+    unsigned MiddleIndex = (GreaterIndex - LessIndex) / 2 + LessIndex;
     SourceLocation::UIntTy MidOffset =
         getLocalSLocEntry(MiddleIndex).getOffset();
 
@@ -882,7 +884,7 @@
   unsigned NumProbes;
   for (NumProbes = 0; NumProbes < 8; ++NumProbes, ++I) {
     // Make sure the entry is loaded!
-    const SrcMgr::SLocEntry &E = getLoadedSLocEntry(I);
+    SrcMgr::SLocEntry const &E = getLoadedSLocEntry(I);
     if (E.getOffset() <= SLocOffset) {
       FileID Res = FileID::get(-int(I) - 2);
       LastFileIDLookup = Res;
@@ -900,7 +902,7 @@
   while (true) {
     ++NumProbes;
     unsigned MiddleIndex = (LessIndex - GreaterIndex) / 2 + GreaterIndex;
-    const SrcMgr::SLocEntry &E = getLoadedSLocEntry(MiddleIndex);
+    SrcMgr::SLocEntry const &E = getLoadedSLocEntry(MiddleIndex);
     if (E.getOffset() == 0)
       return FileID(); // invalid entry.
 
@@ -932,8 +934,8 @@
   }
 }
 
-SourceLocation SourceManager::
-getExpansionLocSlowCase(SourceLocation Loc) const {
+SourceLocation
+SourceManager::getExpansionLocSlowCase(SourceLocation Loc) const {
   do {
     // Note: If Loc indicates an offset into a token that came from a macro
     // expansion (e.g. the 5th character of the token) we do not want to add
@@ -966,10 +968,8 @@
   return Loc;
 }
 
-
-std::pair<FileID, unsigned>
-SourceManager::getDecomposedExpansionLocSlowCase(
-                                             const SrcMgr::SLocEntry *E) const {
+std::pair<FileID, unsigned> SourceManager::getDecomposedExpansionLocSlowCase(
+    SrcMgr::SLocEntry const *E) const {
   // If this is an expansion record, walk through all the expansion points.
   FileID FID;
   SourceLocation Loc;
@@ -979,14 +979,14 @@
 
     FID = getFileID(Loc);
     E = &getSLocEntry(FID);
-    Offset = Loc.getOffset()-E->getOffset();
+    Offset = Loc.getOffset() - E->getOffset();
   } while (!Loc.isFileID());
 
   return std::make_pair(FID, Offset);
 }
 
 std::pair<FileID, unsigned>
-SourceManager::getDecomposedSpellingLocSlowCase(const SrcMgr::SLocEntry *E,
+SourceManager::getDecomposedSpellingLocSlowCase(SrcMgr::SLocEntry const *E,
                                                 unsigned Offset) const {
   // If this is an expansion record, walk through all the expansion points.
   FileID FID;
@@ -997,7 +997,7 @@
 
     FID = getFileID(Loc);
     E = &getSLocEntry(FID);
-    Offset = Loc.getOffset()-E->getOffset();
+    Offset = Loc.getOffset() - E->getOffset();
   } while (!Loc.isFileID());
 
   return std::make_pair(FID, Offset);
@@ -1007,8 +1007,10 @@
 /// spelling location referenced by the ID.  This is the first level down
 /// towards the place where the characters that make up the lexed token can be
 /// found.  This should not generally be used by clients.
-SourceLocation SourceManager::getImmediateSpellingLoc(SourceLocation Loc) const{
-  if (Loc.isFileID()) return Loc;
+SourceLocation
+SourceManager::getImmediateSpellingLoc(SourceLocation Loc) const {
+  if (Loc.isFileID())
+    return Loc;
   std::pair<FileID, unsigned> LocInfo = getDecomposedLoc(Loc);
   Loc = getSLocEntry(LocInfo.first).getExpansion().getSpellingLoc();
   return Loc.getLocWithOffset(LocInfo.second);
@@ -1016,7 +1018,7 @@
 
 /// Return the filename of the file containing a SourceLocation.
 StringRef SourceManager::getFilename(SourceLocation SpellingLoc) const {
-  if (const FileEntry *F = getFileEntryForID(getFileID(SpellingLoc)))
+  if (FileEntry const *F = getFileEntryForID(getFileID(SpellingLoc)))
     return F->getName();
   return StringRef();
 }
@@ -1026,7 +1028,7 @@
 CharSourceRange
 SourceManager::getImmediateExpansionRange(SourceLocation Loc) const {
   assert(Loc.isMacroID() && "Not a macro expansion loc!");
-  const ExpansionInfo &Expansion = getSLocEntry(getFileID(Loc)).getExpansion();
+  ExpansionInfo const &Expansion = getSLocEntry(getFileID(Loc)).getExpansion();
   return Expansion.getExpansionLocRange();
 }
 
@@ -1058,11 +1060,13 @@
 
 bool SourceManager::isMacroArgExpansion(SourceLocation Loc,
                                         SourceLocation *StartLoc) const {
-  if (!Loc.isMacroID()) return false;
+  if (!Loc.isMacroID())
+    return false;
 
   FileID FID = getFileID(Loc);
-  const SrcMgr::ExpansionInfo &Expansion = getSLocEntry(FID).getExpansion();
-  if (!Expansion.isMacroArgExpansion()) return false;
+  SrcMgr::ExpansionInfo const &Expansion = getSLocEntry(FID).getExpansion();
+  if (!Expansion.isMacroArgExpansion())
+    return false;
 
   if (StartLoc)
     *StartLoc = Expansion.getExpansionLocStart();
@@ -1070,15 +1074,16 @@
 }
 
 bool SourceManager::isMacroBodyExpansion(SourceLocation Loc) const {
-  if (!Loc.isMacroID()) return false;
+  if (!Loc.isMacroID())
+    return false;
 
   FileID FID = getFileID(Loc);
-  const SrcMgr::ExpansionInfo &Expansion = getSLocEntry(FID).getExpansion();
+  SrcMgr::ExpansionInfo const &Expansion = getSLocEntry(FID).getExpansion();
   return Expansion.isMacroBodyExpansion();
 }
 
-bool SourceManager::isAtStartOfImmediateMacroExpansion(SourceLocation Loc,
-                                             SourceLocation *MacroBegin) const {
+bool SourceManager::isAtStartOfImmediateMacroExpansion(
+    SourceLocation Loc, SourceLocation *MacroBegin) const {
   assert(Loc.isValid() && Loc.isMacroID() && "Expected a valid macro loc");
 
   std::pair<FileID, unsigned> DecompLoc = getDecomposedLoc(Loc);
@@ -1086,7 +1091,7 @@
     return false; // Does not point at the start of expansion range.
 
   bool Invalid = false;
-  const SrcMgr::ExpansionInfo &ExpInfo =
+  SrcMgr::ExpansionInfo const &ExpInfo =
       getSLocEntry(DecompLoc.first, &Invalid).getExpansion();
   if (Invalid)
     return false;
@@ -1098,7 +1103,7 @@
     // beginning of the expansion.
     FileID PrevFID = getPreviousFileID(DecompLoc.first);
     if (!PrevFID.isInvalid()) {
-      const SrcMgr::SLocEntry &PrevEntry = getSLocEntry(PrevFID, &Invalid);
+      SrcMgr::SLocEntry const &PrevEntry = getSLocEntry(PrevFID, &Invalid);
       if (Invalid)
         return false;
       if (PrevEntry.isExpansion() &&
@@ -1112,8 +1117,8 @@
   return true;
 }
 
-bool SourceManager::isAtEndOfImmediateMacroExpansion(SourceLocation Loc,
-                                               SourceLocation *MacroEnd) const {
+bool SourceManager::isAtEndOfImmediateMacroExpansion(
+    SourceLocation Loc, SourceLocation *MacroEnd) const {
   assert(Loc.isValid() && Loc.isMacroID() && "Expected a valid macro loc");
 
   FileID FID = getFileID(Loc);
@@ -1122,7 +1127,7 @@
     return false; // Does not point at the end of expansion range.
 
   bool Invalid = false;
-  const SrcMgr::ExpansionInfo &ExpInfo =
+  SrcMgr::ExpansionInfo const &ExpInfo =
       getSLocEntry(FID, &Invalid).getExpansion();
   if (Invalid)
     return false;
@@ -1133,7 +1138,7 @@
     // expansion.
     FileID NextFID = getNextFileID(FID);
     if (!NextFID.isInvalid()) {
-      const SrcMgr::SLocEntry &NextEntry = getSLocEntry(NextFID, &Invalid);
+      SrcMgr::SLocEntry const &NextEntry = getSLocEntry(NextFID, &Invalid);
       if (Invalid)
         return false;
       if (NextEntry.isExpansion() &&
@@ -1154,7 +1159,7 @@
 
 /// getCharacterData - Return a pointer to the start of the specified location
 /// in the appropriate MemoryBuffer.
-const char *SourceManager::getCharacterData(SourceLocation SL,
+char const *SourceManager::getCharacterData(SourceLocation SL,
                                             bool *Invalid) const {
   // Note that this is a hot function in the getSpelling() path, which is
   // heavily used by -E mode.
@@ -1162,7 +1167,7 @@
 
   // Note that calling 'getBuffer()' may lazily page in a source file.
   bool CharDataInvalid = false;
-  const SLocEntry &Entry = getSLocEntry(LocInfo.first, &CharDataInvalid);
+  SLocEntry const &Entry = getSLocEntry(LocInfo.first, &CharDataInvalid);
   if (CharDataInvalid || !Entry.isFile()) {
     if (Invalid)
       *Invalid = true;
@@ -1196,12 +1201,12 @@
     return 1;
   }
 
-  const char *Buf = MemBuf->getBufferStart();
+  char const *Buf = MemBuf->getBufferStart();
   // See if we just calculated the line number for this FilePos and can use
   // that to lookup the start of the line instead of searching for it.
   if (LastLineNoFileIDQuery == FID && LastLineNoContentCache->SourceLineCache &&
       LastLineNoResult < LastLineNoContentCache->SourceLineCache.size()) {
-    const unsigned *SourceLineCache =
+    unsigned const *SourceLineCache =
         LastLineNoContentCache->SourceLineCache.begin();
     unsigned LineStart = SourceLineCache[LastLineNoResult - 1];
     unsigned LineEnd = SourceLineCache[LastLineNoResult];
@@ -1219,15 +1224,14 @@
   }
 
   unsigned LineStart = FilePos;
-  while (LineStart && Buf[LineStart-1] != '\n' && Buf[LineStart-1] != '\r')
+  while (LineStart && Buf[LineStart - 1] != '\n' && Buf[LineStart - 1] != '\r')
     --LineStart;
-  return FilePos-LineStart+1;
+  return FilePos - LineStart + 1;
 }
 
 // isInvalid - Return the result of calling loc.isInvalid(), and
 // if Invalid is not null, set its value to same.
-template<typename LocType>
-static bool isInvalid(LocType Loc, bool *Invalid) {
+template <typename LocType> static bool isInvalid(LocType Loc, bool *Invalid) {
   bool MyInvalid = Loc.isInvalid();
   if (Invalid)
     *Invalid = MyInvalid;
@@ -1236,14 +1240,16 @@
 
 unsigned SourceManager::getSpellingColumnNumber(SourceLocation Loc,
                                                 bool *Invalid) const {
-  if (isInvalid(Loc, Invalid)) return 0;
+  if (isInvalid(Loc, Invalid))
+    return 0;
   std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(Loc);
   return getColumnNumber(LocInfo.first, LocInfo.second, Invalid);
 }
 
 unsigned SourceManager::getExpansionColumnNumber(SourceLocation Loc,
                                                  bool *Invalid) const {
-  if (isInvalid(Loc, Invalid)) return 0;
+  if (isInvalid(Loc, Invalid))
+    return 0;
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
   return getColumnNumber(LocInfo.first, LocInfo.second, Invalid);
 }
@@ -1251,7 +1257,8 @@
 unsigned SourceManager::getPresumedColumnNumber(SourceLocation Loc,
                                                 bool *Invalid) const {
   PresumedLoc PLoc = getPresumedLoc(Loc);
-  if (isInvalid(PLoc, Invalid)) return 0;
+  if (isInvalid(PLoc, Invalid))
+    return 0;
   return PLoc.getColumn();
 }
 
@@ -1260,7 +1267,7 @@
 // The returned value holds a 0x80 at each byte position that holds a match.
 // see http://graphics.stanford.edu/~seander/bithacks.html#HasBetweenInWord
 template <class T>
-static constexpr inline T likelyhasbetween(T x, unsigned char m,
+inline static constexpr T likelyhasbetween(T x, unsigned char m,
                                            unsigned char n) {
   return ((x - ~static_cast<T>(0) / 255 * (n + 1)) & ~x &
           ((x & ~static_cast<T>(0) / 255 * 127) +
@@ -1278,8 +1285,8 @@
   // Line #1 starts at char 0.
   LineOffsets.push_back(0);
 
-  const unsigned char *Buf = (const unsigned char *)Buffer.getBufferStart();
-  const unsigned char *End = (const unsigned char *)Buffer.getBufferEnd();
+  unsigned char const *Buf = (unsigned char const *)Buffer.getBufferStart();
+  unsigned char const *End = (unsigned char const *)Buffer.getBufferEnd();
   const std::size_t BufLen = End - Buf;
 
   unsigned I = 0;
@@ -1352,12 +1359,12 @@
     return 1;
   }
 
-  const ContentCache *Content;
+  ContentCache const *Content;
   if (LastLineNoFileIDQuery == FID)
     Content = LastLineNoContentCache;
   else {
     bool MyInvalid = false;
-    const SLocEntry &Entry = getSLocEntry(FID, &MyInvalid);
+    SLocEntry const &Entry = getSLocEntry(FID, &MyInvalid);
     if (MyInvalid || !Entry.isFile()) {
       if (Invalid)
         *Invalid = true;
@@ -1384,11 +1391,11 @@
 
   // Okay, we know we have a line number table.  Do a binary search to find the
   // line number that this character position lands on.
-  const unsigned *SourceLineCache = Content->SourceLineCache.begin();
-  const unsigned *SourceLineCacheStart = SourceLineCache;
-  const unsigned *SourceLineCacheEnd = Content->SourceLineCache.end();
+  unsigned const *SourceLineCache = Content->SourceLineCache.begin();
+  unsigned const *SourceLineCacheStart = SourceLineCache;
+  unsigned const *SourceLineCacheEnd = Content->SourceLineCache.end();
 
-  unsigned QueriedFilePos = FilePos+1;
+  unsigned QueriedFilePos = FilePos + 1;
 
   // FIXME: I would like to be convinced that this code is worth being as
   // complicated as it is, binary search isn't that slow.
@@ -1406,33 +1413,33 @@
   if (LastLineNoFileIDQuery == FID) {
     if (QueriedFilePos >= LastLineNoFilePos) {
       // FIXME: Potential overflow?
-      SourceLineCache = SourceLineCache+LastLineNoResult-1;
+      SourceLineCache = SourceLineCache + LastLineNoResult - 1;
 
       // The query is likely to be nearby the previous one.  Here we check to
       // see if it is within 5, 10 or 20 lines.  It can be far away in cases
       // where big comment blocks and vertical whitespace eat up lines but
       // contribute no tokens.
-      if (SourceLineCache+5 < SourceLineCacheEnd) {
+      if (SourceLineCache + 5 < SourceLineCacheEnd) {
         if (SourceLineCache[5] > QueriedFilePos)
-          SourceLineCacheEnd = SourceLineCache+5;
-        else if (SourceLineCache+10 < SourceLineCacheEnd) {
+          SourceLineCacheEnd = SourceLineCache + 5;
+        else if (SourceLineCache + 10 < SourceLineCacheEnd) {
           if (SourceLineCache[10] > QueriedFilePos)
-            SourceLineCacheEnd = SourceLineCache+10;
-          else if (SourceLineCache+20 < SourceLineCacheEnd) {
+            SourceLineCacheEnd = SourceLineCache + 10;
+          else if (SourceLineCache + 20 < SourceLineCacheEnd) {
             if (SourceLineCache[20] > QueriedFilePos)
-              SourceLineCacheEnd = SourceLineCache+20;
+              SourceLineCacheEnd = SourceLineCache + 20;
           }
         }
       }
     } else {
       if (LastLineNoResult < Content->SourceLineCache.size())
-        SourceLineCacheEnd = SourceLineCache+LastLineNoResult+1;
+        SourceLineCacheEnd = SourceLineCache + LastLineNoResult + 1;
     }
   }
 
-  const unsigned *Pos =
+  unsigned const *Pos =
       std::lower_bound(SourceLineCache, SourceLineCacheEnd, QueriedFilePos);
-  unsigned LineNo = Pos-SourceLineCacheStart;
+  unsigned LineNo = Pos - SourceLineCacheStart;
 
   LastLineNoFileIDQuery = FID;
   LastLineNoContentCache = Content;
@@ -1443,20 +1450,23 @@
 
 unsigned SourceManager::getSpellingLineNumber(SourceLocation Loc,
                                               bool *Invalid) const {
-  if (isInvalid(Loc, Invalid)) return 0;
+  if (isInvalid(Loc, Invalid))
+    return 0;
   std::pair<FileID, unsigned> LocInfo = getDecomposedSpellingLoc(Loc);
   return getLineNumber(LocInfo.first, LocInfo.second);
 }
 unsigned SourceManager::getExpansionLineNumber(SourceLocation Loc,
                                                bool *Invalid) const {
-  if (isInvalid(Loc, Invalid)) return 0;
+  if (isInvalid(Loc, Invalid))
+    return 0;
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
   return getLineNumber(LocInfo.first, LocInfo.second);
 }
 unsigned SourceManager::getPresumedLineNumber(SourceLocation Loc,
                                               bool *Invalid) const {
   PresumedLoc PLoc = getPresumedLoc(Loc);
-  if (isInvalid(PLoc, Invalid)) return 0;
+  if (isInvalid(PLoc, Invalid))
+    return 0;
   return PLoc.getLine();
 }
 
@@ -1472,11 +1482,11 @@
 SourceManager::getFileCharacteristic(SourceLocation Loc) const {
   assert(Loc.isValid() && "Can't get file characteristic of invalid loc!");
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
-  const SLocEntry *SEntry = getSLocEntryForFile(LocInfo.first);
+  SLocEntry const *SEntry = getSLocEntryForFile(LocInfo.first);
   if (!SEntry)
     return C_User;
 
-  const SrcMgr::FileInfo &FI = SEntry->getFile();
+  SrcMgr::FileInfo const &FI = SEntry->getFile();
 
   // If there are no #line directives in this file, just return the whole-file
   // state.
@@ -1485,8 +1495,8 @@
 
   assert(LineTable && "Can't have linetable entries without a LineTable!");
   // See if there is a #line directive before the location.
-  const LineEntry *Entry =
-    LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second);
+  LineEntry const *Entry =
+      LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second);
 
   // If this is before the first line marker, use the file characteristic.
   if (!Entry)
@@ -1500,7 +1510,8 @@
 /// for normal clients.
 StringRef SourceManager::getBufferName(SourceLocation Loc,
                                        bool *Invalid) const {
-  if (isInvalid(Loc, Invalid)) return "<invalid loc>";
+  if (isInvalid(Loc, Invalid))
+    return "<invalid loc>";
 
   auto B = getBufferOrNone(getFileID(Loc));
   if (Invalid)
@@ -1517,18 +1528,19 @@
 /// expansion location, not at the spelling location.
 PresumedLoc SourceManager::getPresumedLoc(SourceLocation Loc,
                                           bool UseLineDirectives) const {
-  if (Loc.isInvalid()) return PresumedLoc();
+  if (Loc.isInvalid())
+    return PresumedLoc();
 
   // Presumed locations are always for expansion points.
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
 
   bool Invalid = false;
-  const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
+  SLocEntry const &Entry = getSLocEntry(LocInfo.first, &Invalid);
   if (Invalid || !Entry.isFile())
     return PresumedLoc();
 
-  const SrcMgr::FileInfo &FI = Entry.getFile();
-  const SrcMgr::ContentCache *C = &FI.getContentCache();
+  SrcMgr::FileInfo const &FI = Entry.getFile();
+  SrcMgr::ContentCache const *C = &FI.getContentCache();
 
   // To get the source name, first consult the FileEntry (if one exists)
   // before the MemBuffer as this will avoid unnecessarily paging in the
@@ -1543,7 +1555,7 @@
   unsigned LineNo = getLineNumber(LocInfo.first, LocInfo.second, &Invalid);
   if (Invalid)
     return PresumedLoc();
-  unsigned ColNo  = getColumnNumber(LocInfo.first, LocInfo.second, &Invalid);
+  unsigned ColNo = getColumnNumber(LocInfo.first, LocInfo.second, &Invalid);
   if (Invalid)
     return PresumedLoc();
 
@@ -1554,8 +1566,8 @@
   if (UseLineDirectives && FI.hasLineDirectives()) {
     assert(LineTable && "Can't have linetable entries without a LineTable!");
     // See if there is a #line directive before this.  If so, get it.
-    if (const LineEntry *Entry =
-          LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second)) {
+    if (LineEntry const *Entry =
+            LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second)) {
       // If the LineEntry indicates a filename, use it.
       if (Entry->FilenameID != -1) {
         Filename = LineTable->getFilename(Entry->FilenameID);
@@ -1569,7 +1581,7 @@
       // physical line numbers from the query point and the line marker to the
       // total.
       unsigned MarkerLineNo = getLineNumber(LocInfo.first, Entry->FileOffset);
-      LineNo = Entry->LineNo + (LineNo-MarkerLineNo-1);
+      LineNo = Entry->LineNo + (LineNo - MarkerLineNo - 1);
 
       // Note that column numbers are not molested by line markers.
 
@@ -1592,20 +1604,21 @@
 /// from isWrittenInMainFile() because it takes line marker directives into
 /// account.
 bool SourceManager::isInMainFile(SourceLocation Loc) const {
-  if (Loc.isInvalid()) return false;
+  if (Loc.isInvalid())
+    return false;
 
   // Presumed locations are always for expansion points.
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
 
-  const SLocEntry *Entry = getSLocEntryForFile(LocInfo.first);
+  SLocEntry const *Entry = getSLocEntryForFile(LocInfo.first);
   if (!Entry)
     return false;
 
-  const SrcMgr::FileInfo &FI = Entry->getFile();
+  SrcMgr::FileInfo const &FI = Entry->getFile();
 
   // Check if there is a line directive for this location.
   if (FI.hasLineDirectives())
-    if (const LineEntry *Entry =
+    if (LineEntry const *Entry =
             LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second))
       if (Entry->IncludeOffset)
         return false;
@@ -1616,18 +1629,18 @@
 /// The size of the SLocEntry that \p FID represents.
 unsigned SourceManager::getFileIDSize(FileID FID) const {
   bool Invalid = false;
-  const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid);
+  SrcMgr::SLocEntry const &Entry = getSLocEntry(FID, &Invalid);
   if (Invalid)
     return 0;
 
   int ID = FID.ID;
   SourceLocation::UIntTy NextOffset;
-  if ((ID > 0 && unsigned(ID+1) == local_sloc_entry_size()))
+  if ((ID > 0 && unsigned(ID + 1) == local_sloc_entry_size()))
     NextOffset = getNextLocalOffset();
-  else if (ID+1 == -1)
+  else if (ID + 1 == -1)
     NextOffset = MaxLoadedOffset;
   else
-    NextOffset = getSLocEntry(FileID::get(ID+1)).getOffset();
+    NextOffset = getSLocEntry(FileID::get(ID + 1)).getOffset();
 
   return NextOffset - Entry.getOffset() - 1;
 }
@@ -1640,9 +1653,9 @@
 ///
 /// If the source file is included multiple times, the source location will
 /// be based upon an arbitrary inclusion.
-SourceLocation SourceManager::translateFileLineCol(const FileEntry *SourceFile,
-                                                  unsigned Line,
-                                                  unsigned Col) const {
+SourceLocation SourceManager::translateFileLineCol(FileEntry const *SourceFile,
+                                                   unsigned Line,
+                                                   unsigned Col) const {
   assert(SourceFile && "Null source file!");
   assert(Line && Col && "Line and column should start from 1!");
 
@@ -1654,14 +1667,14 @@
 ///
 /// If the source file is included multiple times, the FileID will be the
 /// first inclusion.
-FileID SourceManager::translateFile(const FileEntry *SourceFile) const {
+FileID SourceManager::translateFile(FileEntry const *SourceFile) const {
   assert(SourceFile && "Null source file!");
 
   // First, check the main file ID, since it is common to look for a
   // location in the main file.
   if (MainFileID.isValid()) {
     bool Invalid = false;
-    const SLocEntry &MainSLoc = getSLocEntry(MainFileID, &Invalid);
+    SLocEntry const &MainSLoc = getSLocEntry(MainFileID, &Invalid);
     if (Invalid)
       return FileID();
 
@@ -1674,7 +1687,7 @@
   // The location we're looking for isn't in the main file; look
   // through all of the local source locations.
   for (unsigned I = 0, N = local_sloc_entry_size(); I != N; ++I) {
-    const SLocEntry &SLoc = getLocalSLocEntry(I);
+    SLocEntry const &SLoc = getLocalSLocEntry(I);
     if (SLoc.isFile() &&
         SLoc.getFile().getContentCache().OrigEntry == SourceFile)
       return FileID::get(I);
@@ -1682,7 +1695,7 @@
 
   // If that still didn't help, try the modules.
   for (unsigned I = 0, N = loaded_sloc_entry_size(); I != N; ++I) {
-    const SLocEntry &SLoc = getLoadedSLocEntry(I);
+    SLocEntry const &SLoc = getLoadedSLocEntry(I);
     if (SLoc.isFile() &&
         SLoc.getFile().getContentCache().OrigEntry == SourceFile)
       return FileID::get(-int(I) - 2);
@@ -1693,8 +1706,7 @@
 
 /// Get the source location in \arg FID for the given line:col.
 /// Returns null location if \arg FID is not a file SLocEntry.
-SourceLocation SourceManager::translateLineCol(FileID FID,
-                                               unsigned Line,
+SourceLocation SourceManager::translateLineCol(FileID FID, unsigned Line,
                                                unsigned Col) const {
   // Lines are used as a one-based index into a zero-based array. This assert
   // checks for possible buffer underruns.
@@ -1704,7 +1716,7 @@
     return SourceLocation();
 
   bool Invalid = false;
-  const SLocEntry &Entry = getSLocEntry(FID, &Invalid);
+  SLocEntry const &Entry = getSLocEntry(FID, &Invalid);
   if (Invalid)
     return SourceLocation();
 
@@ -1716,7 +1728,7 @@
   if (Line == 1 && Col == 1)
     return FileLoc;
 
-  const ContentCache *Content = &Entry.getFile().getContentCache();
+  ContentCache const *Content = &Entry.getFile().getContentCache();
 
   // If this is the first use of line information for this buffer, compute the
   // SourceLineCache for it on demand.
@@ -1736,7 +1748,7 @@
   }
 
   unsigned FilePos = Content->SourceLineCache[Line - 1];
-  const char *Buf = Buffer->getBufferStart() + FilePos;
+  char const *Buf = Buffer->getBufferStart() + FilePos;
   unsigned BufLength = Buffer->getBufferSize() - FilePos;
   if (BufLength == 0)
     return FileLoc.getLocWithOffset(FilePos);
@@ -1744,7 +1756,7 @@
   unsigned i = 0;
 
   // Check that the given column is valid.
-  while (i < BufLength-1 && i < Col-1 && Buf[i] != '\n' && Buf[i] != '\r')
+  while (i < BufLength - 1 && i < Col - 1 && Buf[i] != '\n' && Buf[i] != '\r')
     ++i;
   return FileLoc.getLocWithOffset(FilePos + i);
 }
@@ -1775,11 +1787,11 @@
     }
 
     bool Invalid = false;
-    const SrcMgr::SLocEntry &Entry = getSLocEntryByID(ID, &Invalid);
+    SrcMgr::SLocEntry const &Entry = getSLocEntryByID(ID, &Invalid);
     if (Invalid)
       return;
     if (Entry.isFile()) {
-      auto& File = Entry.getFile();
+      auto &File = Entry.getFile();
       if (File.getFileCharacteristic() == C_User_ModuleMap ||
           File.getFileCharacteristic() == C_System_ModuleMap)
         continue;
@@ -1805,7 +1817,7 @@
       continue;
     }
 
-    const ExpansionInfo &ExpInfo = Entry.getExpansion();
+    ExpansionInfo const &ExpInfo = Entry.getExpansion();
 
     if (ExpInfo.getExpansionLocStart().isFileID()) {
       if (!isInFileID(ExpInfo.getExpansionLocStart(), FID))
@@ -1815,19 +1827,16 @@
     if (!ExpInfo.isMacroArgExpansion())
       continue;
 
-    associateFileChunkWithMacroArgExp(MacroArgsCache, FID,
-                                 ExpInfo.getSpellingLoc(),
-                                 SourceLocation::getMacroLoc(Entry.getOffset()),
-                                 getFileIDSize(FileID::get(ID)));
+    associateFileChunkWithMacroArgExp(
+        MacroArgsCache, FID, ExpInfo.getSpellingLoc(),
+        SourceLocation::getMacroLoc(Entry.getOffset()),
+        getFileIDSize(FileID::get(ID)));
   }
 }
 
 void SourceManager::associateFileChunkWithMacroArgExp(
-                                         MacroArgsMap &MacroArgsCache,
-                                         FileID FID,
-                                         SourceLocation SpellLoc,
-                                         SourceLocation ExpansionLoc,
-                                         unsigned ExpansionLength) const {
+    MacroArgsMap &MacroArgsCache, FileID FID, SourceLocation SpellLoc,
+    SourceLocation ExpansionLoc, unsigned ExpansionLength) const {
   if (!SpellLoc.isFileID()) {
     SourceLocation::UIntTy SpellBeginOffs = SpellLoc.getOffset();
     SourceLocation::UIntTy SpellEndOffs = SpellBeginOffs + ExpansionLength;
@@ -1841,20 +1850,21 @@
     unsigned SpellRelativeOffs;
     std::tie(SpellFID, SpellRelativeOffs) = getDecomposedLoc(SpellLoc);
     while (true) {
-      const SLocEntry &Entry = getSLocEntry(SpellFID);
+      SLocEntry const &Entry = getSLocEntry(SpellFID);
       SourceLocation::UIntTy SpellFIDBeginOffs = Entry.getOffset();
       unsigned SpellFIDSize = getFileIDSize(SpellFID);
       SourceLocation::UIntTy SpellFIDEndOffs = SpellFIDBeginOffs + SpellFIDSize;
-      const ExpansionInfo &Info = Entry.getExpansion();
+      ExpansionInfo const &Info = Entry.getExpansion();
       if (Info.isMacroArgExpansion()) {
         unsigned CurrSpellLength;
         if (SpellFIDEndOffs < SpellEndOffs)
           CurrSpellLength = SpellFIDSize - SpellRelativeOffs;
         else
           CurrSpellLength = ExpansionLength;
-        associateFileChunkWithMacroArgExp(MacroArgsCache, FID,
-                      Info.getSpellingLoc().getLocWithOffset(SpellRelativeOffs),
-                      ExpansionLoc, CurrSpellLength);
+        associateFileChunkWithMacroArgExp(
+            MacroArgsCache, FID,
+            Info.getSpellingLoc().getLocWithOffset(SpellRelativeOffs),
+            ExpansionLoc, CurrSpellLength);
       }
 
       if (SpellFIDEndOffs >= SpellEndOffs)
@@ -1959,7 +1969,7 @@
 
   SourceLocation UpperLoc;
   bool Invalid = false;
-  const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid);
+  SrcMgr::SLocEntry const &Entry = getSLocEntry(FID, &Invalid);
   if (!Invalid) {
     if (Entry.isExpansion())
       UpperLoc = Entry.getExpansion().getExpansionLocStart();
@@ -1978,7 +1988,7 @@
 /// version of the parent in Loc and return false.  If Loc is the top-level
 /// entry, return true and don't modify it.
 static bool MoveUpIncludeHierarchy(std::pair<FileID, unsigned> &Loc,
-                                   const SourceManager &SM) {
+                                   SourceManager const &SM) {
   std::pair<FileID, unsigned> UpperLoc = SM.getDecomposedIncludedLoc(Loc.first);
   if (UpperLoc.first.isInvalid())
     return true; // We reached the top.
@@ -2046,8 +2056,8 @@
   if (LIsBuiltins || RIsBuiltins) {
     if (LIsBuiltins != RIsBuiltins)
       return LIsBuiltins;
-    // Both are in built-in buffers, but from different files. We just claim that
-    // lower IDs come first.
+    // Both are in built-in buffers, but from different files. We just claim
+    // that lower IDs come first.
     return LOffs.first < ROffs.first;
   }
   bool LIsAsm = LB == "<inline asm>";
@@ -2080,7 +2090,7 @@
   // If we are comparing a source location with multiple locations in the same
   // file, we get a big win by caching the result.
   InBeforeInTUCacheEntry &IsBeforeInTUCache =
-    getInBeforeInTUCache(LOffs.first, ROffs.first);
+      getInBeforeInTUCache(LOffs.first, ROffs.first);
 
   // If we are comparing a source location with multiple locations in the same
   // file, we get a big win by caching the result.
@@ -2090,7 +2100,8 @@
 
   // Okay, we missed in the cache, start updating the cache for this query.
   IsBeforeInTUCache.setQueryFIDs(LOffs.first, ROffs.first,
-                          /*isLFIDBeforeRFID=*/LOffs.first.ID < ROffs.first.ID);
+                                 /*isLFIDBeforeRFID=*/LOffs.first.ID <
+                                     ROffs.first.ID);
 
   // We need to find the common ancestor. The only way of doing this is to
   // build the complete include chain for one and then walking up the chain
@@ -2105,7 +2116,7 @@
     // quit early. The other way round unfortunately remains suboptimal.
   } while (LOffs.first != ROffs.first && !MoveUpIncludeHierarchy(LOffs, *this));
   LocSet::iterator I;
-  while((I = LChain.find(ROffs.first)) == LChain.end()) {
+  while ((I = LChain.find(ROffs.first)) == LChain.end()) {
     if (MoveUpIncludeHierarchy(ROffs, *this))
       break; // Met at topmost file.
   }
@@ -2130,8 +2141,8 @@
                << " mem buffers mapped.\n";
   llvm::errs() << LocalSLocEntryTable.size() << " local SLocEntry's allocated ("
                << llvm::capacity_in_bytes(LocalSLocEntryTable)
-               << " bytes of capacity), "
-               << NextLocalOffset << "B of Sloc address space used.\n";
+               << " bytes of capacity), " << NextLocalOffset
+               << "B of Sloc address space used.\n";
   llvm::errs() << LoadedSLocEntryTable.size()
                << " loaded SLocEntries allocated, "
                << MaxLoadedOffset - CurrentLoadedOffset
@@ -2139,9 +2150,10 @@
 
   unsigned NumLineNumsComputed = 0;
   unsigned NumFileBytesMapped = 0;
-  for (fileinfo_iterator I = fileinfo_begin(), E = fileinfo_end(); I != E; ++I){
+  for (fileinfo_iterator I = fileinfo_begin(), E = fileinfo_end(); I != E;
+       ++I) {
     NumLineNumsComputed += bool(I->second->SourceLineCache);
-    NumFileBytesMapped  += I->second->getSizeBytesMapped();
+    NumFileBytesMapped += I->second->getSizeBytesMapped();
   }
   unsigned NumMacroArgsComputed = MacroArgsCacheMap.size();
 
@@ -2155,10 +2167,11 @@
 LLVM_DUMP_METHOD void SourceManager::dump() const {
   llvm::raw_ostream &out = llvm::errs();
 
-  auto DumpSLocEntry = [&](int ID, const SrcMgr::SLocEntry &Entry,
+  auto DumpSLocEntry = [&](int ID, SrcMgr::SLocEntry const &Entry,
                            llvm::Optional<SourceLocation::UIntTy> NextStart) {
-    out << "SLocEntry <FileID " << ID << "> " << (Entry.isFile() ? "file" : "expansion")
-        << " <SourceLocation " << Entry.getOffset() << ":";
+    out << "SLocEntry <FileID " << ID << "> "
+        << (Entry.isFile() ? "file" : "expansion") << " <SourceLocation "
+        << Entry.getOffset() << ":";
     if (NextStart)
       out << *NextStart << ">\n";
     else
@@ -2190,7 +2203,8 @@
   };
 
   // Dump local SLocEntries.
-  for (unsigned ID = 0, NumIDs = LocalSLocEntryTable.size(); ID != NumIDs; ++ID) {
+  for (unsigned ID = 0, NumIDs = LocalSLocEntryTable.size(); ID != NumIDs;
+       ++ID) {
     DumpSLocEntry(ID, LocalSLocEntryTable[ID],
                   ID == NumIDs - 1 ? NextLocalOffset
                                    : LocalSLocEntryTable[ID + 1].getOffset());
@@ -2219,23 +2233,23 @@
   for (unsigned i = 0, e = MemBufferInfos.size(); i != e; ++i)
     if (size_t sized_mapped = MemBufferInfos[i]->getSizeBytesMapped())
       switch (MemBufferInfos[i]->getMemoryBufferKind()) {
-        case llvm::MemoryBuffer::MemoryBuffer_MMap:
-          mmap_bytes += sized_mapped;
-          break;
-        case llvm::MemoryBuffer::MemoryBuffer_Malloc:
-          malloc_bytes += sized_mapped;
-          break;
+      case llvm::MemoryBuffer::MemoryBuffer_MMap:
+        mmap_bytes += sized_mapped;
+        break;
+      case llvm::MemoryBuffer::MemoryBuffer_Malloc:
+        malloc_bytes += sized_mapped;
+        break;
       }
 
   return MemoryBufferSizes(malloc_bytes, mmap_bytes);
 }
 
 size_t SourceManager::getDataStructureSizes() const {
-  size_t size = llvm::capacity_in_bytes(MemBufferInfos)
-    + llvm::capacity_in_bytes(LocalSLocEntryTable)
-    + llvm::capacity_in_bytes(LoadedSLocEntryTable)
-    + llvm::capacity_in_bytes(SLocEntryLoaded)
-    + llvm::capacity_in_bytes(FileInfos);
+  size_t size = llvm::capacity_in_bytes(MemBufferInfos) +
+                llvm::capacity_in_bytes(LocalSLocEntryTable) +
+                llvm::capacity_in_bytes(LoadedSLocEntryTable) +
+                llvm::capacity_in_bytes(SLocEntryLoaded) +
+                llvm::capacity_in_bytes(FileInfos);
 
   if (OverriddenFilesInfo)
     size += llvm::capacity_in_bytes(OverriddenFilesInfo->OverriddenFiles);
Index: clang/lib/Basic/Stack.cpp
===================================================================
--- clang/lib/Basic/Stack.cpp
+++ clang/lib/Basic/Stack.cpp
@@ -16,7 +16,7 @@
 #include "llvm/Support/CrashRecoveryContext.h"
 
 #ifdef _MSC_VER
-#include <intrin.h>  // for _AddressOfReturnAddress
+#include <intrin.h> // for _AddressOfReturnAddress
 #endif
 
 static LLVM_THREAD_LOCAL void *BottomOfStack = nullptr;
@@ -67,9 +67,11 @@
 void clang::runWithSufficientStackSpaceSlow(llvm::function_ref<void()> Diag,
                                             llvm::function_ref<void()> Fn) {
   llvm::CrashRecoveryContext CRC;
-  CRC.RunSafelyOnThread([&] {
-    noteBottomOfStack();
-    Diag();
-    Fn();
-  }, DesiredStackSize);
+  CRC.RunSafelyOnThread(
+      [&] {
+        noteBottomOfStack();
+        Diag();
+        Fn();
+      },
+      DesiredStackSize);
 }
Index: clang/lib/Basic/TargetID.cpp
===================================================================
--- clang/lib/Basic/TargetID.cpp
+++ clang/lib/Basic/TargetID.cpp
@@ -16,7 +16,7 @@
 namespace clang {
 
 static const llvm::SmallVector<llvm::StringRef, 4>
-getAllPossibleAMDGPUTargetIDFeatures(const llvm::Triple &T,
+getAllPossibleAMDGPUTargetIDFeatures(llvm::Triple const &T,
                                      llvm::StringRef Proc) {
   // Entries in returned vector should be in alphabetical order.
   llvm::SmallVector<llvm::StringRef, 4> Ret;
@@ -34,7 +34,7 @@
 }
 
 const llvm::SmallVector<llvm::StringRef, 4>
-getAllPossibleTargetIDFeatures(const llvm::Triple &T,
+getAllPossibleTargetIDFeatures(llvm::Triple const &T,
                                llvm::StringRef Processor) {
   llvm::SmallVector<llvm::StringRef, 4> Ret;
   if (T.isAMDGPU())
@@ -43,14 +43,14 @@
 }
 
 /// Returns canonical processor name or empty string if \p Processor is invalid.
-static llvm::StringRef getCanonicalProcessorName(const llvm::Triple &T,
+static llvm::StringRef getCanonicalProcessorName(llvm::Triple const &T,
                                                  llvm::StringRef Processor) {
   if (T.isAMDGPU())
     return llvm::AMDGPU::getCanonicalArchName(T, Processor);
   return Processor;
 }
 
-llvm::StringRef getProcessorFromTargetID(const llvm::Triple &T,
+llvm::StringRef getProcessorFromTargetID(llvm::Triple const &T,
                                          llvm::StringRef TargetID) {
   auto Split = TargetID.split(':');
   return getCanonicalProcessorName(T, Split.first);
@@ -101,7 +101,7 @@
 }
 
 llvm::Optional<llvm::StringRef>
-parseTargetID(const llvm::Triple &T, llvm::StringRef TargetID,
+parseTargetID(llvm::Triple const &T, llvm::StringRef TargetID,
               llvm::StringMap<bool> *FeatureMap) {
   auto OptionalProcessor =
       parseTargetIDWithFormatCheckingOnly(TargetID, FeatureMap);
@@ -128,10 +128,10 @@
 // A canonical target ID is a target ID containing a canonical processor name
 // and features in alphabetical order.
 std::string getCanonicalTargetID(llvm::StringRef Processor,
-                                 const llvm::StringMap<bool> &Features) {
+                                 llvm::StringMap<bool> const &Features) {
   std::string TargetID = Processor.str();
   std::map<const llvm::StringRef, bool> OrderedMap;
-  for (const auto &F : Features)
+  for (auto const &F : Features)
     OrderedMap[F.first()] = F.second;
   for (auto F : OrderedMap)
     TargetID = TargetID + ':' + F.first.str() + (F.second ? "+" : "-");
@@ -142,7 +142,7 @@
 // does not show up in any target IDs. Otherwise the target ID combination
 // is invalid.
 llvm::Optional<std::pair<llvm::StringRef, llvm::StringRef>>
-getConflictTargetIDCombination(const std::set<llvm::StringRef> &TargetIDs) {
+getConflictTargetIDCombination(std::set<llvm::StringRef> const &TargetIDs) {
   struct Info {
     llvm::StringRef TargetID;
     llvm::StringMap<bool> Features;
Index: clang/lib/Basic/TargetInfo.cpp
===================================================================
--- clang/lib/Basic/TargetInfo.cpp
+++ clang/lib/Basic/TargetInfo.cpp
@@ -25,7 +25,7 @@
 static const LangASMap DefaultAddrSpaceMap = {0};
 
 // TargetInfo Constructor.
-TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
+TargetInfo::TargetInfo(llvm::Triple const &T) : TargetOpts(), Triple(T) {
   // Set defaults.  Defaults are set for a 32-bit RISC platform, like PPC or
   // SPARC.  These should be overridden by concrete targets as needed.
   BigEndian = !T.isLittleEndian();
@@ -153,51 +153,66 @@
 // Out of line virtual dtor for TargetInfo.
 TargetInfo::~TargetInfo() {}
 
-void TargetInfo::resetDataLayout(StringRef DL, const char *ULP) {
+void TargetInfo::resetDataLayout(StringRef DL, char const *ULP) {
   DataLayoutString = DL.str();
   UserLabelPrefix = ULP;
 }
 
-bool
-TargetInfo::checkCFProtectionBranchSupported(DiagnosticsEngine &Diags) const {
+bool TargetInfo::checkCFProtectionBranchSupported(
+    DiagnosticsEngine &Diags) const {
   Diags.Report(diag::err_opt_not_valid_on_target) << "cf-protection=branch";
   return false;
 }
 
-bool
-TargetInfo::checkCFProtectionReturnSupported(DiagnosticsEngine &Diags) const {
+bool TargetInfo::checkCFProtectionReturnSupported(
+    DiagnosticsEngine &Diags) const {
   Diags.Report(diag::err_opt_not_valid_on_target) << "cf-protection=return";
   return false;
 }
 
 /// getTypeName - Return the user string for the specified integer type enum.
 /// For example, SignedShort -> "short".
-const char *TargetInfo::getTypeName(IntType T) {
+char const *TargetInfo::getTypeName(IntType T) {
   switch (T) {
-  default: llvm_unreachable("not an integer!");
-  case SignedChar:       return "signed char";
-  case UnsignedChar:     return "unsigned char";
-  case SignedShort:      return "short";
-  case UnsignedShort:    return "unsigned short";
-  case SignedInt:        return "int";
-  case UnsignedInt:      return "unsigned int";
-  case SignedLong:       return "long int";
-  case UnsignedLong:     return "long unsigned int";
-  case SignedLongLong:   return "long long int";
-  case UnsignedLongLong: return "long long unsigned int";
+  default:
+    llvm_unreachable("not an integer!");
+  case SignedChar:
+    return "signed char";
+  case UnsignedChar:
+    return "unsigned char";
+  case SignedShort:
+    return "short";
+  case UnsignedShort:
+    return "unsigned short";
+  case SignedInt:
+    return "int";
+  case UnsignedInt:
+    return "unsigned int";
+  case SignedLong:
+    return "long int";
+  case UnsignedLong:
+    return "long unsigned int";
+  case SignedLongLong:
+    return "long long int";
+  case UnsignedLongLong:
+    return "long long unsigned int";
   }
 }
 
 /// getTypeConstantSuffix - Return the constant suffix for the specified
 /// integer type enum. For example, SignedLong -> "L".
-const char *TargetInfo::getTypeConstantSuffix(IntType T) const {
+char const *TargetInfo::getTypeConstantSuffix(IntType T) const {
   switch (T) {
-  default: llvm_unreachable("not an integer!");
+  default:
+    llvm_unreachable("not an integer!");
   case SignedChar:
   case SignedShort:
-  case SignedInt:        return "";
-  case SignedLong:       return "L";
-  case SignedLongLong:   return "LL";
+  case SignedInt:
+    return "";
+  case SignedLong:
+    return "L";
+  case SignedLongLong:
+    return "LL";
   case UnsignedChar:
     if (getCharWidth() < getIntWidth())
       return "";
@@ -206,28 +221,37 @@
     if (getShortWidth() < getIntWidth())
       return "";
     LLVM_FALLTHROUGH;
-  case UnsignedInt:      return "U";
-  case UnsignedLong:     return "UL";
-  case UnsignedLongLong: return "ULL";
+  case UnsignedInt:
+    return "U";
+  case UnsignedLong:
+    return "UL";
+  case UnsignedLongLong:
+    return "ULL";
   }
 }
 
 /// getTypeFormatModifier - Return the printf format modifier for the
 /// specified integer type enum. For example, SignedLong -> "l".
 
-const char *TargetInfo::getTypeFormatModifier(IntType T) {
+char const *TargetInfo::getTypeFormatModifier(IntType T) {
   switch (T) {
-  default: llvm_unreachable("not an integer!");
+  default:
+    llvm_unreachable("not an integer!");
   case SignedChar:
-  case UnsignedChar:     return "hh";
+  case UnsignedChar:
+    return "hh";
   case SignedShort:
-  case UnsignedShort:    return "h";
+  case UnsignedShort:
+    return "h";
   case SignedInt:
-  case UnsignedInt:      return "";
+  case UnsignedInt:
+    return "";
   case SignedLong:
-  case UnsignedLong:     return "l";
+  case UnsignedLong:
+    return "l";
   case SignedLongLong:
-  case UnsignedLongLong: return "ll";
+  case UnsignedLongLong:
+    return "ll";
   }
 }
 
@@ -235,22 +259,28 @@
 /// enum. For example, SignedInt -> getIntWidth().
 unsigned TargetInfo::getTypeWidth(IntType T) const {
   switch (T) {
-  default: llvm_unreachable("not an integer!");
+  default:
+    llvm_unreachable("not an integer!");
   case SignedChar:
-  case UnsignedChar:     return getCharWidth();
+  case UnsignedChar:
+    return getCharWidth();
   case SignedShort:
-  case UnsignedShort:    return getShortWidth();
+  case UnsignedShort:
+    return getShortWidth();
   case SignedInt:
-  case UnsignedInt:      return getIntWidth();
+  case UnsignedInt:
+    return getIntWidth();
   case SignedLong:
-  case UnsignedLong:     return getLongWidth();
+  case UnsignedLong:
+    return getLongWidth();
   case SignedLongLong:
-  case UnsignedLongLong: return getLongLongWidth();
+  case UnsignedLongLong:
+    return getLongLongWidth();
   };
 }
 
-TargetInfo::IntType TargetInfo::getIntTypeByWidth(
-    unsigned BitWidth, bool IsSigned) const {
+TargetInfo::IntType TargetInfo::getIntTypeByWidth(unsigned BitWidth,
+                                                  bool IsSigned) const {
   if (getCharWidth() == BitWidth)
     return IsSigned ? SignedChar : UnsignedChar;
   if (getShortWidth() == BitWidth)
@@ -311,17 +341,23 @@
 /// enum. For example, SignedInt -> getIntAlign().
 unsigned TargetInfo::getTypeAlign(IntType T) const {
   switch (T) {
-  default: llvm_unreachable("not an integer!");
+  default:
+    llvm_unreachable("not an integer!");
   case SignedChar:
-  case UnsignedChar:     return getCharAlign();
+  case UnsignedChar:
+    return getCharAlign();
   case SignedShort:
-  case UnsignedShort:    return getShortAlign();
+  case UnsignedShort:
+    return getShortAlign();
   case SignedInt:
-  case UnsignedInt:      return getIntAlign();
+  case UnsignedInt:
+    return getIntAlign();
   case SignedLong:
-  case UnsignedLong:     return getLongAlign();
+  case UnsignedLong:
+    return getLongAlign();
   case SignedLongLong:
-  case UnsignedLongLong: return getLongLongAlign();
+  case UnsignedLongLong:
+    return getLongLongAlign();
   };
 }
 
@@ -329,7 +365,8 @@
 /// the type is signed; false otherwise.
 bool TargetInfo::isTypeSigned(IntType T) {
   switch (T) {
-  default: llvm_unreachable("not an integer!");
+  default:
+    llvm_unreachable("not an integer!");
   case SignedChar:
   case SignedShort:
   case SignedInt:
@@ -354,11 +391,19 @@
     UseBitFieldTypeAlignment = false;
 
   switch (Opts.WCharSize) {
-  default: llvm_unreachable("invalid wchar_t width");
-  case 0: break;
-  case 1: WCharType = Opts.WCharIsSigned ? SignedChar : UnsignedChar; break;
-  case 2: WCharType = Opts.WCharIsSigned ? SignedShort : UnsignedShort; break;
-  case 4: WCharType = Opts.WCharIsSigned ? SignedInt : UnsignedInt; break;
+  default:
+    llvm_unreachable("invalid wchar_t width");
+  case 0:
+    break;
+  case 1:
+    WCharType = Opts.WCharIsSigned ? SignedChar : UnsignedChar;
+    break;
+  case 2:
+    WCharType = Opts.WCharIsSigned ? SignedShort : UnsignedShort;
+    break;
+  case 4:
+    WCharType = Opts.WCharIsSigned ? SignedInt : UnsignedInt;
+    break;
   }
 
   if (Opts.AlignDouble) {
@@ -410,7 +455,7 @@
     // should be immutable once created and thus these language options need
     // to be defined only once.
     if (Opts.getOpenCLCompatibleVersion() == 300) {
-      const auto &OpenCLFeaturesMap = getSupportedOpenCLOpts();
+      auto const &OpenCLFeaturesMap = getSupportedOpenCLOpts();
       Opts.OpenCLGenericAddressSpace = hasFeatureEnabled(
           OpenCLFeaturesMap, "__opencl_c_generic_address_space");
       if (Opts.OpenCLVersion == 300)
@@ -460,8 +505,8 @@
 
 bool TargetInfo::initFeatureMap(
     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
-    const std::vector<std::string> &FeatureVec) const {
-  for (const auto &F : FeatureVec) {
+    std::vector<std::string> const &FeatureVec) const {
+  for (auto const &F : FeatureVec) {
     StringRef Name = F;
     // Apply the feature via the target.
     bool Enabled = Name[0] == '+';
@@ -494,7 +539,6 @@
 
 //===----------------------------------------------------------------------===//
 
-
 static StringRef removeGCCRegisterPrefix(StringRef Name) {
   if (Name[0] == '%' || Name[0] == '#')
     Name = Name.substr(1);
@@ -522,7 +566,7 @@
   if (Name.empty())
     return false;
 
-  ArrayRef<const char *> Names = getGCCRegNames();
+  ArrayRef<char const *> Names = getGCCRegNames();
 
   // If we have a number it maps to an entry in the register name array.
   if (isDigit(Name[0])) {
@@ -536,8 +580,8 @@
     return true;
 
   // Check any additional names that we have.
-  for (const AddlRegName &ARN : getGCCAddlRegNames())
-    for (const char *AN : ARN.Names) {
+  for (AddlRegName const &ARN : getGCCAddlRegNames())
+    for (char const *AN : ARN.Names) {
       if (!AN)
         break;
       // Make sure the register that the additional name is for is within
@@ -547,8 +591,8 @@
     }
 
   // Now check aliases.
-  for (const GCCRegAlias &GRA : getGCCRegAliases())
-    for (const char *A : GRA.Aliases) {
+  for (GCCRegAlias const &GRA : getGCCRegAliases())
+    for (char const *A : GRA.Aliases) {
       if (!A)
         break;
       if (A == Name)
@@ -565,7 +609,7 @@
   // Get rid of any register prefix.
   Name = removeGCCRegisterPrefix(Name);
 
-  ArrayRef<const char *> Names = getGCCRegNames();
+  ArrayRef<char const *> Names = getGCCRegNames();
 
   // First, check if we have a number.
   if (isDigit(Name[0])) {
@@ -577,8 +621,8 @@
   }
 
   // Check any additional names that we have.
-  for (const AddlRegName &ARN : getGCCAddlRegNames())
-    for (const char *AN : ARN.Names) {
+  for (AddlRegName const &ARN : getGCCAddlRegNames())
+    for (char const *AN : ARN.Names) {
       if (!AN)
         break;
       // Make sure the register that the additional name is for is within
@@ -588,8 +632,8 @@
     }
 
   // Now check aliases.
-  for (const GCCRegAlias &RA : getGCCRegAliases())
-    for (const char *A : RA.Aliases) {
+  for (GCCRegAlias const &RA : getGCCRegAliases())
+    for (char const *A : RA.Aliases) {
       if (!A)
         break;
       if (A == Name)
@@ -600,7 +644,7 @@
 }
 
 bool TargetInfo::validateOutputConstraint(ConstraintInfo &Info) const {
-  const char *Name = Info.getConstraintStr().c_str();
+  char const *Name = Info.getConstraintStr().c_str();
   // An output constraint must start with '=' or '+'
   if (*Name != '=' && *Name != '+')
     return false;
@@ -657,7 +701,7 @@
     case 'n':
     case 'E':
     case 'F':
-      break;  // Pass them.
+      break; // Pass them.
     }
 
     Name++;
@@ -673,12 +717,12 @@
   return Info.allowsMemory() || Info.allowsRegister();
 }
 
-bool TargetInfo::resolveSymbolicName(const char *&Name,
+bool TargetInfo::resolveSymbolicName(char const *&Name,
                                      ArrayRef<ConstraintInfo> OutputConstraints,
                                      unsigned &Index) const {
   assert(*Name == '[' && "Symbolic name did not start with '['");
   Name++;
-  const char *Start = Name;
+  char const *Start = Name;
   while (*Name && *Name != ']')
     Name++;
 
@@ -697,9 +741,9 @@
 }
 
 bool TargetInfo::validateInputConstraint(
-                              MutableArrayRef<ConstraintInfo> OutputConstraints,
-                              ConstraintInfo &Info) const {
-  const char *Name = Info.ConstraintStr.c_str();
+    MutableArrayRef<ConstraintInfo> OutputConstraints,
+    ConstraintInfo &Info) const {
+  char const *Name = Info.ConstraintStr.c_str();
 
   if (!*Name)
     return false;
@@ -709,17 +753,18 @@
     default:
       // Check if we have a matching constraint
       if (*Name >= '0' && *Name <= '9') {
-        const char *DigitStart = Name;
+        char const *DigitStart = Name;
         while (Name[1] >= '0' && Name[1] <= '9')
           Name++;
-        const char *DigitEnd = Name;
+        char const *DigitEnd = Name;
         unsigned i;
         if (StringRef(DigitStart, DigitEnd - DigitStart + 1)
                 .getAsInteger(10, i))
           return false;
 
         // Check if matching constraint is out of bounds.
-        if (i >= OutputConstraints.size()) return false;
+        if (i >= OutputConstraints.size())
+          return false;
 
         // A number must refer to an output only operand.
         if (OutputConstraints[i].isReadWrite())
@@ -765,7 +810,7 @@
     case 'n': // immediate integer with a known value.
       Info.setRequiresImmediate();
       break;
-    case 'I':  // Various constant constraints with target-specific meanings.
+    case 'I': // Various constant constraints with target-specific meanings.
     case 'J':
     case 'K':
     case 'L':
@@ -873,8 +918,8 @@
   assert(getLongAccumIBits() >= getUnsignedLongAccumIBits());
 }
 
-void TargetInfo::copyAuxTarget(const TargetInfo *Aux) {
-  auto *Target = static_cast<TransferrableTargetInfo*>(this);
-  auto *Src = static_cast<const TransferrableTargetInfo*>(Aux);
+void TargetInfo::copyAuxTarget(TargetInfo const *Aux) {
+  auto *Target = static_cast<TransferrableTargetInfo *>(this);
+  auto *Src = static_cast<TransferrableTargetInfo const *>(Aux);
   *Target = *Src;
 }
Index: clang/lib/Basic/Targets.h
===================================================================
--- clang/lib/Basic/Targets.h
+++ clang/lib/Basic/Targets.h
@@ -24,22 +24,22 @@
 namespace targets {
 
 LLVM_LIBRARY_VISIBILITY
-clang::TargetInfo *AllocateTarget(const llvm::Triple &Triple,
-                                  const clang::TargetOptions &Opts);
+clang::TargetInfo *AllocateTarget(llvm::Triple const &Triple,
+                                  clang::TargetOptions const &Opts);
 
 /// DefineStd - Define a macro name and standard variants.  For example if
 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
 /// when in GNU mode.
 LLVM_LIBRARY_VISIBILITY
 void DefineStd(clang::MacroBuilder &Builder, llvm::StringRef MacroName,
-               const clang::LangOptions &Opts);
+               clang::LangOptions const &Opts);
 
 LLVM_LIBRARY_VISIBILITY
 void defineCPUMacros(clang::MacroBuilder &Builder, llvm::StringRef CPUName,
                      bool Tuning = true);
 
 LLVM_LIBRARY_VISIBILITY
-void addCygMingDefines(const clang::LangOptions &Opts,
+void addCygMingDefines(clang::LangOptions const &Opts,
                        clang::MacroBuilder &Builder);
 } // namespace targets
 } // namespace clang
Index: clang/lib/Basic/Targets.cpp
===================================================================
--- clang/lib/Basic/Targets.cpp
+++ clang/lib/Basic/Targets.cpp
@@ -54,7 +54,7 @@
 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
 /// when in GNU mode.
 void DefineStd(MacroBuilder &Builder, StringRef MacroName,
-               const LangOptions &Opts) {
+               LangOptions const &Opts) {
   assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
 
   // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
@@ -76,7 +76,7 @@
     Builder.defineMacro("__tune_" + CPUName + "__");
 }
 
-void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {
+void addCygMingDefines(LangOptions const &Opts, MacroBuilder &Builder) {
   // Mingw and cygwin define __declspec(a) to __attribute__((a)).  Clang
   // supports __declspec natively under -fms-extensions, but we define a no-op
   // __declspec macro anyway for pre-processor compatibility.
@@ -89,8 +89,8 @@
     // Provide macros for all the calling convention keywords.  Provide both
     // single and double underscore prefixed variants.  These are available on
     // x64 as well as x86, even though they have no effect.
-    const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
-    for (const char *CC : CCs) {
+    char const *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
+    for (char const *CC : CCs) {
       std::string GCCSpelling = "__attribute__((__";
       GCCSpelling += CC;
       GCCSpelling += "__))";
@@ -104,8 +104,8 @@
 // Driver code
 //===----------------------------------------------------------------------===//
 
-TargetInfo *AllocateTarget(const llvm::Triple &Triple,
-                           const TargetOptions &Opts) {
+TargetInfo *AllocateTarget(llvm::Triple const &Triple,
+                           TargetOptions const &Opts) {
   llvm::Triple::OSType os = Triple.getOS();
 
   switch (Triple.getArch()) {
@@ -612,14 +612,14 @@
         !Triple.isOSBinFormatWasm())
       return nullptr;
     switch (os) {
-      case llvm::Triple::WASI:
-        return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
-      case llvm::Triple::Emscripten:
-        return new EmscriptenTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
-      case llvm::Triple::UnknownOS:
-        return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
-      default:
-        return nullptr;
+    case llvm::Triple::WASI:
+      return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
+    case llvm::Triple::Emscripten:
+      return new EmscriptenTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
+    case llvm::Triple::UnknownOS:
+      return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
+    default:
+      return nullptr;
     }
   case llvm::Triple::wasm64:
     if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
@@ -627,14 +627,14 @@
         !Triple.isOSBinFormatWasm())
       return nullptr;
     switch (os) {
-      case llvm::Triple::WASI:
-        return new WASITargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
-      case llvm::Triple::Emscripten:
-        return new EmscriptenTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
-      case llvm::Triple::UnknownOS:
-        return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
-      default:
-        return nullptr;
+    case llvm::Triple::WASI:
+      return new WASITargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
+    case llvm::Triple::Emscripten:
+      return new EmscriptenTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
+    case llvm::Triple::UnknownOS:
+      return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
+    default:
+      return nullptr;
     }
 
   case llvm::Triple::renderscript32:
@@ -654,7 +654,7 @@
 /// options.
 TargetInfo *
 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
-                             const std::shared_ptr<TargetOptions> &Opts) {
+                             std::shared_ptr<TargetOptions> const &Opts) {
   llvm::Triple Triple(Opts->Triple);
 
   // Construct the target
@@ -676,8 +676,7 @@
   }
 
   // Check the TuneCPU name if specified.
-  if (!Opts->TuneCPU.empty() &&
-      !Target->isValidTuneCPUName(Opts->TuneCPU)) {
+  if (!Opts->TuneCPU.empty() && !Target->isValidTuneCPUName(Opts->TuneCPU)) {
     Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU;
     SmallVector<StringRef, 32> ValidList;
     Target->fillValidTuneCPUList(ValidList);
@@ -706,7 +705,7 @@
 
   // Add the features to the compile options.
   Opts->Features.clear();
-  for (const auto &F : Opts->FeatureMap)
+  for (auto const &F : Opts->FeatureMap)
     Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
   // Sort here, so we handle the features in a predictable order. (This matters
   // when we're dealing with features that overlap.)
@@ -728,9 +727,9 @@
 }
 /// validateOpenCLTarget  - Check that OpenCL target has valid
 /// options setting based on OpenCL version.
-bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts,
+bool TargetInfo::validateOpenCLTarget(LangOptions const &Opts,
                                       DiagnosticsEngine &Diags) const {
-  const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts();
+  llvm::StringMap<bool> const &OpenCLFeaturesMap = getSupportedOpenCLOpts();
 
   auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) {
     if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) &&
Index: clang/lib/Basic/TokenKinds.cpp
===================================================================
--- clang/lib/Basic/TokenKinds.cpp
+++ clang/lib/Basic/TokenKinds.cpp
@@ -14,41 +14,48 @@
 #include "llvm/Support/ErrorHandling.h"
 using namespace clang;
 
-static const char * const TokNames[] = {
+static char const *const TokNames[] = {
 #define TOK(X) #X,
-#define KEYWORD(X,Y) #X,
+#define KEYWORD(X, Y) #X,
 #include "clang/Basic/TokenKinds.def"
-  nullptr
-};
+    nullptr};
 
-const char *tok::getTokenName(TokenKind Kind) {
+char const *tok::getTokenName(TokenKind Kind) {
   if (Kind < tok::NUM_TOKENS)
     return TokNames[Kind];
   llvm_unreachable("unknown TokenKind");
   return nullptr;
 }
 
-const char *tok::getPunctuatorSpelling(TokenKind Kind) {
+char const *tok::getPunctuatorSpelling(TokenKind Kind) {
   switch (Kind) {
-#define PUNCTUATOR(X,Y) case X: return Y;
+#define PUNCTUATOR(X, Y)                                                       \
+  case X:                                                                      \
+    return Y;
 #include "clang/Basic/TokenKinds.def"
-  default: break;
+  default:
+    break;
   }
   return nullptr;
 }
 
-const char *tok::getKeywordSpelling(TokenKind Kind) {
+char const *tok::getKeywordSpelling(TokenKind Kind) {
   switch (Kind) {
-#define KEYWORD(X,Y) case kw_ ## X: return #X;
+#define KEYWORD(X, Y)                                                          \
+  case kw_##X:                                                                 \
+    return #X;
 #include "clang/Basic/TokenKinds.def"
-    default: break;
+  default:
+    break;
   }
   return nullptr;
 }
 
 bool tok::isAnnotation(TokenKind Kind) {
   switch (Kind) {
-#define ANNOTATION(X) case annot_ ## X: return true;
+#define ANNOTATION(X)                                                          \
+  case annot_##X:                                                              \
+    return true;
 #include "clang/Basic/TokenKinds.def"
   default:
     break;
@@ -58,7 +65,9 @@
 
 bool tok::isPragmaAnnotation(TokenKind Kind) {
   switch (Kind) {
-#define PRAGMA_ANNOTATION(X) case annot_ ## X: return true;
+#define PRAGMA_ANNOTATION(X)                                                   \
+  case annot_##X:                                                              \
+    return true;
 #include "clang/Basic/TokenKinds.def"
   default:
     break;
Index: clang/lib/Basic/TypeTraits.cpp
===================================================================
--- clang/lib/Basic/TypeTraits.cpp
+++ clang/lib/Basic/TypeTraits.cpp
@@ -15,7 +15,7 @@
 #include <cassert>
 using namespace clang;
 
-static constexpr const char *TypeTraitNames[] = {
+static constexpr char const *TypeTraitNames[] = {
 #define TYPE_TRAIT_1(Spelling, Name, Key) #Name,
 #include "clang/Basic/TokenKinds.def"
 #define TYPE_TRAIT_2(Spelling, Name, Key) #Name,
@@ -24,7 +24,7 @@
 #include "clang/Basic/TokenKinds.def"
 };
 
-static constexpr const char *TypeTraitSpellings[] = {
+static constexpr char const *TypeTraitSpellings[] = {
 #define TYPE_TRAIT_1(Spelling, Name, Key) #Spelling,
 #include "clang/Basic/TokenKinds.def"
 #define TYPE_TRAIT_2(Spelling, Name, Key) #Spelling,
@@ -33,54 +33,54 @@
 #include "clang/Basic/TokenKinds.def"
 };
 
-static constexpr const char *ArrayTypeTraitNames[] = {
+static constexpr char const *ArrayTypeTraitNames[] = {
 #define ARRAY_TYPE_TRAIT(Spelling, Name, Key) #Name,
 #include "clang/Basic/TokenKinds.def"
 };
 
-static constexpr const char *ArrayTypeTraitSpellings[] = {
+static constexpr char const *ArrayTypeTraitSpellings[] = {
 #define ARRAY_TYPE_TRAIT(Spelling, Name, Key) #Spelling,
 #include "clang/Basic/TokenKinds.def"
 };
 
-static constexpr const char *UnaryExprOrTypeTraitNames[] = {
+static constexpr char const *UnaryExprOrTypeTraitNames[] = {
 #define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) #Name,
 #define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) #Name,
 #include "clang/Basic/TokenKinds.def"
 };
 
-static constexpr const char *UnaryExprOrTypeTraitSpellings[] = {
+static constexpr char const *UnaryExprOrTypeTraitSpellings[] = {
 #define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) #Spelling,
 #define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) #Spelling,
 #include "clang/Basic/TokenKinds.def"
 };
 
-const char *clang::getTraitName(TypeTrait T) {
+char const *clang::getTraitName(TypeTrait T) {
   assert(T <= TT_Last && "invalid enum value!");
   return TypeTraitNames[T];
 }
 
-const char *clang::getTraitName(ArrayTypeTrait T) {
+char const *clang::getTraitName(ArrayTypeTrait T) {
   assert(T <= ATT_Last && "invalid enum value!");
   return ArrayTypeTraitNames[T];
 }
 
-const char *clang::getTraitName(UnaryExprOrTypeTrait T) {
+char const *clang::getTraitName(UnaryExprOrTypeTrait T) {
   assert(T <= UETT_Last && "invalid enum value!");
   return UnaryExprOrTypeTraitNames[T];
 }
 
-const char *clang::getTraitSpelling(TypeTrait T) {
+char const *clang::getTraitSpelling(TypeTrait T) {
   assert(T <= TT_Last && "invalid enum value!");
   return TypeTraitSpellings[T];
 }
 
-const char *clang::getTraitSpelling(ArrayTypeTrait T) {
+char const *clang::getTraitSpelling(ArrayTypeTrait T) {
   assert(T <= ATT_Last && "invalid enum value!");
   return ArrayTypeTraitSpellings[T];
 }
 
-const char *clang::getTraitSpelling(UnaryExprOrTypeTrait T) {
+char const *clang::getTraitSpelling(UnaryExprOrTypeTrait T) {
   assert(T <= UETT_Last && "invalid enum value!");
   return UnaryExprOrTypeTraitSpellings[T];
 }
Index: clang/lib/Basic/Version.cpp
===================================================================
--- clang/lib/Basic/Version.cpp
+++ clang/lib/Basic/Version.cpp
@@ -85,9 +85,7 @@
   return OS.str();
 }
 
-std::string getClangFullVersion() {
-  return getClangToolFullVersion("clang");
-}
+std::string getClangFullVersion() { return getClangToolFullVersion("clang"); }
 
 std::string getClangToolFullVersion(StringRef ToolName) {
   std::string buf;
Index: clang/lib/Basic/Warnings.cpp
===================================================================
--- clang/lib/Basic/Warnings.cpp
+++ clang/lib/Basic/Warnings.cpp
@@ -42,9 +42,9 @@
 }
 
 void clang::ProcessWarningOptions(DiagnosticsEngine &Diags,
-                                  const DiagnosticOptions &Opts,
+                                  DiagnosticOptions const &Opts,
                                   bool ReportDiags) {
-  Diags.setSuppressSystemWarnings(true);  // Default to -Wno-system-headers
+  Diags.setSuppressSystemWarnings(true); // Default to -Wno-system-headers
   Diags.setIgnoreAllWarnings(Opts.IgnoreWarnings);
   Diags.setShowOverloads(Opts.getShowOverloads());
 
@@ -71,8 +71,7 @@
     Diags.setExtensionHandlingBehavior(diag::Severity::Ignored);
 
   SmallVector<diag::kind, 10> _Diags;
-  const IntrusiveRefCntPtr< DiagnosticIDs > DiagIDs =
-    Diags.getDiagnosticIDs();
+  IntrusiveRefCntPtr<DiagnosticIDs> const DiagIDs = Diags.getDiagnosticIDs();
   // We parse the warning options twice.  The first pass sets diagnostic state,
   // while the second pass reports warnings/errors.  This has the effect that
   // we follow the more canonical "last option wins" paradigm when there are
@@ -86,7 +85,7 @@
       break;
 
     for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i) {
-      const auto Flavor = diag::Flavor::WarningOrError;
+      auto const Flavor = diag::Flavor::WarningOrError;
       StringRef Opt = Opts.Warnings[i];
       StringRef OrigOpt = Opts.Warnings[i];
 
@@ -135,12 +134,12 @@
       // a few projects.
       if (Opt.startswith("error")) {
         StringRef Specifier;
-        if (Opt.size() > 5) {  // Specifier must be present.
+        if (Opt.size() > 5) { // Specifier must be present.
           if (Opt[5] != '=' &&
               Opt.substr(5) != "-implicit-function-declaration") {
             if (Report)
               Diags.Report(diag::warn_unknown_warning_specifier)
-                << "-Werror" << ("-W" + OrigOpt.str());
+                  << "-Werror" << ("-W" + OrigOpt.str());
             continue;
           }
           Specifier = Opt.substr(6);
@@ -168,7 +167,7 @@
           if ((Opt[12] != '=' && Opt[12] != '-') || Opt.size() == 13) {
             if (Report)
               Diags.Report(diag::warn_unknown_warning_specifier)
-                << "-Wfatal-errors" << ("-W" + OrigOpt.str());
+                  << "-Wfatal-errors" << ("-W" + OrigOpt.str());
             continue;
           }
           Specifier = Opt.substr(13);
@@ -200,15 +199,16 @@
 
     for (unsigned i = 0, e = Opts.Remarks.size(); i != e; ++i) {
       StringRef Opt = Opts.Remarks[i];
-      const auto Flavor = diag::Flavor::Remark;
+      auto const Flavor = diag::Flavor::Remark;
 
       // Check to see if this warning starts with "no-", if so, this is a
       // negative form of the option.
       bool IsPositive = !Opt.startswith("no-");
-      if (!IsPositive) Opt = Opt.substr(3);
+      if (!IsPositive)
+        Opt = Opt.substr(3);
 
-      auto Severity = IsPositive ? diag::Severity::Remark
-                                 : diag::Severity::Ignored;
+      auto Severity =
+          IsPositive ? diag::Severity::Remark : diag::Severity::Ignored;
 
       // -Reverything sets the state of all remarks. Note that all remarks are
       // in remark groups, so we don't need a separate 'all remarks enabled'
Index: clang/lib/Format/AffectedRangeManager.h
===================================================================
--- clang/lib/Format/AffectedRangeManager.h
+++ clang/lib/Format/AffectedRangeManager.h
@@ -24,8 +24,8 @@
 
 class AffectedRangeManager {
 public:
-  AffectedRangeManager(const SourceManager &SourceMgr,
-                       const ArrayRef<CharSourceRange> Ranges)
+  AffectedRangeManager(SourceManager const &SourceMgr,
+                       ArrayRef<CharSourceRange> const Ranges)
       : SourceMgr(SourceMgr), Ranges(Ranges.begin(), Ranges.end()) {}
 
   // Determines which lines are affected by the SourceRanges given as input.
@@ -34,17 +34,17 @@
   bool computeAffectedLines(SmallVectorImpl<AnnotatedLine *> &Lines);
 
   // Returns true if 'Range' intersects with one of the input ranges.
-  bool affectsCharSourceRange(const CharSourceRange &Range);
+  bool affectsCharSourceRange(CharSourceRange const &Range);
 
 private:
   // Returns true if the range from 'First' to 'Last' intersects with one of the
   // input ranges.
-  bool affectsTokenRange(const FormatToken &First, const FormatToken &Last,
+  bool affectsTokenRange(FormatToken const &First, FormatToken const &Last,
                          bool IncludeLeadingNewlines);
 
   // Returns true if one of the input ranges intersect the leading empty lines
   // before 'Tok'.
-  bool affectsLeadingEmptyLines(const FormatToken &Tok);
+  bool affectsLeadingEmptyLines(FormatToken const &Tok);
 
   // Marks all lines between I and E as well as all their children as affected.
   void markAllAsAffected(SmallVectorImpl<AnnotatedLine *>::iterator I,
@@ -52,11 +52,11 @@
 
   // Determines whether 'Line' is affected by the SourceRanges given as input.
   // Returns \c true if line or one if its children is affected.
-  bool nonPPLineAffected(AnnotatedLine *Line, const AnnotatedLine *PreviousLine,
+  bool nonPPLineAffected(AnnotatedLine *Line, AnnotatedLine const *PreviousLine,
                          SmallVectorImpl<AnnotatedLine *> &Lines);
 
-  const SourceManager &SourceMgr;
-  const SmallVector<CharSourceRange, 8> Ranges;
+  SourceManager const &SourceMgr;
+  SmallVector<CharSourceRange, 8> const Ranges;
 };
 
 } // namespace format
Index: clang/lib/Format/AffectedRangeManager.cpp
===================================================================
--- clang/lib/Format/AffectedRangeManager.cpp
+++ clang/lib/Format/AffectedRangeManager.cpp
@@ -24,7 +24,7 @@
   SmallVectorImpl<AnnotatedLine *>::iterator I = Lines.begin();
   SmallVectorImpl<AnnotatedLine *>::iterator E = Lines.end();
   bool SomeLineAffected = false;
-  const AnnotatedLine *PreviousLine = nullptr;
+  AnnotatedLine const *PreviousLine = nullptr;
   while (I != E) {
     AnnotatedLine *Line = *I;
     Line->LeadingEmptyLinesAffected = affectsLeadingEmptyLines(*Line->First);
@@ -58,7 +58,7 @@
 }
 
 bool AffectedRangeManager::affectsCharSourceRange(
-    const CharSourceRange &Range) {
+    CharSourceRange const &Range) {
   for (SmallVectorImpl<CharSourceRange>::const_iterator I = Ranges.begin(),
                                                         E = Ranges.end();
        I != E; ++I) {
@@ -69,8 +69,8 @@
   return false;
 }
 
-bool AffectedRangeManager::affectsTokenRange(const FormatToken &First,
-                                             const FormatToken &Last,
+bool AffectedRangeManager::affectsTokenRange(FormatToken const &First,
+                                             FormatToken const &Last,
                                              bool IncludeLeadingNewlines) {
   SourceLocation Start = First.WhitespaceRange.getBegin();
   if (!IncludeLeadingNewlines)
@@ -81,7 +81,7 @@
   return affectsCharSourceRange(Range);
 }
 
-bool AffectedRangeManager::affectsLeadingEmptyLines(const FormatToken &Tok) {
+bool AffectedRangeManager::affectsLeadingEmptyLines(FormatToken const &Tok) {
   CharSourceRange EmptyLineRange = CharSourceRange::getCharRange(
       Tok.WhitespaceRange.getBegin(),
       Tok.WhitespaceRange.getBegin().getLocWithOffset(Tok.LastNewlineOffset));
@@ -99,7 +99,7 @@
 }
 
 bool AffectedRangeManager::nonPPLineAffected(
-    AnnotatedLine *Line, const AnnotatedLine *PreviousLine,
+    AnnotatedLine *Line, AnnotatedLine const *PreviousLine,
     SmallVectorImpl<AnnotatedLine *> &Lines) {
   bool SomeLineAffected = false;
   Line->ChildrenAffected = computeAffectedLines(Line->Children);
Index: clang/lib/Format/BreakableToken.h
===================================================================
--- clang/lib/Format/BreakableToken.h
+++ clang/lib/Format/BreakableToken.h
@@ -29,7 +29,7 @@
 
 /// Checks if \p Token switches formatting, like /* clang-format off */.
 /// \p Token must be a comment.
-bool switchesFormatting(const FormatToken &Token);
+bool switchesFormatting(FormatToken const &Token);
 
 struct FormatStyle;
 
@@ -155,7 +155,7 @@
   /// file.
   virtual Split getSplit(unsigned LineIndex, unsigned TailOffset,
                          unsigned ColumnLimit, unsigned ContentStartColumn,
-                         const llvm::Regex &CommentPragmasRegex) const = 0;
+                         llvm::Regex const &CommentPragmasRegex) const = 0;
 
   /// Emits the previously retrieved \p Split via \p Whitespaces.
   virtual void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
@@ -190,7 +190,7 @@
   /// If the split is not contained within one token, for example when reflowing
   /// line comments, returns (0, <length>).
   virtual Split getReflowSplit(unsigned LineIndex,
-                               const llvm::Regex &CommentPragmasRegex) const {
+                               llvm::Regex const &CommentPragmasRegex) const {
     return Split(StringRef::npos, 0);
   }
 
@@ -231,15 +231,15 @@
   virtual void updateNextToken(LineState &State) const {}
 
 protected:
-  BreakableToken(const FormatToken &Tok, bool InPPDirective,
-                 encoding::Encoding Encoding, const FormatStyle &Style)
+  BreakableToken(FormatToken const &Tok, bool InPPDirective,
+                 encoding::Encoding Encoding, FormatStyle const &Style)
       : Tok(Tok), InPPDirective(InPPDirective), Encoding(Encoding),
         Style(Style) {}
 
-  const FormatToken &Tok;
-  const bool InPPDirective;
+  FormatToken const &Tok;
+  bool const InPPDirective;
   const encoding::Encoding Encoding;
-  const FormatStyle &Style;
+  FormatStyle const &Style;
 };
 
 class BreakableStringLiteral : public BreakableToken {
@@ -248,14 +248,14 @@
   ///
   /// \p StartColumn specifies the column in which the token will start
   /// after formatting.
-  BreakableStringLiteral(const FormatToken &Tok, unsigned StartColumn,
+  BreakableStringLiteral(FormatToken const &Tok, unsigned StartColumn,
                          StringRef Prefix, StringRef Postfix,
                          unsigned UnbreakableTailLength, bool InPPDirective,
-                         encoding::Encoding Encoding, const FormatStyle &Style);
+                         encoding::Encoding Encoding, FormatStyle const &Style);
 
   Split getSplit(unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
                  unsigned ContentStartColumn,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
   void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
                    unsigned ContentIndent,
                    WhitespaceManager &Whitespaces) const override;
@@ -289,27 +289,27 @@
   ///
   /// \p StartColumn specifies the column in which the comment will start after
   /// formatting.
-  BreakableComment(const FormatToken &Token, unsigned StartColumn,
+  BreakableComment(FormatToken const &Token, unsigned StartColumn,
                    bool InPPDirective, encoding::Encoding Encoding,
-                   const FormatStyle &Style);
+                   FormatStyle const &Style);
 
 public:
   bool supportsReflow() const override { return true; }
   unsigned getLineCount() const override;
   Split getSplit(unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
                  unsigned ContentStartColumn,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
   void compressWhitespace(unsigned LineIndex, unsigned TailOffset, Split Split,
                           WhitespaceManager &Whitespaces) const override;
 
 protected:
   // Returns the token containing the line at LineIndex.
-  const FormatToken &tokenAt(unsigned LineIndex) const;
+  FormatToken const &tokenAt(unsigned LineIndex) const;
 
   // Checks if the content of line LineIndex may be reflown with the previous
   // line.
   virtual bool mayReflow(unsigned LineIndex,
-                         const llvm::Regex &CommentPragmasRegex) const = 0;
+                         llvm::Regex const &CommentPragmasRegex) const = 0;
 
   // Contains the original text of the lines of the block comment.
   //
@@ -356,14 +356,14 @@
 
 class BreakableBlockComment : public BreakableComment {
 public:
-  BreakableBlockComment(const FormatToken &Token, unsigned StartColumn,
+  BreakableBlockComment(FormatToken const &Token, unsigned StartColumn,
                         unsigned OriginalStartColumn, bool FirstInLine,
                         bool InPPDirective, encoding::Encoding Encoding,
-                        const FormatStyle &Style, bool UseCRLF);
+                        FormatStyle const &Style, bool UseCRLF);
 
   Split getSplit(unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
                  unsigned ContentStartColumn,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
   unsigned getRangeLength(unsigned LineIndex, unsigned Offset,
                           StringRef::size_type Length,
                           unsigned StartColumn) const override;
@@ -375,7 +375,7 @@
                    unsigned ContentIndent,
                    WhitespaceManager &Whitespaces) const override;
   Split getReflowSplit(unsigned LineIndex,
-                       const llvm::Regex &CommentPragmasRegex) const override;
+                       llvm::Regex const &CommentPragmasRegex) const override;
   void reflow(unsigned LineIndex,
               WhitespaceManager &Whitespaces) const override;
   bool introducesBreakBeforeToken() const override;
@@ -384,7 +384,7 @@
   Split getSplitAfterLastLine(unsigned TailOffset) const override;
 
   bool mayReflow(unsigned LineIndex,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
 
   // Contains Javadoc annotations that require additional indent when continued
   // on multiple lines.
@@ -435,9 +435,9 @@
 
 class BreakableLineCommentSection : public BreakableComment {
 public:
-  BreakableLineCommentSection(const FormatToken &Token, unsigned StartColumn,
+  BreakableLineCommentSection(FormatToken const &Token, unsigned StartColumn,
                               bool InPPDirective, encoding::Encoding Encoding,
-                              const FormatStyle &Style);
+                              FormatStyle const &Style);
 
   unsigned getRangeLength(unsigned LineIndex, unsigned Offset,
                           StringRef::size_type Length,
@@ -447,14 +447,14 @@
                    unsigned ContentIndent,
                    WhitespaceManager &Whitespaces) const override;
   Split getReflowSplit(unsigned LineIndex,
-                       const llvm::Regex &CommentPragmasRegex) const override;
+                       llvm::Regex const &CommentPragmasRegex) const override;
   void reflow(unsigned LineIndex,
               WhitespaceManager &Whitespaces) const override;
   void adaptStartOfLine(unsigned LineIndex,
                         WhitespaceManager &Whitespaces) const override;
   void updateNextToken(LineState &State) const override;
   bool mayReflow(unsigned LineIndex,
-                 const llvm::Regex &CommentPragmasRegex) const override;
+                 llvm::Regex const &CommentPragmasRegex) const override;
 
 private:
   // OriginalPrefix[i] contains the original prefix of line i, including
Index: clang/lib/Format/BreakableToken.cpp
===================================================================
--- clang/lib/Format/BreakableToken.cpp
+++ clang/lib/Format/BreakableToken.cpp
@@ -40,7 +40,7 @@
 }
 
 static StringRef getLineCommentIndentPrefix(StringRef Comment,
-                                            const FormatStyle &Style) {
+                                            FormatStyle const &Style) {
   static constexpr StringRef KnownCStylePrefixes[] = {"///<", "//!<", "///",
                                                       "//!",  "//:",  "//"};
   static constexpr StringRef KnownTextProtoPrefixes[] = {"####", "###", "##",
@@ -56,7 +56,7 @@
 
   for (StringRef KnownPrefix : KnownPrefixes) {
     if (Comment.startswith(KnownPrefix)) {
-      const auto PrefixLength =
+      auto const PrefixLength =
           Comment.find_first_not_of(' ', KnownPrefix.size());
       return Comment.substr(0, PrefixLength);
     }
@@ -67,7 +67,7 @@
 static BreakableToken::Split
 getCommentSplit(StringRef Text, unsigned ContentStartColumn,
                 unsigned ColumnLimit, unsigned TabWidth,
-                encoding::Encoding Encoding, const FormatStyle &Style,
+                encoding::Encoding Encoding, FormatStyle const &Style,
                 bool DecorationEndsWithStar = false) {
   LLVM_DEBUG(llvm::dbgs() << "Comment split: \"" << Text
                           << "\", Column limit: " << ColumnLimit
@@ -102,7 +102,7 @@
 
   StringRef::size_type SpaceOffset = Text.find_last_of(Blanks, MaxSplitBytes);
 
-  static const auto kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\.");
+  static auto const kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\.");
   // Some spaces are unacceptable to break on, rewind past them.
   while (SpaceOffset != StringRef::npos) {
     // If a line-comment ends with `\`, the next line continues the comment,
@@ -216,7 +216,7 @@
   return BreakableToken::Split(StringRef::npos, 0);
 }
 
-bool switchesFormatting(const FormatToken &Token) {
+bool switchesFormatting(FormatToken const &Token) {
   assert((Token.is(TT_BlockComment) || Token.is(TT_LineComment)) &&
          "formatting regions are switched by comment tokens");
   StringRef Content = Token.TokenText.substr(2).ltrim();
@@ -265,9 +265,9 @@
 }
 
 BreakableStringLiteral::BreakableStringLiteral(
-    const FormatToken &Tok, unsigned StartColumn, StringRef Prefix,
+    FormatToken const &Tok, unsigned StartColumn, StringRef Prefix,
     StringRef Postfix, unsigned UnbreakableTailLength, bool InPPDirective,
-    encoding::Encoding Encoding, const FormatStyle &Style)
+    encoding::Encoding Encoding, FormatStyle const &Style)
     : BreakableToken(Tok, InPPDirective, Encoding, Style),
       StartColumn(StartColumn), Prefix(Prefix), Postfix(Postfix),
       UnbreakableTailLength(UnbreakableTailLength) {
@@ -278,7 +278,7 @@
 
 BreakableToken::Split BreakableStringLiteral::getSplit(
     unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
-    unsigned ContentStartColumn, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned ContentStartColumn, llvm::Regex const &CommentPragmasRegex) const {
   return getStringSplit(Line.substr(TailOffset), ContentStartColumn,
                         ColumnLimit - Postfix.size(), Style.TabWidth, Encoding);
 }
@@ -292,10 +292,10 @@
       Prefix, InPPDirective, 1, StartColumn);
 }
 
-BreakableComment::BreakableComment(const FormatToken &Token,
+BreakableComment::BreakableComment(FormatToken const &Token,
                                    unsigned StartColumn, bool InPPDirective,
                                    encoding::Encoding Encoding,
-                                   const FormatStyle &Style)
+                                   FormatStyle const &Style)
     : BreakableToken(Token, InPPDirective, Encoding, Style),
       StartColumn(StartColumn) {}
 
@@ -304,7 +304,7 @@
 BreakableToken::Split
 BreakableComment::getSplit(unsigned LineIndex, unsigned TailOffset,
                            unsigned ColumnLimit, unsigned ContentStartColumn,
-                           const llvm::Regex &CommentPragmasRegex) const {
+                           llvm::Regex const &CommentPragmasRegex) const {
   // Don't break lines matching the comment pragmas regex.
   if (CommentPragmasRegex.match(Content[LineIndex]))
     return Split(StringRef::npos, 0);
@@ -329,7 +329,7 @@
       /*InPPDirective=*/false, /*Newlines=*/0, /*Spaces=*/1);
 }
 
-const FormatToken &BreakableComment::tokenAt(unsigned LineIndex) const {
+FormatToken const &BreakableComment::tokenAt(unsigned LineIndex) const {
   return Tokens[LineIndex] ? *Tokens[LineIndex] : Tok;
 }
 
@@ -349,7 +349,7 @@
   // Numbered lists may also start with a number followed by '.'
   // To avoid issues if a line starts with a number which is actually the end
   // of a previous line, we only consider numbers with up to 2 digits.
-  static const auto kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\. ");
+  static auto const kNumberedListRegexp = llvm::Regex("^[1-9][0-9]?\\. ");
   hasSpecialMeaningPrefix =
       hasSpecialMeaningPrefix || kNumberedListRegexp.match(Content);
 
@@ -364,9 +364,9 @@
 }
 
 BreakableBlockComment::BreakableBlockComment(
-    const FormatToken &Token, unsigned StartColumn,
+    FormatToken const &Token, unsigned StartColumn,
     unsigned OriginalStartColumn, bool FirstInLine, bool InPPDirective,
-    encoding::Encoding Encoding, const FormatStyle &Style, bool UseCRLF)
+    encoding::Encoding Encoding, FormatStyle const &Style, bool UseCRLF)
     : BreakableComment(Token, StartColumn, InPPDirective, Encoding, Style),
       DelimitersOnNewline(false),
       UnbreakableTailLength(Token.UnbreakableTailLength) {
@@ -491,7 +491,7 @@
 
 BreakableToken::Split BreakableBlockComment::getSplit(
     unsigned LineIndex, unsigned TailOffset, unsigned ColumnLimit,
-    unsigned ContentStartColumn, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned ContentStartColumn, llvm::Regex const &CommentPragmasRegex) const {
   // Don't break lines matching the comment pragmas regex.
   if (CommentPragmasRegex.match(Content[LineIndex]))
     return Split(StringRef::npos, 0);
@@ -630,7 +630,7 @@
 }
 
 BreakableToken::Split BreakableBlockComment::getReflowSplit(
-    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, llvm::Regex const &CommentPragmasRegex) const {
   if (!mayReflow(LineIndex, CommentPragmasRegex))
     return Split(StringRef::npos, 0);
 
@@ -738,7 +738,7 @@
 }
 
 bool BreakableBlockComment::mayReflow(
-    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, llvm::Regex const &CommentPragmasRegex) const {
   // Content[LineIndex] may exclude the indent after the '*' decoration. In that
   // case, we compute the start of the comment pragma manually.
   StringRef IndentContent = Content[LineIndex];
@@ -751,8 +751,8 @@
 }
 
 BreakableLineCommentSection::BreakableLineCommentSection(
-    const FormatToken &Token, unsigned StartColumn, bool InPPDirective,
-    encoding::Encoding Encoding, const FormatStyle &Style)
+    FormatToken const &Token, unsigned StartColumn, bool InPPDirective,
+    encoding::Encoding Encoding, FormatStyle const &Style)
     : BreakableComment(Token, StartColumn, InPPDirective, Encoding, Style) {
   assert(Tok.is(TT_LineComment) &&
          "line comment section must start with a line comment");
@@ -760,7 +760,7 @@
   // How many spaces we changed in the first line of the section, this will be
   // applied in all following lines
   int FirstLineSpaceChange = 0;
-  for (const FormatToken *CurrentTok = &Tok;
+  for (FormatToken const *CurrentTok = &Tok;
        CurrentTok && CurrentTok->is(TT_LineComment);
        CurrentTok = CurrentTok->Next) {
     LastLineTok = LineTok;
@@ -779,7 +779,7 @@
       Lines[i] = Lines[i].ltrim(Blanks);
       StringRef IndentPrefix = getLineCommentIndentPrefix(Lines[i], Style);
       OriginalPrefix[i] = IndentPrefix;
-      const unsigned SpacesInPrefix =
+      unsigned const SpacesInPrefix =
           std::count(IndentPrefix.begin(), IndentPrefix.end(), ' ');
 
       // On the first line of the comment section we calculate how many spaces
@@ -812,8 +812,8 @@
         }
 
         assert(Lines[i].size() > IndentPrefix.size());
-        const auto FirstNonSpace = Lines[i][IndentPrefix.size()];
-        const auto AllowsSpaceChange =
+        auto const FirstNonSpace = Lines[i][IndentPrefix.size()];
+        auto const AllowsSpaceChange =
             SpacesInPrefix != 0 ||
             (isAlphanumeric(FirstNonSpace) ||
              (FirstNonSpace == '}' && FirstLineSpaceChange != 0));
@@ -901,7 +901,7 @@
 }
 
 BreakableComment::Split BreakableLineCommentSection::getReflowSplit(
-    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, llvm::Regex const &CommentPragmasRegex) const {
   if (!mayReflow(LineIndex, CommentPragmasRegex))
     return Split(StringRef::npos, 0);
 
@@ -995,8 +995,8 @@
   }
   if (OriginalPrefix[LineIndex] != Prefix[LineIndex]) {
     // Adjust the prefix if necessary.
-    const auto SpacesToRemove = -std::min(PrefixSpaceChange[LineIndex], 0);
-    const auto SpacesToAdd = std::max(PrefixSpaceChange[LineIndex], 0);
+    auto const SpacesToRemove = -std::min(PrefixSpaceChange[LineIndex], 0);
+    auto const SpacesToAdd = std::max(PrefixSpaceChange[LineIndex], 0);
     Whitespaces.replaceWhitespaceInToken(
         tokenAt(LineIndex), OriginalPrefix[LineIndex].size() - SpacesToRemove,
         /*ReplaceChars=*/SpacesToRemove, "", "", /*InPPDirective=*/false,
@@ -1011,7 +1011,7 @@
 }
 
 bool BreakableLineCommentSection::mayReflow(
-    unsigned LineIndex, const llvm::Regex &CommentPragmasRegex) const {
+    unsigned LineIndex, llvm::Regex const &CommentPragmasRegex) const {
   // Line comments have the indent as part of the prefix, so we need to
   // recompute the start of the line.
   StringRef IndentContent = Content[LineIndex];
Index: clang/lib/Format/CMakeLists.txt
===================================================================
--- clang/lib/Format/CMakeLists.txt
+++ clang/lib/Format/CMakeLists.txt
@@ -9,6 +9,7 @@
   FormatTokenLexer.cpp
   MacroExpander.cpp
   NamespaceEndCommentsFixer.cpp
+  QualifierAlignmentFixer.cpp
   SortJavaScriptImports.cpp
   TokenAnalyzer.cpp
   TokenAnnotator.cpp
Index: clang/lib/Format/ContinuationIndenter.h
===================================================================
--- clang/lib/Format/ContinuationIndenter.h
+++ clang/lib/Format/ContinuationIndenter.h
@@ -39,7 +39,7 @@
   llvm::StringMap<FormatStyle> DelimiterStyle;
   llvm::StringMap<FormatStyle> EnclosingFunctionStyle;
 
-  RawStringFormatStyleManager(const FormatStyle &CodeStyle);
+  RawStringFormatStyleManager(FormatStyle const &CodeStyle);
 
   llvm::Optional<FormatStyle> getDelimiterStyle(StringRef Delimiter) const;
 
@@ -51,9 +51,9 @@
 public:
   /// Constructs a \c ContinuationIndenter to format \p Line starting in
   /// column \p FirstIndent.
-  ContinuationIndenter(const FormatStyle &Style,
-                       const AdditionalKeywords &Keywords,
-                       const SourceManager &SourceMgr,
+  ContinuationIndenter(FormatStyle const &Style,
+                       AdditionalKeywords const &Keywords,
+                       SourceManager const &SourceMgr,
                        WhitespaceManager &Whitespaces,
                        encoding::Encoding Encoding,
                        bool BinPackInconclusiveFunctions);
@@ -63,15 +63,15 @@
   /// the case of formatting inside raw string literals, \p FirstStartColumn is
   /// the column at which the state of the parent formatter is.
   LineState getInitialState(unsigned FirstIndent, unsigned FirstStartColumn,
-                            const AnnotatedLine *Line, bool DryRun);
+                            AnnotatedLine const *Line, bool DryRun);
 
   // FIXME: canBreak and mustBreak aren't strictly indentation-related. Find a
   // better home.
   /// Returns \c true, if a line break after \p State is allowed.
-  bool canBreak(const LineState &State);
+  bool canBreak(LineState const &State);
 
   /// Returns \c true, if a line break after \p State is mandatory.
-  bool mustBreak(const LineState &State);
+  bool mustBreak(LineState const &State);
 
   /// Appends the next token to \p State and updates information
   /// necessary for indentation.
@@ -86,7 +86,7 @@
 
   /// Get the column limit for this line. This is the style's column
   /// limit, potentially reduced for preprocessor definitions.
-  unsigned getColumnLimit(const LineState &State) const;
+  unsigned getColumnLimit(LineState const &State) const;
 
 private:
   /// Mark the next token as consumed in \p State and modify its stacks
@@ -108,20 +108,20 @@
   /// Reformats a raw string literal.
   ///
   /// \returns An extra penalty induced by reformatting the token.
-  unsigned reformatRawStringLiteral(const FormatToken &Current,
+  unsigned reformatRawStringLiteral(FormatToken const &Current,
                                     LineState &State,
-                                    const FormatStyle &RawStringStyle,
+                                    FormatStyle const &RawStringStyle,
                                     bool DryRun, bool Newline);
 
   /// If the current token is at the end of the current line, handle
   /// the transition to the next line.
-  unsigned handleEndOfLine(const FormatToken &Current, LineState &State,
+  unsigned handleEndOfLine(FormatToken const &Current, LineState &State,
                            bool DryRun, bool AllowBreak, bool Newline);
 
   /// If \p Current is a raw string that is configured to be reformatted,
   /// return the style to be used.
-  llvm::Optional<FormatStyle> getRawStringStyle(const FormatToken &Current,
-                                                const LineState &State);
+  llvm::Optional<FormatStyle> getRawStringStyle(FormatToken const &Current,
+                                                LineState const &State);
 
   /// If the current token sticks out over the end of the line, break
   /// it if possible.
@@ -141,7 +141,7 @@
   /// the column limit where possible; if false, words are allowed to protrude
   /// over the column limit as long as the penalty is less than the penalty
   /// of a break.
-  std::pair<unsigned, bool> breakProtrudingToken(const FormatToken &Current,
+  std::pair<unsigned, bool> breakProtrudingToken(FormatToken const &Current,
                                                  LineState &State,
                                                  bool AllowBreak, bool DryRun,
                                                  bool Strict);
@@ -149,7 +149,7 @@
   /// Returns the \c BreakableToken starting at \p Current, or nullptr
   /// if the current token cannot be broken.
   std::unique_ptr<BreakableToken>
-  createBreakableToken(const FormatToken &Current, LineState &State,
+  createBreakableToken(FormatToken const &Current, LineState &State,
                        bool AllowBreak);
 
   /// Appends the next token to \p State and updates information
@@ -172,25 +172,25 @@
   unsigned addTokenOnNewLine(LineState &State, bool DryRun);
 
   /// Calculate the new column for a line wrap before the next token.
-  unsigned getNewLineColumn(const LineState &State);
+  unsigned getNewLineColumn(LineState const &State);
 
   /// Adds a multiline token to the \p State.
   ///
   /// \returns Extra penalty for the first line of the literal: last line is
   /// handled in \c addNextStateToQueue, and the penalty for other lines doesn't
   /// matter, as we don't change them.
-  unsigned addMultilineToken(const FormatToken &Current, LineState &State);
+  unsigned addMultilineToken(FormatToken const &Current, LineState &State);
 
   /// Returns \c true if the next token starts a multiline string
   /// literal.
   ///
   /// This includes implicitly concatenated strings, strings that will be broken
   /// by clang-format and string literals with escaped newlines.
-  bool nextIsMultilineString(const LineState &State);
+  bool nextIsMultilineString(LineState const &State);
 
   FormatStyle Style;
-  const AdditionalKeywords &Keywords;
-  const SourceManager &SourceMgr;
+  AdditionalKeywords const &Keywords;
+  SourceManager const &SourceMgr;
   WhitespaceManager &Whitespaces;
   encoding::Encoding Encoding;
   bool BinPackInconclusiveFunctions;
@@ -199,7 +199,7 @@
 };
 
 struct ParenState {
-  ParenState(const FormatToken *Tok, unsigned Indent, unsigned LastSpace,
+  ParenState(FormatToken const *Tok, unsigned Indent, unsigned LastSpace,
              bool AvoidBinPacking, bool NoLineBreak)
       : Tok(Tok), Indent(Indent), LastSpace(LastSpace),
         NestedBlockIndent(Indent), IsAligned(false),
@@ -218,7 +218,7 @@
   ///
   /// Not considered for memoization as it will always have the same value at
   /// the same token.
-  const FormatToken *Tok;
+  FormatToken const *Tok;
 
   /// The position to which a specific parenthesis level needs to be
   /// indented.
@@ -349,7 +349,7 @@
   /// operator.
   bool UnindentOperator : 1;
 
-  bool operator<(const ParenState &Other) const {
+  bool operator<(ParenState const &Other) const {
     if (Indent != Other.Indent)
       return Indent < Other.Indent;
     if (LastSpace != Other.LastSpace)
@@ -451,10 +451,10 @@
   /// The line that is being formatted.
   ///
   /// Does not need to be considered for memoization because it doesn't change.
-  const AnnotatedLine *Line;
+  AnnotatedLine const *Line;
 
   /// Comparison operator to be able to used \c LineState in \c map.
-  bool operator<(const LineState &Other) const {
+  bool operator<(LineState const &Other) const {
     if (NextToken != Other.NextToken)
       return NextToken < Other.NextToken;
     if (Column != Other.Column)
Index: clang/lib/Format/ContinuationIndenter.cpp
===================================================================
--- clang/lib/Format/ContinuationIndenter.cpp
+++ clang/lib/Format/ContinuationIndenter.cpp
@@ -29,15 +29,15 @@
 
 // Returns true if a TT_SelectorName should be indented when wrapped,
 // false otherwise.
-static bool shouldIndentWrappedSelectorName(const FormatStyle &Style,
+static bool shouldIndentWrappedSelectorName(FormatStyle const &Style,
                                             LineType LineType) {
   return Style.IndentWrappedFunctionNames || LineType == LT_ObjCMethodDecl;
 }
 
 // Returns the length of everything up to the first possible line break after
 // the ), ], } or > matching \c Tok.
-static unsigned getLengthToMatchingParen(const FormatToken &Tok,
-                                         const std::vector<ParenState> &Stack) {
+static unsigned getLengthToMatchingParen(FormatToken const &Tok,
+                                         std::vector<ParenState> const &Stack) {
   // Normally whether or not a break before T is possible is calculated and
   // stored in T.CanBreakBefore. Braces, array initializers and text proto
   // messages like `key: < ... >` are an exception: a break is possible
@@ -85,7 +85,7 @@
   // corresponds. Returns either a pointer to the matching level or nullptr if
   // LParen is not found in the initial portion of the stack up to
   // MatchingStackIndex.
-  auto FindParenState = [&](const FormatToken *LBrace) -> const ParenState * {
+  auto FindParenState = [&](FormatToken const *LBrace) -> ParenState const * {
     while (MatchingStackIndex >= 0 && Stack[MatchingStackIndex].Tok != LBrace)
       --MatchingStackIndex;
     return MatchingStackIndex >= 0 ? &Stack[MatchingStackIndex] : nullptr;
@@ -98,7 +98,7 @@
     if (End->Next->MatchingParen &&
         End->Next->MatchingParen->isOneOf(
             tok::l_brace, TT_ArrayInitializerLSquare, tok::less)) {
-      const ParenState *State = FindParenState(End->Next->MatchingParen);
+      ParenState const *State = FindParenState(End->Next->MatchingParen);
       if (State && State->BreakBeforeClosingBrace)
         break;
     }
@@ -106,7 +106,7 @@
   return End->TotalLength - Tok.TotalLength + 1;
 }
 
-static unsigned getLengthToNextOperator(const FormatToken &Tok) {
+static unsigned getLengthToNextOperator(FormatToken const &Tok) {
   if (!Tok.NextOperator)
     return 0;
   return Tok.NextOperator->TotalLength - Tok.TotalLength;
@@ -114,14 +114,14 @@
 
 // Returns \c true if \c Tok is the "." or "->" of a call and starts the next
 // segment of a builder type call.
-static bool startsSegmentOfBuilderTypeCall(const FormatToken &Tok) {
+static bool startsSegmentOfBuilderTypeCall(FormatToken const &Tok) {
   return Tok.isMemberAccess() && Tok.Previous && Tok.Previous->closesScope();
 }
 
 // Returns \c true if \c Current starts a new parameter.
-static bool startsNextParameter(const FormatToken &Current,
-                                const FormatStyle &Style) {
-  const FormatToken &Previous = *Current.Previous;
+static bool startsNextParameter(FormatToken const &Current,
+                                FormatStyle const &Style) {
+  FormatToken const &Previous = *Current.Previous;
   if (Current.is(TT_CtorInitializerComma) &&
       Style.BreakConstructorInitializers == FormatStyle::BCIS_BeforeComma)
     return true;
@@ -135,8 +135,8 @@
            Style.BreakInheritanceList != FormatStyle::BILS_BeforeComma));
 }
 
-static bool opensProtoMessageField(const FormatToken &LessTok,
-                                   const FormatStyle &Style) {
+static bool opensProtoMessageField(FormatToken const &LessTok,
+                                   FormatStyle const &Style) {
   if (LessTok.isNot(tok::less))
     return false;
   return Style.Language == FormatStyle::LK_TextProto ||
@@ -173,9 +173,9 @@
 // Returns the canonical delimiter for \p Language, or the empty string if no
 // canonical delimiter is specified.
 static StringRef
-getCanonicalRawStringDelimiter(const FormatStyle &Style,
+getCanonicalRawStringDelimiter(FormatStyle const &Style,
                                FormatStyle::LanguageKind Language) {
-  for (const auto &Format : Style.RawStringFormats) {
+  for (auto const &Format : Style.RawStringFormats) {
     if (Format.Language == Language)
       return StringRef(Format.CanonicalDelimiter);
   }
@@ -183,8 +183,8 @@
 }
 
 RawStringFormatStyleManager::RawStringFormatStyleManager(
-    const FormatStyle &CodeStyle) {
-  for (const auto &RawStringFormat : CodeStyle.RawStringFormats) {
+    FormatStyle const &CodeStyle) {
+  for (auto const &RawStringFormat : CodeStyle.RawStringFormats) {
     llvm::Optional<FormatStyle> LanguageStyle =
         CodeStyle.GetLanguageStyle(RawStringFormat.Language);
     if (!LanguageStyle) {
@@ -223,9 +223,9 @@
   return It->second;
 }
 
-ContinuationIndenter::ContinuationIndenter(const FormatStyle &Style,
-                                           const AdditionalKeywords &Keywords,
-                                           const SourceManager &SourceMgr,
+ContinuationIndenter::ContinuationIndenter(FormatStyle const &Style,
+                                           AdditionalKeywords const &Keywords,
+                                           SourceManager const &SourceMgr,
                                            WhitespaceManager &Whitespaces,
                                            encoding::Encoding Encoding,
                                            bool BinPackInconclusiveFunctions)
@@ -236,7 +236,7 @@
 
 LineState ContinuationIndenter::getInitialState(unsigned FirstIndent,
                                                 unsigned FirstStartColumn,
-                                                const AnnotatedLine *Line,
+                                                AnnotatedLine const *Line,
                                                 bool DryRun) {
   LineState State;
   State.FirstIndent = FirstIndent;
@@ -276,9 +276,9 @@
   return State;
 }
 
-bool ContinuationIndenter::canBreak(const LineState &State) {
-  const FormatToken &Current = *State.NextToken;
-  const FormatToken &Previous = *Current.Previous;
+bool ContinuationIndenter::canBreak(LineState const &State) {
+  FormatToken const &Current = *State.NextToken;
+  FormatToken const &Previous = *Current.Previous;
   assert(&Previous == Current.Previous);
   if (!Current.CanBreakBefore && !(State.Stack.back().BreakBeforeClosingBrace &&
                                    Current.closesBlockOrBlockTypeList(Style)))
@@ -328,9 +328,9 @@
   return !State.Stack.back().NoLineBreak;
 }
 
-bool ContinuationIndenter::mustBreak(const LineState &State) {
-  const FormatToken &Current = *State.NextToken;
-  const FormatToken &Previous = *Current.Previous;
+bool ContinuationIndenter::mustBreak(LineState const &State) {
+  FormatToken const &Current = *State.NextToken;
+  FormatToken const &Previous = *Current.Previous;
   if (Style.BraceWrapping.BeforeLambdaBody && Current.CanBreakBefore &&
       Current.is(TT_LambdaLBrace) && Previous.isNot(TT_LineComment)) {
     auto LambdaBodyLength = getLengthToMatchingParen(Current, State.Stack);
@@ -384,7 +384,7 @@
           getColumnLimit(State))
     return true;
 
-  const FormatToken &BreakConstructorInitializersToken =
+  FormatToken const &BreakConstructorInitializersToken =
       Style.BreakConstructorInitializers == FormatStyle::BCIS_AfterColon
           ? Previous
           : Current;
@@ -540,7 +540,7 @@
 unsigned ContinuationIndenter::addTokenToState(LineState &State, bool Newline,
                                                bool DryRun,
                                                unsigned ExtraSpaces) {
-  const FormatToken &Current = *State.NextToken;
+  FormatToken const &Current = *State.NextToken;
 
   assert(!State.Stack.empty());
   State.NoContinuation = false;
@@ -577,13 +577,13 @@
 void ContinuationIndenter::addTokenOnCurrentLine(LineState &State, bool DryRun,
                                                  unsigned ExtraSpaces) {
   FormatToken &Current = *State.NextToken;
-  const FormatToken &Previous = *State.NextToken->Previous;
+  FormatToken const &Previous = *State.NextToken->Previous;
   if (Current.is(tok::equal) &&
       (State.Line->First->is(tok::kw_for) || Current.NestingLevel == 0) &&
       State.Stack.back().VariablePos == 0) {
     State.Stack.back().VariablePos = State.Column;
     // Move over * and & if they are bound to the variable name.
-    const FormatToken *Tok = &Previous;
+    FormatToken const *Tok = &Previous;
     while (Tok && State.Stack.back().VariablePos >= Tok->ColumnWidth) {
       State.Stack.back().VariablePos -= Tok->ColumnWidth;
       if (Tok->SpacesRequiredBefore != 0)
@@ -692,7 +692,7 @@
   // there is a line-break right after the operator.
   // Exclude relational operators, as there, it is always more desirable to
   // have the LHS 'left' of the RHS.
-  const FormatToken *P = Current.getPreviousNonComment();
+  FormatToken const *P = Current.getPreviousNonComment();
   if (!Current.is(tok::comment) && P &&
       (P->isOneOf(TT_BinaryOperator, tok::comma) ||
        (P->is(TT_ConditionalExpr) && P->is(tok::colon))) &&
@@ -759,7 +759,7 @@
     //       .SecondInnerFunctionCall();
     bool HasTrailingCall = false;
     if (Previous.MatchingParen) {
-      const FormatToken *Next = Previous.MatchingParen->getNextNonComment();
+      FormatToken const *Next = Previous.MatchingParen->getNextNonComment();
       HasTrailingCall = Next && Next->isMemberAccess();
     }
     if (HasTrailingCall && State.Stack.size() > 1 &&
@@ -771,14 +771,14 @@
 unsigned ContinuationIndenter::addTokenOnNewLine(LineState &State,
                                                  bool DryRun) {
   FormatToken &Current = *State.NextToken;
-  const FormatToken &Previous = *State.NextToken->Previous;
+  FormatToken const &Previous = *State.NextToken->Previous;
 
   // Extra penalty that needs to be added because of the way certain line
   // breaks are chosen.
   unsigned Penalty = 0;
 
-  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
-  const FormatToken *NextNonComment = Previous.getNextNonComment();
+  FormatToken const *PreviousNonComment = Current.getPreviousNonComment();
+  FormatToken const *NextNonComment = Previous.getNextNonComment();
   if (!NextNonComment)
     NextNonComment = &Current;
   // The first line break on any NestingLevel causes an extra penalty in order
@@ -974,7 +974,7 @@
   return Penalty;
 }
 
-unsigned ContinuationIndenter::getNewLineColumn(const LineState &State) {
+unsigned ContinuationIndenter::getNewLineColumn(LineState const &State) {
   if (!State.NextToken || !State.NextToken->Previous)
     return 0;
 
@@ -984,13 +984,13 @@
       Current.isNot(TT_CSharpGenericTypeConstraint))
     return State.Stack.back().ColonPos + 2;
 
-  const FormatToken &Previous = *Current.Previous;
+  FormatToken const &Previous = *Current.Previous;
   // If we are continuing an expression, we want to use the continuation indent.
   unsigned ContinuationIndent =
       std::max(State.Stack.back().LastSpace, State.Stack.back().Indent) +
       Style.ContinuationIndentWidth;
-  const FormatToken *PreviousNonComment = Current.getPreviousNonComment();
-  const FormatToken *NextNonComment = Previous.getNextNonComment();
+  FormatToken const *PreviousNonComment = Current.getPreviousNonComment();
+  FormatToken const *NextNonComment = Previous.getNextNonComment();
   if (!NextNonComment)
     NextNonComment = &Current;
 
@@ -1174,9 +1174,9 @@
   return State.Stack.back().Indent;
 }
 
-static bool hasNestedBlockInlined(const FormatToken *Previous,
-                                  const FormatToken &Current,
-                                  const FormatStyle &Style) {
+static bool hasNestedBlockInlined(FormatToken const *Previous,
+                                  FormatToken const &Current,
+                                  FormatStyle const &Style) {
   if (Previous->isNot(tok::l_paren))
     return true;
   if (Previous->ParameterCount > 1)
@@ -1189,7 +1189,7 @@
 unsigned ContinuationIndenter::moveStateToNextToken(LineState &State,
                                                     bool DryRun, bool Newline) {
   assert(State.Stack.size());
-  const FormatToken &Current = *State.NextToken;
+  FormatToken const &Current = *State.NextToken;
 
   if (Current.is(TT_CSharpGenericTypeConstraint))
     State.Stack.back().IsCSharpGenericTypeConstraint = true;
@@ -1219,7 +1219,7 @@
   if (Style.BreakBeforeTernaryOperators && Current.is(tok::question))
     State.Stack.back().QuestionColumn = State.Column;
   if (!Style.BreakBeforeTernaryOperators && Current.isNot(tok::colon)) {
-    const FormatToken *Previous = Current.Previous;
+    FormatToken const *Previous = Current.Previous;
     while (Previous && Previous->isTrailingComment())
       Previous = Previous->Previous;
     if (Previous && Previous->is(tok::question))
@@ -1273,7 +1273,7 @@
     State.Stack.back().LastSpace = State.Column;
 
   // Insert scopes created by fake parenthesis.
-  const FormatToken *Previous = Current.getPreviousNonComment();
+  FormatToken const *Previous = Current.getPreviousNonComment();
 
   // Add special behavior to support a format commonly used for JavaScript
   // closures:
@@ -1336,8 +1336,8 @@
 
 void ContinuationIndenter::moveStatePastFakeLParens(LineState &State,
                                                     bool Newline) {
-  const FormatToken &Current = *State.NextToken;
-  const FormatToken *Previous = Current.getPreviousNonComment();
+  FormatToken const &Current = *State.NextToken;
+  FormatToken const *Previous = Current.getPreviousNonComment();
 
   // Don't add extra indentation for the first fake parenthesis after
   // 'return', assignments or opening <({[. The indentation for these cases
@@ -1444,7 +1444,7 @@
 
 void ContinuationIndenter::moveStatePastScopeOpener(LineState &State,
                                                     bool Newline) {
-  const FormatToken &Current = *State.NextToken;
+  FormatToken const &Current = *State.NextToken;
   if (!Current.opensScope())
     return;
 
@@ -1472,7 +1472,7 @@
     } else {
       NewIndent = State.Stack.back().LastSpace + Style.ContinuationIndentWidth;
     }
-    const FormatToken *NextNoComment = Current.getNextNonComment();
+    FormatToken const *NextNoComment = Current.getNextNonComment();
     bool EndsInComma = Current.MatchingParen &&
                        Current.MatchingParen->Previous &&
                        Current.MatchingParen->Previous->is(tok::comma);
@@ -1536,7 +1536,7 @@
       } else {
         // For ColumnLimit = 0, we have to figure out whether there is or has to
         // be a line break within this call.
-        for (const FormatToken *Tok = &Current;
+        for (FormatToken const *Tok = &Current;
              Tok && Tok != Current.MatchingParen; Tok = Tok->Next) {
           if (Tok->MustBreakBefore ||
               (Tok->CanBreakBefore && Tok->NewlinesBefore > 0)) {
@@ -1586,7 +1586,7 @@
 }
 
 void ContinuationIndenter::moveStatePastScopeCloser(LineState &State) {
-  const FormatToken &Current = *State.NextToken;
+  FormatToken const &Current = *State.NextToken;
   if (!Current.closesScope())
     return;
 
@@ -1611,7 +1611,7 @@
   // line).
   if (State.Stack.back().BreakBeforeParameter && Current.MatchingParen &&
       Current.MatchingParen->Previous) {
-    const FormatToken &CurrentScopeOpener = *Current.MatchingParen->Previous;
+    FormatToken const &CurrentScopeOpener = *Current.MatchingParen->Previous;
     if (CurrentScopeOpener.is(TT_ObjCMethodExpr) &&
         CurrentScopeOpener.MatchingParen) {
       int NecessarySpaceInLine =
@@ -1625,7 +1625,7 @@
 
   if (Current.is(tok::r_square)) {
     // If this ends the array subscript expr, reset the corresponding value.
-    const FormatToken *NextNonComment = Current.getNextNonComment();
+    FormatToken const *NextNonComment = Current.getNextNonComment();
     if (NextNonComment && NextNonComment->isNot(tok::l_square))
       State.Stack.back().StartOfArraySubscripts = 0;
   }
@@ -1660,8 +1660,8 @@
 }
 
 unsigned ContinuationIndenter::reformatRawStringLiteral(
-    const FormatToken &Current, LineState &State,
-    const FormatStyle &RawStringStyle, bool DryRun, bool Newline) {
+    FormatToken const &Current, LineState &State,
+    FormatStyle const &RawStringStyle, bool DryRun, bool Newline) {
   unsigned StartColumn = State.Column - Current.ColumnWidth;
   StringRef OldDelimiter = *getRawStringDelimiter(Current.TokenText);
   StringRef NewDelimiter =
@@ -1778,7 +1778,7 @@
     }
     SourceLocation OriginLoc =
         Current.Tok.getLocation().getLocWithOffset(OldPrefixSize);
-    for (const tooling::Replacement &Fix : Fixes.first) {
+    for (tooling::Replacement const &Fix : Fixes.first) {
       auto Err = Whitespaces.addReplacement(tooling::Replacement(
           SourceMgr, OriginLoc.getLocWithOffset(Fix.getOffset()),
           Fix.getLength(), Fix.getReplacementText()));
@@ -1808,7 +1808,7 @@
   return Fixes.second + PrefixExcessCharacters * Style.PenaltyExcessCharacter;
 }
 
-unsigned ContinuationIndenter::addMultilineToken(const FormatToken &Current,
+unsigned ContinuationIndenter::addMultilineToken(FormatToken const &Current,
                                                  LineState &State) {
   // Break before further function parameters on all levels.
   for (unsigned i = 0, e = State.Stack.size(); i != e; ++i)
@@ -1824,7 +1824,7 @@
   return 0;
 }
 
-unsigned ContinuationIndenter::handleEndOfLine(const FormatToken &Current,
+unsigned ContinuationIndenter::handleEndOfLine(FormatToken const &Current,
                                                LineState &State, bool DryRun,
                                                bool AllowBreak, bool Newline) {
   unsigned Penalty = 0;
@@ -1880,7 +1880,7 @@
 
 // Returns the enclosing function name of a token, or the empty string if not
 // found.
-static StringRef getEnclosingFunctionName(const FormatToken &Current) {
+static StringRef getEnclosingFunctionName(FormatToken const &Current) {
   // Look for: 'function(' or 'function<templates>(' before Current.
   auto Tok = Current.getPreviousNonComment();
   if (!Tok || !Tok->is(tok::l_paren))
@@ -1899,8 +1899,8 @@
 }
 
 llvm::Optional<FormatStyle>
-ContinuationIndenter::getRawStringStyle(const FormatToken &Current,
-                                        const LineState &State) {
+ContinuationIndenter::getRawStringStyle(FormatToken const &Current,
+                                        LineState const &State) {
   if (!Current.isStringLiteral())
     return None;
   auto Delimiter = getRawStringDelimiter(Current.TokenText);
@@ -1917,7 +1917,7 @@
 }
 
 std::unique_ptr<BreakableToken>
-ContinuationIndenter::createBreakableToken(const FormatToken &Current,
+ContinuationIndenter::createBreakableToken(FormatToken const &Current,
                                            LineState &State, bool AllowBreak) {
   unsigned StartColumn = State.Column - Current.ColumnWidth;
   if (Current.isStringLiteral()) {
@@ -1995,7 +1995,7 @@
 }
 
 std::pair<unsigned, bool>
-ContinuationIndenter::breakProtrudingToken(const FormatToken &Current,
+ContinuationIndenter::breakProtrudingToken(FormatToken const &Current,
                                            LineState &State, bool AllowBreak,
                                            bool DryRun, bool Strict) {
   std::unique_ptr<const BreakableToken> Token =
@@ -2373,13 +2373,13 @@
   return {Penalty, Exceeded};
 }
 
-unsigned ContinuationIndenter::getColumnLimit(const LineState &State) const {
+unsigned ContinuationIndenter::getColumnLimit(LineState const &State) const {
   // In preprocessor directives reserve two chars for trailing " \"
   return Style.ColumnLimit - (State.Line->InPPDirective ? 2 : 0);
 }
 
-bool ContinuationIndenter::nextIsMultilineString(const LineState &State) {
-  const FormatToken &Current = *State.NextToken;
+bool ContinuationIndenter::nextIsMultilineString(LineState const &State) {
+  FormatToken const &Current = *State.NextToken;
   if (!Current.isStringLiteral() || Current.is(TT_ImplicitStringLiteral))
     return false;
   // We never consider raw string literals "multiline" for the purpose of
Index: clang/lib/Format/Encoding.h
===================================================================
--- clang/lib/Format/Encoding.h
+++ clang/lib/Format/Encoding.h
@@ -32,8 +32,8 @@
 /// Detects encoding of the Text. If the Text can be decoded using UTF-8,
 /// it is considered UTF8, otherwise we treat it as some 8-bit encoding.
 inline Encoding detectEncoding(StringRef Text) {
-  const llvm::UTF8 *Ptr = reinterpret_cast<const llvm::UTF8 *>(Text.begin());
-  const llvm::UTF8 *BufEnd = reinterpret_cast<const llvm::UTF8 *>(Text.end());
+  llvm::UTF8 const *Ptr = reinterpret_cast<llvm::UTF8 const *>(Text.begin());
+  llvm::UTF8 const *BufEnd = reinterpret_cast<llvm::UTF8 const *>(Text.end());
   if (llvm::isLegalUTF8String(&Ptr, BufEnd))
     return Encoding_UTF8;
   return Encoding_Unknown;
Index: clang/lib/Format/Format.cpp
===================================================================
--- clang/lib/Format/Format.cpp
+++ clang/lib/Format/Format.cpp
@@ -19,6 +19,7 @@
 #include "FormatInternal.h"
 #include "FormatTokenLexer.h"
 #include "NamespaceEndCommentsFixer.h"
+#include "QualifierAlignmentFixer.h"
 #include "SortJavaScriptImports.h"
 #include "TokenAnalyzer.h"
 #include "TokenAnnotator.h"
@@ -126,6 +127,16 @@
   }
 };
 
+template <>
+struct ScalarEnumerationTraits<FormatStyle::QualifierAlignmentStyle> {
+  static void enumeration(IO &IO, FormatStyle::QualifierAlignmentStyle &Value) {
+    IO.enumCase(Value, "Leave", FormatStyle::QAS_Leave);
+    IO.enumCase(Value, "Left", FormatStyle::QAS_Left);
+    IO.enumCase(Value, "Right", FormatStyle::QAS_Right);
+    IO.enumCase(Value, "Custom", FormatStyle::QAS_Custom);
+  }
+};
+
 template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
   static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
     IO.enumCase(Value, "None", FormatStyle::SFS_None);
@@ -641,6 +652,23 @@
     IO.mapOptional("BreakStringLiterals", Style.BreakStringLiterals);
     IO.mapOptional("ColumnLimit", Style.ColumnLimit);
     IO.mapOptional("CommentPragmas", Style.CommentPragmas);
+    IO.mapOptional("QualifierAlignment", Style.QualifierAlignment);
+
+    // Default Order for Left/Right based Qualifier alignment.
+    if (Style.QualifierAlignment == FormatStyle::QAS_Right) {
+      Style.QualifierOrder.clear();
+      Style.QualifierOrder.push_back("type");
+      Style.QualifierOrder.push_back("const");
+      Style.QualifierOrder.push_back("volatile");
+    } else if (Style.QualifierAlignment == FormatStyle::QAS_Left) {
+      Style.QualifierOrder.clear();
+      Style.QualifierOrder.push_back("const");
+      Style.QualifierOrder.push_back("volatile");
+      Style.QualifierOrder.push_back("type");
+    }
+
+    IO.mapOptional("QualifierOrder", Style.QualifierOrder);
+
     IO.mapOptional("CompactNamespaces", Style.CompactNamespaces);
     IO.mapOptional("ConstructorInitializerIndentWidth",
                    Style.ConstructorInitializerIndentWidth);
@@ -668,7 +696,7 @@
     // value, set the latter to an equivalent non-default value if needed.
     StringRef BasedOn;
     IO.mapOptional("BasedOnStyle", BasedOn);
-    const bool IsGoogleOrChromium = BasedOn.equals_insensitive("google") ||
+    bool const IsGoogleOrChromium = BasedOn.equals_insensitive("google") ||
                                     BasedOn.equals_insensitive("chromium");
     bool OnCurrentLine = IsGoogleOrChromium;
     bool OnNextLine = true;
@@ -864,7 +892,7 @@
       if (!Seq.empty() && Seq[0].Language == FormatStyle::LK_None) {
         Template = Seq[0];
       } else {
-        Template = *((const FormatStyle *)IO.getContext());
+        Template = *((FormatStyle const *)IO.getContext());
         Template.Language = FormatStyle::LK_None;
       }
       Seq.resize(Index + 1, Template);
@@ -878,7 +906,7 @@
 namespace clang {
 namespace format {
 
-const std::error_category &getParseCategory() {
+std::error_category const &getParseCategory() {
   static const ParseErrorCategory C{};
   return C;
 }
@@ -886,12 +914,12 @@
   return std::error_code(static_cast<int>(e), getParseCategory());
 }
 
-inline llvm::Error make_string_error(const llvm::Twine &Message) {
+inline llvm::Error make_string_error(llvm::Twine const &Message) {
   return llvm::make_error<llvm::StringError>(Message,
                                              llvm::inconvertibleErrorCode());
 }
 
-const char *ParseErrorCategory::name() const noexcept {
+char const *ParseErrorCategory::name() const noexcept {
   return "clang-format.parse_error";
 }
 
@@ -905,11 +933,19 @@
     return "Unsuitable";
   case ParseError::BinPackTrailingCommaConflict:
     return "trailing comma insertion cannot be used with bin packing";
+  case ParseError::InvalidQualifierSpecified:
+    return "Invalid qualifier specified in QualifierOrder";
+  case ParseError::DuplicateQualifierSpecified:
+    return "Duplicate qualifier specified in QualfierOrder";
+  case ParseError::MissingQualifierType:
+    return "Missing type in QualfierOrder";
+  case ParseError::MissingQualifierOrder:
+    return "Missing QualfierOrder";
   }
   llvm_unreachable("unexpected parse error");
 }
 
-static FormatStyle expandPresets(const FormatStyle &Style) {
+static FormatStyle expandPresets(FormatStyle const &Style) {
   if (Style.BreakBeforeBraces == FormatStyle::BS_Custom)
     return Style;
   FormatStyle Expanded = Style;
@@ -1078,6 +1114,16 @@
   LLVMStyle.ConstructorInitializerIndentWidth = 4;
   LLVMStyle.ContinuationIndentWidth = 4;
   LLVMStyle.Cpp11BracedListStyle = true;
+
+  // Off by default Qualifier ordering
+  LLVMStyle.QualifierAlignment = FormatStyle::QAS_Leave;
+  // Default 'Left' qualifier order but off by default.
+  LLVMStyle.QualifierOrder.push_back("inline");
+  LLVMStyle.QualifierOrder.push_back("static");
+  LLVMStyle.QualifierOrder.push_back("const");
+  LLVMStyle.QualifierOrder.push_back("volatile");
+  LLVMStyle.QualifierOrder.push_back("type");
+
   LLVMStyle.DeriveLineEnding = true;
   LLVMStyle.DerivePointerAlignment = false;
   LLVMStyle.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
@@ -1512,6 +1558,37 @@
   return true;
 }
 
+ParseError validateQualifierOrder(FormatStyle *Style) {
+  // If its empty then it means don't do anything.
+  if (Style->QualifierOrder.empty())
+    return ParseError::MissingQualifierOrder;
+
+  // Ensure the list contains only currently valid qualifiers.
+  for (auto const &Qualifier : Style->QualifierOrder) {
+    if (Qualifier == "type")
+      continue;
+    auto token =
+        LeftRightQualifierAlignmentFixer::getTokenFromQualifier(Qualifier);
+    if (token == tok::identifier)
+      return ParseError::InvalidQualifierSpecified;
+  }
+  // Ensure the list is unqiue (no duplicates).
+  std::set<std::string> UniqueQualifiers(Style->QualifierOrder.begin(),
+                                         Style->QualifierOrder.end());
+  if (Style->QualifierOrder.size() != UniqueQualifiers.size()) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "Duplicate Qualifiers " << Style->QualifierOrder.size()
+               << " vs " << UniqueQualifiers.size() << "\n");
+    return ParseError::DuplicateQualifierSpecified;
+  }
+
+  auto type = std::find(Style->QualifierOrder.begin(),
+                        Style->QualifierOrder.end(), "type");
+  if (type == Style->QualifierOrder.end())
+    return ParseError::MissingQualifierType;
+  return ParseError::Success;
+}
+
 std::error_code parseConfiguration(llvm::MemoryBufferRef Config,
                                    FormatStyle *Style, bool AllowUnknownOptions,
                                    llvm::SourceMgr::DiagHandlerTy DiagHandler,
@@ -1573,10 +1650,12 @@
     // See comment on FormatStyle::TSC_Wrapped.
     return make_error_code(ParseError::BinPackTrailingCommaConflict);
   }
+  if (Style->QualifierAlignment != FormatStyle::QAS_Leave)
+    return make_error_code(validateQualifierOrder(Style));
   return make_error_code(ParseError::Success);
 }
 
-std::string configurationAsText(const FormatStyle &Style) {
+std::string configurationAsText(FormatStyle const &Style) {
   std::string Text;
   llvm::raw_string_ostream Stream(Text);
   llvm::yaml::Output Output(Stream);
@@ -1621,7 +1700,7 @@
 
 class JavaScriptRequoter : public TokenAnalyzer {
 public:
-  JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
+  JavaScriptRequoter(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style) {}
 
   std::pair<tooling::Replacements, unsigned>
@@ -1708,7 +1787,7 @@
 
 class Formatter : public TokenAnalyzer {
 public:
-  Formatter(const Environment &Env, const FormatStyle &Style,
+  Formatter(Environment const &Env, FormatStyle const &Style,
             FormattingAttemptStatus *Status)
       : TokenAnalyzer(Env, Style), Status(Status) {}
 
@@ -1744,7 +1823,7 @@
                     /*FirstStartColumn=*/Env.getFirstStartColumn(),
                     /*NextStartColumn=*/Env.getNextStartColumn(),
                     /*LastStartColumn=*/Env.getLastStartColumn());
-    for (const auto &R : Whitespaces.generateReplacements())
+    for (auto const &R : Whitespaces.generateReplacements())
       if (Result.add(R))
         return std::make_pair(Result, 0);
     return std::make_pair(Result, Penalty);
@@ -1758,8 +1837,8 @@
   }
 
   bool
-  hasCpp03IncompatibleFormat(const SmallVectorImpl<AnnotatedLine *> &Lines) {
-    for (const AnnotatedLine *Line : Lines) {
+  hasCpp03IncompatibleFormat(SmallVectorImpl<AnnotatedLine *> const &Lines) {
+    for (AnnotatedLine const *Line : Lines) {
       if (hasCpp03IncompatibleFormat(Line->Children))
         return true;
       for (FormatToken *Tok = Line->First->Next; Tok; Tok = Tok->Next) {
@@ -1775,9 +1854,9 @@
     return false;
   }
 
-  int countVariableAlignments(const SmallVectorImpl<AnnotatedLine *> &Lines) {
+  int countVariableAlignments(SmallVectorImpl<AnnotatedLine *> const &Lines) {
     int AlignmentDiff = 0;
-    for (const AnnotatedLine *Line : Lines) {
+    for (AnnotatedLine const *Line : Lines) {
       AlignmentDiff += countVariableAlignments(Line->Children);
       for (FormatToken *Tok = Line->First; Tok && Tok->Next; Tok = Tok->Next) {
         if (!Tok->is(TT_PointerOrReference))
@@ -1796,7 +1875,7 @@
   }
 
   void
-  deriveLocalStyle(const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
+  deriveLocalStyle(SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
     bool HasBinPackedFunction = false;
     bool HasOnePerLineFunction = false;
     for (unsigned i = 0, e = AnnotatedLines.size(); i != e; ++i) {
@@ -1843,7 +1922,7 @@
 /// is conceptually incompatible with bin packing.
 class TrailingCommaInserter : public TokenAnalyzer {
 public:
-  TrailingCommaInserter(const Environment &Env, const FormatStyle &Style)
+  TrailingCommaInserter(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style) {}
 
   std::pair<tooling::Replacements, unsigned>
@@ -1903,7 +1982,7 @@
 // file.
 class Cleaner : public TokenAnalyzer {
 public:
-  Cleaner(const Environment &Env, const FormatStyle &Style)
+  Cleaner(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style),
         DeletedTokens(FormatTokenLess(Env.getSourceManager())) {}
 
@@ -1946,7 +2025,7 @@
     }
   }
 
-  bool containsOnlyComments(const AnnotatedLine &Line) {
+  bool containsOnlyComments(AnnotatedLine const &Line) {
     for (FormatToken *Tok = Line.First; Tok != nullptr; Tok = Tok->Next) {
       if (Tok->isNot(tok::comment))
         return false;
@@ -2037,7 +2116,7 @@
   template <typename LeftKind, typename RightKind>
   void cleanupPair(FormatToken *Start, LeftKind LK, RightKind RK,
                    bool DeleteLeft) {
-    auto NextNotDeleted = [this](const FormatToken &Tok) -> FormatToken * {
+    auto NextNotDeleted = [this](FormatToken const &Tok) -> FormatToken * {
       for (auto *Res = Tok.Next; Res; Res = Res->Next)
         if (!Res->is(tok::comment) &&
             DeletedTokens.find(Res) == DeletedTokens.end())
@@ -2113,13 +2192,13 @@
   // We store tokens in the order they appear in the translation unit so that
   // we do not need to sort them in `generateFixes()`.
   struct FormatTokenLess {
-    FormatTokenLess(const SourceManager &SM) : SM(SM) {}
+    FormatTokenLess(SourceManager const &SM) : SM(SM) {}
 
-    bool operator()(const FormatToken *LHS, const FormatToken *RHS) const {
+    bool operator()(FormatToken const *LHS, FormatToken const *RHS) const {
       return SM.isBeforeInTranslationUnit(LHS->Tok.getLocation(),
                                           RHS->Tok.getLocation());
     }
-    const SourceManager &SM;
+    SourceManager const &SM;
   };
 
   // Tokens to be deleted.
@@ -2128,7 +2207,7 @@
 
 class ObjCHeaderStyleGuesser : public TokenAnalyzer {
 public:
-  ObjCHeaderStyleGuesser(const Environment &Env, const FormatStyle &Style)
+  ObjCHeaderStyleGuesser(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style), IsObjC(false) {}
 
   std::pair<tooling::Replacements, unsigned>
@@ -2146,9 +2225,9 @@
 
 private:
   static bool
-  guessIsObjC(const SourceManager &SourceManager,
-              const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
-              const AdditionalKeywords &Keywords) {
+  guessIsObjC(SourceManager const &SourceManager,
+              SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines,
+              AdditionalKeywords const &Keywords) {
     // Keep this array sorted, since we are binary searching over it.
     static constexpr llvm::StringLiteral FoundationIdentifiers[] = {
         "CGFloat",
@@ -2228,7 +2307,7 @@
                           Line->First->TokenText == "__pragma" ||
                           Line->First->TokenText == "_Pragma"))
         continue;
-      for (const FormatToken *FormatTok = Line->First; FormatTok;
+      for (FormatToken const *FormatTok = Line->First; FormatTok;
            FormatTok = FormatTok->Next) {
         if ((FormatTok->Previous && FormatTok->Previous->is(tok::at) &&
              (FormatTok->Tok.getObjCKeywordID() != tok::objc_not_keyword ||
@@ -2299,8 +2378,8 @@
 // its current line.
 // If `Cursor` is not on any #include, `Index` will be UINT_MAX.
 static std::pair<unsigned, unsigned>
-FindCursorIndex(const SmallVectorImpl<IncludeDirective> &Includes,
-                const SmallVectorImpl<unsigned> &Indices, unsigned Cursor) {
+FindCursorIndex(SmallVectorImpl<IncludeDirective> const &Includes,
+                SmallVectorImpl<unsigned> const &Indices, unsigned Cursor) {
   unsigned CursorIndex = UINT_MAX;
   unsigned OffsetToEOL = 0;
   for (int i = 0, e = Includes.size(); i != e; ++i) {
@@ -2320,7 +2399,7 @@
 }
 
 // Replace all "\r\n" with "\n".
-std::string replaceCRLF(const std::string &Code) {
+std::string replaceCRLF(std::string const &Code) {
   std::string NewCode;
   size_t Pos = 0, LastPos = 0;
 
@@ -2348,8 +2427,8 @@
 // first #include in the duplicate #includes remains. If the `Cursor` is
 // provided and put on a deleted #include, it will be moved to the remaining
 // #include in the duplicate #includes.
-static void sortCppIncludes(const FormatStyle &Style,
-                            const SmallVectorImpl<IncludeDirective> &Includes,
+static void sortCppIncludes(FormatStyle const &Style,
+                            SmallVectorImpl<IncludeDirective> const &Includes,
                             ArrayRef<tooling::Range> Ranges, StringRef FileName,
                             StringRef Code, tooling::Replacements &Replaces,
                             unsigned *Cursor) {
@@ -2443,12 +2522,12 @@
 
 namespace {
 
-const char CppIncludeRegexPattern[] =
+char const CppIncludeRegexPattern[] =
     R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
 
 } // anonymous namespace
 
-tooling::Replacements sortCppIncludes(const FormatStyle &Style, StringRef Code,
+tooling::Replacements sortCppIncludes(FormatStyle const &Style, StringRef Code,
                                       ArrayRef<tooling::Range> Ranges,
                                       StringRef FileName,
                                       tooling::Replacements &Replaces,
@@ -2485,7 +2564,7 @@
              Trimmed == "/* clang-format on */")
       FormattingOff = false;
 
-    const bool EmptyLineSkipped =
+    bool const EmptyLineSkipped =
         Trimmed.empty() &&
         (Style.IncludeStyle.IncludeBlocks == tooling::IncludeStyle::IBS_Merge ||
          Style.IncludeStyle.IncludeBlocks ==
@@ -2530,7 +2609,7 @@
 
 // Returns group number to use as a first order sort on imports. Gives UINT_MAX
 // if the import does not match any given groups.
-static unsigned findJavaImportGroup(const FormatStyle &Style,
+static unsigned findJavaImportGroup(FormatStyle const &Style,
                                     StringRef ImportIdentifier) {
   unsigned LongestMatchIndex = UINT_MAX;
   unsigned LongestMatchLength = 0;
@@ -2550,8 +2629,8 @@
 // Import declarations with the same text will be deduplicated. Between each
 // import group, a newline is inserted, and within each import group, a
 // lexicographic sort based on ASCII value is performed.
-static void sortJavaImports(const FormatStyle &Style,
-                            const SmallVectorImpl<JavaImportDirective> &Imports,
+static void sortJavaImports(FormatStyle const &Style,
+                            SmallVectorImpl<JavaImportDirective> const &Imports,
                             ArrayRef<tooling::Range> Ranges, StringRef FileName,
                             StringRef Code, tooling::Replacements &Replaces) {
   unsigned ImportsBeginOffset = Imports.front().Offset;
@@ -2624,12 +2703,12 @@
 
 namespace {
 
-const char JavaImportRegexPattern[] =
+char const JavaImportRegexPattern[] =
     "^[\t ]*import[\t ]+(static[\t ]*)?([^\t ]*)[\t ]*;";
 
 } // anonymous namespace
 
-tooling::Replacements sortJavaImports(const FormatStyle &Style, StringRef Code,
+tooling::Replacements sortJavaImports(FormatStyle const &Style, StringRef Code,
                                       ArrayRef<tooling::Range> Ranges,
                                       StringRef FileName,
                                       tooling::Replacements &Replaces) {
@@ -2691,7 +2770,7 @@
 
 bool isLikelyXml(StringRef Code) { return Code.ltrim().startswith("<"); }
 
-tooling::Replacements sortIncludes(const FormatStyle &Style, StringRef Code,
+tooling::Replacements sortIncludes(FormatStyle const &Style, StringRef Code,
                                    ArrayRef<tooling::Range> Ranges,
                                    StringRef FileName, unsigned *Cursor) {
   tooling::Replacements Replaces;
@@ -2713,8 +2792,8 @@
 template <typename T>
 static llvm::Expected<tooling::Replacements>
 processReplacements(T ProcessFunc, StringRef Code,
-                    const tooling::Replacements &Replaces,
-                    const FormatStyle &Style) {
+                    tooling::Replacements const &Replaces,
+                    FormatStyle const &Style) {
   if (Replaces.empty())
     return tooling::Replacements();
 
@@ -2731,11 +2810,11 @@
 }
 
 llvm::Expected<tooling::Replacements>
-formatReplacements(StringRef Code, const tooling::Replacements &Replaces,
-                   const FormatStyle &Style) {
+formatReplacements(StringRef Code, tooling::Replacements const &Replaces,
+                   FormatStyle const &Style) {
   // We need to use lambda function here since there are two versions of
   // `sortIncludes`.
-  auto SortIncludes = [](const FormatStyle &Style, StringRef Code,
+  auto SortIncludes = [](FormatStyle const &Style, StringRef Code,
                          std::vector<tooling::Range> Ranges,
                          StringRef FileName) -> tooling::Replacements {
     return sortIncludes(Style, Code, Ranges, FileName);
@@ -2747,7 +2826,7 @@
 
   // We need to use lambda function here since there are two versions of
   // `reformat`.
-  auto Reformat = [](const FormatStyle &Style, StringRef Code,
+  auto Reformat = [](FormatStyle const &Style, StringRef Code,
                      std::vector<tooling::Range> Ranges,
                      StringRef FileName) -> tooling::Replacements {
     return reformat(Style, Code, Ranges, FileName);
@@ -2757,27 +2836,27 @@
 
 namespace {
 
-inline bool isHeaderInsertion(const tooling::Replacement &Replace) {
+inline bool isHeaderInsertion(tooling::Replacement const &Replace) {
   return Replace.getOffset() == UINT_MAX && Replace.getLength() == 0 &&
          llvm::Regex(CppIncludeRegexPattern)
              .match(Replace.getReplacementText());
 }
 
-inline bool isHeaderDeletion(const tooling::Replacement &Replace) {
+inline bool isHeaderDeletion(tooling::Replacement const &Replace) {
   return Replace.getOffset() == UINT_MAX && Replace.getLength() == 1;
 }
 
 // FIXME: insert empty lines between newly created blocks.
 tooling::Replacements
-fixCppIncludeInsertions(StringRef Code, const tooling::Replacements &Replaces,
-                        const FormatStyle &Style) {
+fixCppIncludeInsertions(StringRef Code, tooling::Replacements const &Replaces,
+                        FormatStyle const &Style) {
   if (!Style.isCpp())
     return Replaces;
 
   tooling::Replacements HeaderInsertions;
   std::set<llvm::StringRef> HeadersToDelete;
   tooling::Replacements Result;
-  for (const auto &R : Replaces) {
+  for (auto const &R : Replaces) {
     if (isHeaderInsertion(R)) {
       // Replacements from \p Replaces must be conflict-free already, so we can
       // simply consume the error.
@@ -2798,10 +2877,10 @@
   StringRef FileName = Replaces.begin()->getFilePath();
   tooling::HeaderIncludes Includes(FileName, Code, Style.IncludeStyle);
 
-  for (const auto &Header : HeadersToDelete) {
+  for (auto const &Header : HeadersToDelete) {
     tooling::Replacements Replaces =
         Includes.remove(Header.trim("\"<>"), Header.startswith("<"));
-    for (const auto &R : Replaces) {
+    for (auto const &R : Replaces) {
       auto Err = Result.add(R);
       if (Err) {
         // Ignore the deletion on conflict.
@@ -2814,7 +2893,7 @@
 
   llvm::Regex IncludeRegex = llvm::Regex(CppIncludeRegexPattern);
   llvm::SmallVector<StringRef, 4> Matches;
-  for (const auto &R : HeaderInsertions) {
+  for (auto const &R : HeaderInsertions) {
     auto IncludeDirective = R.getReplacementText();
     bool Matched = IncludeRegex.match(IncludeDirective, &Matches);
     assert(Matched && "Header insertion replacement must have replacement text "
@@ -2841,11 +2920,11 @@
 } // anonymous namespace
 
 llvm::Expected<tooling::Replacements>
-cleanupAroundReplacements(StringRef Code, const tooling::Replacements &Replaces,
-                          const FormatStyle &Style) {
+cleanupAroundReplacements(StringRef Code, tooling::Replacements const &Replaces,
+                          FormatStyle const &Style) {
   // We need to use lambda function here since there are two versions of
   // `cleanup`.
-  auto Cleanup = [](const FormatStyle &Style, StringRef Code,
+  auto Cleanup = [](FormatStyle const &Style, StringRef Code,
                     std::vector<tooling::Range> Ranges,
                     StringRef FileName) -> tooling::Replacements {
     return cleanup(Style, Code, Ranges, FileName);
@@ -2857,8 +2936,9 @@
 }
 
 namespace internal {
+
 std::pair<tooling::Replacements, unsigned>
-reformat(const FormatStyle &Style, StringRef Code,
+reformat(FormatStyle const &Style, StringRef Code,
          ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
          unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
          FormattingAttemptStatus *Status) {
@@ -2890,35 +2970,44 @@
   }
 
   typedef std::function<std::pair<tooling::Replacements, unsigned>(
-      const Environment &)>
+      Environment const &)>
       AnalyzerPass;
   SmallVector<AnalyzerPass, 4> Passes;
 
+  if (Style.isCpp() && Style.QualifierAlignment != FormatStyle::QAS_Leave) {
+    Passes.emplace_back([&](Environment const &Env) {
+      return QualifierAlignmentFixer(Env, Expanded, Code, Ranges,
+                                     FirstStartColumn, NextStartColumn,
+                                     LastStartColumn, FileName)
+          .process();
+    });
+  }
+
   if (Style.Language == FormatStyle::LK_Cpp) {
     if (Style.FixNamespaceComments)
-      Passes.emplace_back([&](const Environment &Env) {
+      Passes.emplace_back([&](Environment const &Env) {
         return NamespaceEndCommentsFixer(Env, Expanded).process();
       });
 
     if (Style.SortUsingDeclarations)
-      Passes.emplace_back([&](const Environment &Env) {
+      Passes.emplace_back([&](Environment const &Env) {
         return UsingDeclarationsSorter(Env, Expanded).process();
       });
   }
 
   if (Style.Language == FormatStyle::LK_JavaScript &&
       Style.JavaScriptQuotes != FormatStyle::JSQS_Leave)
-    Passes.emplace_back([&](const Environment &Env) {
+    Passes.emplace_back([&](Environment const &Env) {
       return JavaScriptRequoter(Env, Expanded).process();
     });
 
-  Passes.emplace_back([&](const Environment &Env) {
+  Passes.emplace_back([&](Environment const &Env) {
     return Formatter(Env, Expanded, Status).process();
   });
 
   if (Style.Language == FormatStyle::LK_JavaScript &&
       Style.InsertTrailingCommas == FormatStyle::TCS_Wrapped)
-    Passes.emplace_back([&](const Environment &Env) {
+    Passes.emplace_back([&](Environment const &Env) {
       return TrailingCommaInserter(Env, Expanded).process();
     });
 
@@ -2949,7 +3038,7 @@
 }
 } // namespace internal
 
-tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
+tooling::Replacements reformat(FormatStyle const &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName,
                                FormattingAttemptStatus *Status) {
@@ -2960,7 +3049,7 @@
       .first;
 }
 
-tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code,
+tooling::Replacements cleanup(FormatStyle const &Style, StringRef Code,
                               ArrayRef<tooling::Range> Ranges,
                               StringRef FileName) {
   // cleanups only apply to C++ (they mostly concern ctor commas etc.)
@@ -2969,7 +3058,7 @@
   return Cleaner(Environment(Code, FileName, Ranges), Style).process().first;
 }
 
-tooling::Replacements reformat(const FormatStyle &Style, StringRef Code,
+tooling::Replacements reformat(FormatStyle const &Style, StringRef Code,
                                ArrayRef<tooling::Range> Ranges,
                                StringRef FileName, bool *IncompleteFormat) {
   FormattingAttemptStatus Status;
@@ -2979,7 +3068,7 @@
   return Result;
 }
 
-tooling::Replacements fixNamespaceEndComments(const FormatStyle &Style,
+tooling::Replacements fixNamespaceEndComments(FormatStyle const &Style,
                                               StringRef Code,
                                               ArrayRef<tooling::Range> Ranges,
                                               StringRef FileName) {
@@ -2988,7 +3077,7 @@
       .first;
 }
 
-tooling::Replacements sortUsingDeclarations(const FormatStyle &Style,
+tooling::Replacements sortUsingDeclarations(FormatStyle const &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName) {
@@ -2997,7 +3086,7 @@
       .first;
 }
 
-LangOptions getFormattingLangOpts(const FormatStyle &Style) {
+LangOptions getFormattingLangOpts(FormatStyle const &Style) {
   LangOptions LangOpts;
 
   FormatStyle::LanguageStandard LexingStd = Style.Standard;
@@ -3023,7 +3112,7 @@
   return LangOpts;
 }
 
-const char *StyleOptionHelpDescription =
+char const *StyleOptionHelpDescription =
     "Coding style, currently supports:\n"
     "  LLVM, GNU, Google, Chromium, Microsoft, Mozilla, WebKit.\n"
     "Use -style=file to load style configuration from\n"
@@ -3061,7 +3150,7 @@
 }
 
 FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code) {
-  const auto GuessedLanguage = getLanguageByFileName(FileName);
+  auto const GuessedLanguage = getLanguageByFileName(FileName);
   if (GuessedLanguage == FormatStyle::LK_Cpp) {
     auto Extension = llvm::sys::path::extension(FileName);
     // If there's no file extension (or it's .h), we need to check the contents
@@ -3078,9 +3167,9 @@
   return GuessedLanguage;
 }
 
-const char *DefaultFormatStyle = "file";
+char const *DefaultFormatStyle = "file";
 
-const char *DefaultFallbackStyle = "LLVM";
+char const *DefaultFallbackStyle = "LLVM";
 
 llvm::Expected<FormatStyle> getStyle(StringRef StyleName, StringRef FileName,
                                      StringRef FallbackStyleName,
@@ -3135,7 +3224,7 @@
   FilesToLookFor.push_back(".clang-format");
   FilesToLookFor.push_back("_clang-format");
 
-  auto dropDiagnosticHandler = [](const llvm::SMDiagnostic &, void *) {};
+  auto dropDiagnosticHandler = [](llvm::SMDiagnostic const &, void *) {};
 
   for (StringRef Directory = Path; !Directory.empty();
        Directory = llvm::sys::path::parent_path(Directory)) {
@@ -3146,7 +3235,7 @@
       continue;
     }
 
-    for (const auto &F : FilesToLookFor) {
+    for (auto const &F : FilesToLookFor) {
       SmallString<128> ConfigFile(Directory);
 
       llvm::sys::path::append(ConfigFile, F);
@@ -3180,7 +3269,7 @@
 
           LLVM_DEBUG(llvm::dbgs() << "Applying child configurations\n");
 
-          for (const auto &MemBuf : llvm::reverse(ChildFormatTextToApply)) {
+          for (auto const &MemBuf : llvm::reverse(ChildFormatTextToApply)) {
             auto Ec = parseConfiguration(*MemBuf, &Style, AllowUnknownOptions,
                                          dropDiagnosticHandler);
             // It was already correctly parsed.
Index: clang/lib/Format/FormatInternal.h
===================================================================
--- clang/lib/Format/FormatInternal.h
+++ clang/lib/Format/FormatInternal.h
@@ -69,7 +69,7 @@
 /// If ``Status`` is non-null, its value will be populated with the status of
 /// this formatting attempt. See \c FormattingAttemptStatus.
 std::pair<tooling::Replacements, unsigned>
-reformat(const FormatStyle &Style, StringRef Code,
+reformat(FormatStyle const &Style, StringRef Code,
          ArrayRef<tooling::Range> Ranges, unsigned FirstStartColumn,
          unsigned NextStartColumn, unsigned LastStartColumn, StringRef FileName,
          FormattingAttemptStatus *Status);
Index: clang/lib/Format/FormatToken.h
===================================================================
--- clang/lib/Format/FormatToken.h
+++ clang/lib/Format/FormatToken.h
@@ -130,7 +130,7 @@
 };
 
 /// Determines the name of a token type.
-const char *getTokenTypeName(TokenType Type);
+char const *getTokenTypeName(TokenType Type);
 
 // Represents what type of block a set of braces open.
 enum BraceBlockKind { BK_Unknown, BK_Block, BK_BracedInit };
@@ -451,7 +451,7 @@
 
   bool is(tok::TokenKind Kind) const { return Tok.is(Kind); }
   bool is(TokenType TT) const { return getType() == TT; }
-  bool is(const IdentifierInfo *II) const {
+  bool is(IdentifierInfo const *II) const {
     return II && II == Tok.getIdentifierInfo();
   }
   bool is(tok::PPKeywordKind Kind) const {
@@ -645,8 +645,8 @@
   }
 
   /// Returns the next token ignoring comments.
-  const FormatToken *getNextNonComment() const {
-    const FormatToken *Tok = Next;
+  FormatToken const *getNextNonComment() const {
+    FormatToken const *Tok = Next;
     while (Tok && Tok->is(tok::comment))
       Tok = Tok->Next;
     return Tok;
@@ -654,7 +654,7 @@
 
   /// Returns \c true if this tokens starts a block-type list, i.e. a
   /// list that should be indented with a block indent.
-  bool opensBlockOrBlockTypeList(const FormatStyle &Style) const {
+  bool opensBlockOrBlockTypeList(FormatStyle const &Style) const {
     // C# Does not indent object initialisers as continuations.
     if (is(tok::l_brace) && getBlockKind() == BK_BracedInit && Style.isCSharp())
       return true;
@@ -670,10 +670,10 @@
 
   /// Returns whether the token is the left square bracket of a C++
   /// structured binding declaration.
-  bool isCppStructuredBinding(const FormatStyle &Style) const {
+  bool isCppStructuredBinding(FormatStyle const &Style) const {
     if (!Style.isCpp() || isNot(tok::l_square))
       return false;
-    const FormatToken *T = this;
+    FormatToken const *T = this;
     do {
       T = T->getPreviousNonComment();
     } while (T && T->isOneOf(tok::kw_const, tok::kw_volatile, tok::amp,
@@ -682,7 +682,7 @@
   }
 
   /// Same as opensBlockOrBlockTypeList, but for the closing token.
-  bool closesBlockOrBlockTypeList(const FormatStyle &Style) const {
+  bool closesBlockOrBlockTypeList(FormatStyle const &Style) const {
     if (is(TT_TemplateString) && closesScope())
       return true;
     return MatchingParen && MatchingParen->opensBlockOrBlockTypeList(Style);
@@ -690,8 +690,8 @@
 
   /// Return the actual namespace token, if this token starts a namespace
   /// block.
-  const FormatToken *getNamespaceToken() const {
-    const FormatToken *NamespaceTok = this;
+  FormatToken const *getNamespaceToken() const {
+    FormatToken const *NamespaceTok = this;
     if (is(tok::comment))
       NamespaceTok = NamespaceTok->getNextNonComment();
     // Detect "(inline|export)? namespace" in the beginning of a line.
@@ -703,12 +703,12 @@
                : nullptr;
   }
 
-  void copyFrom(const FormatToken &Tok) { *this = Tok; }
+  void copyFrom(FormatToken const &Tok) { *this = Tok; }
 
 private:
   // Only allow copying via the explicit copyFrom method.
-  FormatToken(const FormatToken &) = delete;
-  FormatToken &operator=(const FormatToken &) = default;
+  FormatToken(FormatToken const &) = delete;
+  FormatToken &operator=(FormatToken const &) = default;
 
   template <typename A, typename... Ts>
   bool startsSequenceInternal(A K1, Ts... Tokens) const {
@@ -742,12 +742,12 @@
 
 class TokenRole {
 public:
-  TokenRole(const FormatStyle &Style) : Style(Style) {}
+  TokenRole(FormatStyle const &Style) : Style(Style) {}
   virtual ~TokenRole();
 
   /// After the \c TokenAnnotator has finished annotating all the tokens,
   /// this function precomputes required information for formatting.
-  virtual void precomputeFormattingInfos(const FormatToken *Token);
+  virtual void precomputeFormattingInfos(FormatToken const *Token);
 
   /// Apply the special formatting that the given role demands.
   ///
@@ -770,20 +770,20 @@
   }
 
   /// Notifies the \c Role that a comma was found.
-  virtual void CommaFound(const FormatToken *Token) {}
+  virtual void CommaFound(FormatToken const *Token) {}
 
-  virtual const FormatToken *lastComma() { return nullptr; }
+  virtual FormatToken const *lastComma() { return nullptr; }
 
 protected:
-  const FormatStyle &Style;
+  FormatStyle const &Style;
 };
 
 class CommaSeparatedList : public TokenRole {
 public:
-  CommaSeparatedList(const FormatStyle &Style)
+  CommaSeparatedList(FormatStyle const &Style)
       : TokenRole(Style), HasNestedBracedList(false) {}
 
-  void precomputeFormattingInfos(const FormatToken *Token) override;
+  void precomputeFormattingInfos(FormatToken const *Token) override;
 
   unsigned formatAfterToken(LineState &State, ContinuationIndenter *Indenter,
                             bool DryRun) override;
@@ -792,11 +792,11 @@
                            bool DryRun) override;
 
   /// Adds \p Token as the next comma to the \c CommaSeparated list.
-  void CommaFound(const FormatToken *Token) override {
+  void CommaFound(FormatToken const *Token) override {
     Commas.push_back(Token);
   }
 
-  const FormatToken *lastComma() override {
+  FormatToken const *lastComma() override {
     if (Commas.empty())
       return nullptr;
     return Commas.back();
@@ -821,10 +821,10 @@
 
   /// Calculate which \c ColumnFormat fits best into
   /// \p RemainingCharacters.
-  const ColumnFormat *getColumnFormat(unsigned RemainingCharacters) const;
+  ColumnFormat const *getColumnFormat(unsigned RemainingCharacters) const;
 
   /// The ordered \c FormatTokens making up the commas of this list.
-  SmallVector<const FormatToken *, 8> Commas;
+  SmallVector<FormatToken const *, 8> Commas;
 
   /// The length of each of the list's items in characters including the
   /// trailing comma.
@@ -1057,7 +1057,7 @@
   /// If \c AcceptIdentifierName is true, returns true not only for keywords,
   // but also for IdentifierName tokens (aka pseudo-keywords), such as
   // ``yield``.
-  bool IsJavaScriptIdentifier(const FormatToken &Tok,
+  bool IsJavaScriptIdentifier(FormatToken const &Tok,
                               bool AcceptIdentifierName = true) const {
     // Based on the list of JavaScript & TypeScript keywords here:
     // https://github.com/microsoft/TypeScript/blob/master/src/compiler/scanner.ts#L74
@@ -1124,7 +1124,7 @@
 
   /// Returns \c true if \p Tok is a C# keyword, returns
   /// \c false if it is a anything else.
-  bool isCSharpKeyword(const FormatToken &Tok) const {
+  bool isCSharpKeyword(FormatToken const &Tok) const {
     switch (Tok.Tok.getKind()) {
     case tok::kw_bool:
     case tok::kw_break:
Index: clang/lib/Format/FormatToken.cpp
===================================================================
--- clang/lib/Format/FormatToken.cpp
+++ clang/lib/Format/FormatToken.cpp
@@ -21,8 +21,8 @@
 namespace clang {
 namespace format {
 
-const char *getTokenTypeName(TokenType Type) {
-  static const char *const TokNames[] = {
+char const *getTokenTypeName(TokenType Type) {
+  static char const *const TokNames[] = {
 #define TYPE(X) #X,
       LIST_TOKEN_TYPES
 #undef TYPE
@@ -72,7 +72,7 @@
 
 TokenRole::~TokenRole() {}
 
-void TokenRole::precomputeFormattingInfos(const FormatToken *Token) {}
+void TokenRole::precomputeFormattingInfos(FormatToken const *Token) {}
 
 unsigned CommaSeparatedList::formatAfterToken(LineState &State,
                                               ContinuationIndenter *Indenter,
@@ -84,7 +84,7 @@
     return 0; // Handled by formatFromToken
 
   // Ensure that we start on the opening brace.
-  const FormatToken *LBrace =
+  FormatToken const *LBrace =
       State.NextToken->Previous->getPreviousNonComment();
   if (!LBrace || !LBrace->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
       LBrace->is(BK_Block) || LBrace->is(TT_DictLiteral) ||
@@ -97,7 +97,7 @@
       Style.ColumnLimit - State.Column + State.NextToken->Previous->ColumnWidth;
 
   // Find the best ColumnFormat, i.e. the best number of columns to use.
-  const ColumnFormat *Format = getColumnFormat(RemainingCodePoints);
+  ColumnFormat const *Format = getColumnFormat(RemainingCodePoints);
 
   // If no ColumnFormat can be used, the braced list would generally be
   // bin-packed. Add a severe penalty to this so that column layouts are
@@ -145,13 +145,13 @@
 
 // Returns the lengths in code points between Begin and End (both included),
 // assuming that the entire sequence is put on a single line.
-static unsigned CodePointsBetween(const FormatToken *Begin,
-                                  const FormatToken *End) {
+static unsigned CodePointsBetween(FormatToken const *Begin,
+                                  FormatToken const *End) {
   assert(End->TotalLength >= Begin->TotalLength);
   return End->TotalLength - Begin->TotalLength + Begin->ColumnWidth;
 }
 
-void CommaSeparatedList::precomputeFormattingInfos(const FormatToken *Token) {
+void CommaSeparatedList::precomputeFormattingInfos(FormatToken const *Token) {
   // FIXME: At some point we might want to do this for other lists, too.
   if (!Token->MatchingParen ||
       !Token->isOneOf(tok::l_brace, TT_ArrayInitializerLSquare))
@@ -194,10 +194,10 @@
     MustBreakBeforeItem.push_back(ItemBegin->MustBreakBefore);
     if (ItemBegin->is(tok::l_brace))
       HasNestedBracedList = true;
-    const FormatToken *ItemEnd = nullptr;
+    FormatToken const *ItemEnd = nullptr;
     if (i == Commas.size()) {
       ItemEnd = Token->MatchingParen;
-      const FormatToken *NonCommentEnd = ItemEnd->getPreviousNonComment();
+      FormatToken const *NonCommentEnd = ItemEnd->getPreviousNonComment();
       ItemLengths.push_back(CodePointsBetween(ItemBegin, NonCommentEnd));
       if (Style.Cpp11BracedListStyle &&
           !ItemEnd->Previous->isTrailingComment()) {
@@ -289,9 +289,9 @@
   }
 }
 
-const CommaSeparatedList::ColumnFormat *
+CommaSeparatedList::ColumnFormat const *
 CommaSeparatedList::getColumnFormat(unsigned RemainingCharacters) const {
-  const ColumnFormat *BestFormat = nullptr;
+  ColumnFormat const *BestFormat = nullptr;
   for (SmallVector<ColumnFormat, 4>::const_reverse_iterator
            I = Formats.rbegin(),
            E = Formats.rend();
Index: clang/lib/Format/FormatTokenLexer.h
===================================================================
--- clang/lib/Format/FormatTokenLexer.h
+++ clang/lib/Format/FormatTokenLexer.h
@@ -37,14 +37,14 @@
 
 class FormatTokenLexer {
 public:
-  FormatTokenLexer(const SourceManager &SourceMgr, FileID ID, unsigned Column,
-                   const FormatStyle &Style, encoding::Encoding Encoding,
+  FormatTokenLexer(SourceManager const &SourceMgr, FileID ID, unsigned Column,
+                   FormatStyle const &Style, encoding::Encoding Encoding,
                    llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator,
                    IdentifierTable &IdentTable);
 
   ArrayRef<FormatToken *> lex();
 
-  const AdditionalKeywords &getKeywords() { return Keywords; }
+  AdditionalKeywords const &getKeywords() { return Keywords; }
 
 private:
   void tryMergePreviousTokens();
@@ -101,9 +101,9 @@
   unsigned Column;
   unsigned TrailingWhitespace;
   std::unique_ptr<Lexer> Lex;
-  const SourceManager &SourceMgr;
+  SourceManager const &SourceMgr;
   FileID ID;
-  const FormatStyle &Style;
+  FormatStyle const &Style;
   IdentifierTable &IdentTable;
   AdditionalKeywords Keywords;
   encoding::Encoding Encoding;
Index: clang/lib/Format/FormatTokenLexer.cpp
===================================================================
--- clang/lib/Format/FormatTokenLexer.cpp
+++ clang/lib/Format/FormatTokenLexer.cpp
@@ -23,8 +23,8 @@
 namespace format {
 
 FormatTokenLexer::FormatTokenLexer(
-    const SourceManager &SourceMgr, FileID ID, unsigned Column,
-    const FormatStyle &Style, encoding::Encoding Encoding,
+    SourceManager const &SourceMgr, FileID ID, unsigned Column,
+    FormatStyle const &Style, encoding::Encoding Encoding,
     llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator,
     IdentifierTable &IdentTable)
     : FormatTok(nullptr), IsFirstToken(true), StateStack({LexerState::NORMAL}),
@@ -37,24 +37,24 @@
                       getFormattingLangOpts(Style)));
   Lex->SetKeepWhitespaceMode(true);
 
-  for (const std::string &ForEachMacro : Style.ForEachMacros)
+  for (std::string const &ForEachMacro : Style.ForEachMacros)
     Macros.insert({&IdentTable.get(ForEachMacro), TT_ForEachMacro});
-  for (const std::string &IfMacro : Style.IfMacros)
+  for (std::string const &IfMacro : Style.IfMacros)
     Macros.insert({&IdentTable.get(IfMacro), TT_IfMacro});
-  for (const std::string &AttributeMacro : Style.AttributeMacros)
+  for (std::string const &AttributeMacro : Style.AttributeMacros)
     Macros.insert({&IdentTable.get(AttributeMacro), TT_AttributeMacro});
-  for (const std::string &StatementMacro : Style.StatementMacros)
+  for (std::string const &StatementMacro : Style.StatementMacros)
     Macros.insert({&IdentTable.get(StatementMacro), TT_StatementMacro});
-  for (const std::string &TypenameMacro : Style.TypenameMacros)
+  for (std::string const &TypenameMacro : Style.TypenameMacros)
     Macros.insert({&IdentTable.get(TypenameMacro), TT_TypenameMacro});
-  for (const std::string &NamespaceMacro : Style.NamespaceMacros)
+  for (std::string const &NamespaceMacro : Style.NamespaceMacros)
     Macros.insert({&IdentTable.get(NamespaceMacro), TT_NamespaceMacro});
-  for (const std::string &WhitespaceSensitiveMacro :
+  for (std::string const &WhitespaceSensitiveMacro :
        Style.WhitespaceSensitiveMacros) {
     Macros.insert(
         {&IdentTable.get(WhitespaceSensitiveMacro), TT_UntouchableMacroFunc});
   }
-  for (const std::string &StatementAttributeLikeMacro :
+  for (std::string const &StatementAttributeLikeMacro :
        Style.StatementAttributeLikeMacros)
     Macros.insert({&IdentTable.get(StatementAttributeLikeMacro),
                    TT_StatementAttributeLikeMacro});
@@ -519,8 +519,8 @@
     return;
 
   // 'Manually' lex ahead in the current file buffer.
-  const char *Offset = Lex->getBufferLocation();
-  const char *RegexBegin = Offset - RegexToken->TokenText.size();
+  char const *Offset = Lex->getBufferLocation();
+  char const *RegexBegin = Offset - RegexToken->TokenText.size();
   StringRef Buffer = Lex->getBuffer();
   bool InCharacterClass = false;
   bool HaveClosingSlash = false;
@@ -566,9 +566,9 @@
         CSharpStringLiteral->TokenText.startswith(R"($@")")))
     return;
 
-  const char *StrBegin =
+  char const *StrBegin =
       Lex->getBufferLocation() - CSharpStringLiteral->TokenText.size();
-  const char *Offset = StrBegin;
+  char const *Offset = StrBegin;
   if (CSharpStringLiteral->TokenText.startswith(R"(@")"))
     Offset += 2;
   else // CSharpStringLiteral->TokenText.startswith(R"($@")")
@@ -639,8 +639,8 @@
   }
 
   // 'Manually' lex ahead in the current file buffer.
-  const char *Offset = Lex->getBufferLocation();
-  const char *TmplBegin = Offset - BacktickToken->TokenText.size(); // at "`"
+  char const *Offset = Lex->getBufferLocation();
+  char const *TmplBegin = Offset - BacktickToken->TokenText.size(); // at "`"
   for (; Offset != Lex->getBuffer().end(); ++Offset) {
     if (Offset[0] == '`') {
       StateStack.pop();
@@ -689,7 +689,7 @@
   if (!HashToken->isOneOf(tok::hash, tok::hashhash))
     return;
   // Turn the remainder of this line into a comment.
-  const char *CommentBegin =
+  char const *CommentBegin =
       Lex->getBufferLocation() - HashToken->TokenText.size(); // at "#"
   size_t From = CommentBegin - Lex->getBuffer().begin();
   size_t To = Lex->getBuffer().find_first_of('\n', From);
@@ -723,8 +723,8 @@
   if (Macro->TokenText != "_T")
     return false;
 
-  const char *Start = Macro->TokenText.data();
-  const char *End = Last->TokenText.data() + Last->TokenText.size();
+  char const *Start = Macro->TokenText.data();
+  char const *End = Last->TokenText.data() + Last->TokenText.size();
   String->TokenText = StringRef(Start, End - Start);
   String->IsFirst = Macro->IsFirst;
   String->LastNewlineOffset = Macro->LastNewlineOffset;
@@ -912,7 +912,7 @@
     while (BackslashPos != StringRef::npos) {
       if (BackslashPos + 1 < FormatTok->TokenText.size() &&
           FormatTok->TokenText[BackslashPos + 1] == '\n') {
-        const char *Offset = Lex->getBufferLocation();
+        char const *Offset = Lex->getBufferLocation();
         Offset -= FormatTok->TokenText.size();
         Offset += BackslashPos + 1;
         resetLexer(SourceMgr.getFileOffset(Lex->getSourceLocation(Offset)));
Index: clang/lib/Format/MacroExpander.cpp
===================================================================
--- clang/lib/Format/MacroExpander.cpp
+++ clang/lib/Format/MacroExpander.cpp
@@ -119,26 +119,26 @@
 };
 
 MacroExpander::MacroExpander(
-    const std::vector<std::string> &Macros, clang::SourceManager &SourceMgr,
-    const FormatStyle &Style,
+    std::vector<std::string> const &Macros, clang::SourceManager &SourceMgr,
+    FormatStyle const &Style,
     llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator,
     IdentifierTable &IdentTable)
     : SourceMgr(SourceMgr), Style(Style), Allocator(Allocator),
       IdentTable(IdentTable) {
-  for (const std::string &Macro : Macros) {
+  for (std::string const &Macro : Macros) {
     parseDefinition(Macro);
   }
 }
 
 MacroExpander::~MacroExpander() = default;
 
-void MacroExpander::parseDefinition(const std::string &Macro) {
+void MacroExpander::parseDefinition(std::string const &Macro) {
   Buffers.push_back(
       llvm::MemoryBuffer::getMemBufferCopy(Macro, "<scratch space>"));
   clang::FileID FID = SourceMgr.createFileID(Buffers.back()->getMemBufferRef());
   FormatTokenLexer Lex(SourceMgr, FID, 0, Style, encoding::Encoding_UTF8,
                        Allocator, IdentTable);
-  const auto Tokens = Lex.lex();
+  auto const Tokens = Lex.lex();
   if (!Tokens.empty()) {
     DefinitionParser Parser(Tokens);
     auto Definition = Parser.parse();
@@ -158,7 +158,7 @@
                                                           ArgsList Args) const {
   assert(defined(ID->TokenText));
   SmallVector<FormatToken *, 8> Result;
-  const Definition &Def = Definitions.find(ID->TokenText)->second;
+  Definition const &Def = Definitions.find(ID->TokenText)->second;
 
   // Expand each argument at most once.
   llvm::StringSet<> ExpandedArgs;
Index: clang/lib/Format/Macros.h
===================================================================
--- clang/lib/Format/Macros.h
+++ clang/lib/Format/Macros.h
@@ -102,8 +102,8 @@
   ///
   /// Macros that cannot be parsed will be silently discarded.
   ///
-  MacroExpander(const std::vector<std::string> &Macros,
-                clang::SourceManager &SourceMgr, const FormatStyle &Style,
+  MacroExpander(std::vector<std::string> const &Macros,
+                clang::SourceManager &SourceMgr, FormatStyle const &Style,
                 llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator,
                 IdentifierTable &IdentTable);
   ~MacroExpander();
@@ -124,10 +124,10 @@
   struct Definition;
   class DefinitionParser;
 
-  void parseDefinition(const std::string &Macro);
+  void parseDefinition(std::string const &Macro);
 
   clang::SourceManager &SourceMgr;
-  const FormatStyle &Style;
+  FormatStyle const &Style;
   llvm::SpecificBumpPtrAllocator<FormatToken> &Allocator;
   IdentifierTable &IdentTable;
   std::vector<std::unique_ptr<llvm::MemoryBuffer>> Buffers;
Index: clang/lib/Format/NamespaceEndCommentsFixer.h
===================================================================
--- clang/lib/Format/NamespaceEndCommentsFixer.h
+++ clang/lib/Format/NamespaceEndCommentsFixer.h
@@ -26,13 +26,13 @@
 // a preprocessor directive, the result will be the matching namespace token.
 // Otherwise returns null.
 // \p AnnotatedLines is the sequence of lines from which \p Line is a member of.
-const FormatToken *
-getNamespaceToken(const AnnotatedLine *Line,
-                  const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines);
+FormatToken const *
+getNamespaceToken(AnnotatedLine const *Line,
+                  SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines);
 
 class NamespaceEndCommentsFixer : public TokenAnalyzer {
 public:
-  NamespaceEndCommentsFixer(const Environment &Env, const FormatStyle &Style);
+  NamespaceEndCommentsFixer(Environment const &Env, FormatStyle const &Style);
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
Index: clang/lib/Format/NamespaceEndCommentsFixer.cpp
===================================================================
--- clang/lib/Format/NamespaceEndCommentsFixer.cpp
+++ clang/lib/Format/NamespaceEndCommentsFixer.cpp
@@ -24,12 +24,12 @@
 namespace {
 // Computes the name of a namespace given the namespace token.
 // Returns "" for anonymous namespace.
-std::string computeName(const FormatToken *NamespaceTok) {
+std::string computeName(FormatToken const *NamespaceTok) {
   assert(NamespaceTok &&
          NamespaceTok->isOneOf(tok::kw_namespace, TT_NamespaceMacro) &&
          "expecting a namespace token");
   std::string name = "";
-  const FormatToken *Tok = NamespaceTok->getNextNonComment();
+  FormatToken const *Tok = NamespaceTok->getNextNonComment();
   if (NamespaceTok->is(TT_NamespaceMacro)) {
     // Collects all the non-comment tokens between opening parenthesis
     // and closing parenthesis or comma.
@@ -44,7 +44,7 @@
     // `namespace MACRO1 MACRO2 A::B::inline C {`, returns "A::B::inline C".
     // Peek for the first '::' (or '{') and then return all tokens from one
     // token before that up until the '{'.
-    const FormatToken *FirstNSTok = Tok;
+    FormatToken const *FirstNSTok = Tok;
     while (Tok && !Tok->is(tok::l_brace) && !Tok->is(tok::coloncolon)) {
       FirstNSTok = Tok;
       Tok = Tok->getNextNonComment();
@@ -62,7 +62,7 @@
 }
 
 std::string computeEndCommentText(StringRef NamespaceName, bool AddNewline,
-                                  const FormatToken *NamespaceTok,
+                                  FormatToken const *NamespaceTok,
                                   unsigned SpacesToAdd) {
   std::string text = "//";
   text.append(SpacesToAdd, ' ');
@@ -79,14 +79,14 @@
   return text;
 }
 
-bool hasEndComment(const FormatToken *RBraceTok) {
+bool hasEndComment(FormatToken const *RBraceTok) {
   return RBraceTok->Next && RBraceTok->Next->is(tok::comment);
 }
 
-bool validEndComment(const FormatToken *RBraceTok, StringRef NamespaceName,
-                     const FormatToken *NamespaceTok) {
+bool validEndComment(FormatToken const *RBraceTok, StringRef NamespaceName,
+                     FormatToken const *NamespaceTok) {
   assert(hasEndComment(RBraceTok));
-  const FormatToken *Comment = RBraceTok->Next;
+  FormatToken const *Comment = RBraceTok->Next;
 
   // Matches a valid namespace end comment.
   // Valid namespace end comments don't need to be edited.
@@ -140,8 +140,8 @@
   return (NamespaceNameInComment == NamespaceName);
 }
 
-void addEndComment(const FormatToken *RBraceTok, StringRef EndCommentText,
-                   const SourceManager &SourceMgr,
+void addEndComment(FormatToken const *RBraceTok, StringRef EndCommentText,
+                   SourceManager const &SourceMgr,
                    tooling::Replacements *Fixes) {
   auto EndLoc = RBraceTok->Tok.getEndLoc();
   auto Range = CharSourceRange::getCharRange(EndLoc, EndLoc);
@@ -152,11 +152,11 @@
   }
 }
 
-void updateEndComment(const FormatToken *RBraceTok, StringRef EndCommentText,
-                      const SourceManager &SourceMgr,
+void updateEndComment(FormatToken const *RBraceTok, StringRef EndCommentText,
+                      SourceManager const &SourceMgr,
                       tooling::Replacements *Fixes) {
   assert(hasEndComment(RBraceTok));
-  const FormatToken *Comment = RBraceTok->Next;
+  FormatToken const *Comment = RBraceTok->Next;
   auto Range = CharSourceRange::getCharRange(Comment->getStartOfNonWhitespace(),
                                              Comment->Tok.getEndLoc());
   auto Err = Fixes->add(tooling::Replacement(SourceMgr, Range, EndCommentText));
@@ -167,16 +167,16 @@
 }
 } // namespace
 
-const FormatToken *
-getNamespaceToken(const AnnotatedLine *Line,
-                  const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
+FormatToken const *
+getNamespaceToken(AnnotatedLine const *Line,
+                  SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
   if (!Line->Affected || Line->InPPDirective || !Line->startsWith(tok::r_brace))
     return nullptr;
   size_t StartLineIndex = Line->MatchingOpeningBlockLineIndex;
   if (StartLineIndex == UnwrappedLine::kInvalidIndex)
     return nullptr;
   assert(StartLineIndex < AnnotatedLines.size());
-  const FormatToken *NamespaceTok = AnnotatedLines[StartLineIndex]->First;
+  FormatToken const *NamespaceTok = AnnotatedLines[StartLineIndex]->First;
   if (NamespaceTok->is(tok::l_brace)) {
     // "namespace" keyword can be on the line preceding '{', e.g. in styles
     // where BraceWrapping.AfterNamespace is true.
@@ -187,20 +187,20 @@
 }
 
 StringRef
-getNamespaceTokenText(const AnnotatedLine *Line,
-                      const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
-  const FormatToken *NamespaceTok = getNamespaceToken(Line, AnnotatedLines);
+getNamespaceTokenText(AnnotatedLine const *Line,
+                      SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
+  FormatToken const *NamespaceTok = getNamespaceToken(Line, AnnotatedLines);
   return NamespaceTok ? NamespaceTok->TokenText : StringRef();
 }
 
-NamespaceEndCommentsFixer::NamespaceEndCommentsFixer(const Environment &Env,
-                                                     const FormatStyle &Style)
+NamespaceEndCommentsFixer::NamespaceEndCommentsFixer(Environment const &Env,
+                                                     FormatStyle const &Style)
     : TokenAnalyzer(Env, Style) {}
 
 std::pair<tooling::Replacements, unsigned> NamespaceEndCommentsFixer::analyze(
     TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
     FormatTokenLexer &Tokens) {
-  const SourceManager &SourceMgr = Env.getSourceManager();
+  SourceManager const &SourceMgr = Env.getSourceManager();
   AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
   tooling::Replacements Fixes;
 
@@ -225,8 +225,8 @@
   StringRef NamespaceTokenText;
   unsigned int CompactedNamespacesCount = 0;
   for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
-    const AnnotatedLine *EndLine = AnnotatedLines[I];
-    const FormatToken *NamespaceTok =
+    AnnotatedLine const *EndLine = AnnotatedLines[I];
+    FormatToken const *NamespaceTok =
         getNamespaceToken(EndLine, AnnotatedLines);
     if (!NamespaceTok)
       continue;
@@ -234,7 +234,7 @@
     if (RBraceTok->Finalized)
       continue;
     RBraceTok->Finalized = true;
-    const FormatToken *EndCommentPrevTok = RBraceTok;
+    FormatToken const *EndCommentPrevTok = RBraceTok;
     // Namespaces often end with '};'. In that case, attach namespace end
     // comments to the semicolon tokens.
     if (RBraceTok->Next && RBraceTok->Next->is(tok::semi)) {
@@ -267,7 +267,7 @@
     // The next token in the token stream after the place where the end comment
     // token must be. This is either the next token on the current line or the
     // first token on the next line.
-    const FormatToken *EndCommentNextTok = EndCommentPrevTok->Next;
+    FormatToken const *EndCommentNextTok = EndCommentPrevTok->Next;
     if (EndCommentNextTok && EndCommentNextTok->is(tok::comment))
       EndCommentNextTok = EndCommentNextTok->Next;
     if (!EndCommentNextTok && I + 1 < E)
Index: clang/lib/Format/SortJavaScriptImports.h
===================================================================
--- clang/lib/Format/SortJavaScriptImports.h
+++ clang/lib/Format/SortJavaScriptImports.h
@@ -24,7 +24,7 @@
 
 // Sort JavaScript ES6 imports/exports in ``Code``. The generated replacements
 // only monotonically increase the length of the given code.
-tooling::Replacements sortJavaScriptImports(const FormatStyle &Style,
+tooling::Replacements sortJavaScriptImports(FormatStyle const &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName);
Index: clang/lib/Format/SortJavaScriptImports.cpp
===================================================================
--- clang/lib/Format/SortJavaScriptImports.cpp
+++ clang/lib/Format/SortJavaScriptImports.cpp
@@ -42,7 +42,7 @@
   StringRef Alias;
   SourceRange Range;
 
-  bool operator==(const JsImportedSymbol &RHS) const {
+  bool operator==(JsImportedSymbol const &RHS) const {
     // Ignore Range for comparison, it is only used to stitch code together,
     // but imports at different code locations are still conceptually the same.
     return Symbol == RHS.Symbol && Alias == RHS.Alias;
@@ -100,7 +100,7 @@
   SourceRange Range;
 };
 
-bool operator<(const JsModuleReference &LHS, const JsModuleReference &RHS) {
+bool operator<(JsModuleReference const &LHS, JsModuleReference const &RHS) {
   if (LHS.IsExport != RHS.IsExport)
     return LHS.IsExport < RHS.IsExport;
   if (LHS.Category != RHS.Category)
@@ -128,7 +128,7 @@
 // structure, making it messy to sort them using regular expressions.
 class JavaScriptImportSorter : public TokenAnalyzer {
 public:
-  JavaScriptImportSorter(const Environment &Env, const FormatStyle &Style)
+  JavaScriptImportSorter(Environment const &Env, FormatStyle const &Style)
       : TokenAnalyzer(Env, Style),
         FileContents(Env.getSourceManager().getBufferData(Env.getFileID())) {}
 
@@ -139,7 +139,7 @@
     tooling::Replacements Result;
     AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
 
-    const AdditionalKeywords &Keywords = Tokens.getKeywords();
+    AdditionalKeywords const &Keywords = Tokens.getKeywords();
     SmallVector<JsModuleReference, 16> References;
     AnnotatedLine *FirstNonImportLine;
     std::tie(References, FirstNonImportLine) =
@@ -239,7 +239,7 @@
   }
 
   StringRef getSourceText(SourceLocation Begin, SourceLocation End) {
-    const SourceManager &SM = Env.getSourceManager();
+    SourceManager const &SM = Env.getSourceManager();
     return FileContents.substr(SM.getFileOffset(Begin),
                                SM.getFileOffset(End) - SM.getFileOffset(Begin));
   }
@@ -249,12 +249,12 @@
   // skips runs of "no-formatting" module references, and sorts/merges the
   // references that have formatting enabled in individual chunks.
   SmallVector<JsModuleReference, 16>
-  sortModuleReferences(const SmallVector<JsModuleReference, 16> &References) {
+  sortModuleReferences(SmallVector<JsModuleReference, 16> const &References) {
     // Sort module references.
     // Imports can have formatting disabled (FormattingOff), so the code below
     // skips runs of "no-formatting" module references, and sorts other
     // references per group.
-    const auto *Start = References.begin();
+    auto const *Start = References.begin();
     SmallVector<JsModuleReference, 16> ReferencesSorted;
     while (Start != References.end()) {
       while (Start != References.end() && Start->FormattingOff) {
@@ -326,7 +326,7 @@
     // E.g. `import {b, a} from 'x';` -> `import {a, b} from 'x';`
     SmallVector<JsImportedSymbol, 1> Symbols = Reference.Symbols;
     llvm::stable_sort(
-        Symbols, [&](const JsImportedSymbol &LHS, const JsImportedSymbol &RHS) {
+        Symbols, [&](JsImportedSymbol const &LHS, JsImportedSymbol const &RHS) {
           return LHS.Symbol.compare_insensitive(RHS.Symbol) < 0;
         });
     if (!Reference.SymbolsMerged && Symbols == Reference.Symbols) {
@@ -351,7 +351,7 @@
   // and a pointer to the first "main code" line if that is adjacent to the
   // affected lines of module references, nullptr otherwise.
   std::pair<SmallVector<JsModuleReference, 16>, AnnotatedLine *>
-  parseModuleReferences(const AdditionalKeywords &Keywords,
+  parseModuleReferences(AdditionalKeywords const &Keywords,
                         SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
     SmallVector<JsModuleReference, 16> References;
     SourceLocation Start;
@@ -428,7 +428,7 @@
   // Parses a JavaScript/ECMAScript 6 module reference.
   // See http://www.ecma-international.org/ecma-262/6.0/#sec-scripts-and-modules
   // for grammar EBNF (production ModuleItem).
-  bool parseModuleReference(const AdditionalKeywords &Keywords,
+  bool parseModuleReference(AdditionalKeywords const &Keywords,
                             JsModuleReference &Reference) {
     if (!Current || !Current->isOneOf(Keywords.kw_import, tok::kw_export))
       return false;
@@ -468,14 +468,14 @@
     return true;
   }
 
-  bool parseModuleBindings(const AdditionalKeywords &Keywords,
+  bool parseModuleBindings(AdditionalKeywords const &Keywords,
                            JsModuleReference &Reference) {
     if (parseStarBinding(Keywords, Reference))
       return true;
     return parseNamedBindings(Keywords, Reference);
   }
 
-  bool parseStarBinding(const AdditionalKeywords &Keywords,
+  bool parseStarBinding(AdditionalKeywords const &Keywords,
                         JsModuleReference &Reference) {
     // * as prefix from '...';
     if (Current->isNot(tok::star))
@@ -491,7 +491,7 @@
     return true;
   }
 
-  bool parseNamedBindings(const AdditionalKeywords &Keywords,
+  bool parseNamedBindings(AdditionalKeywords const &Keywords,
                           JsModuleReference &Reference) {
     // eat a potential "import X, " prefix.
     if (Current->is(tok::identifier)) {
@@ -545,7 +545,7 @@
   }
 };
 
-tooling::Replacements sortJavaScriptImports(const FormatStyle &Style,
+tooling::Replacements sortJavaScriptImports(FormatStyle const &Style,
                                             StringRef Code,
                                             ArrayRef<tooling::Range> Ranges,
                                             StringRef FileName) {
Index: clang/lib/Format/TokenAnalyzer.h
===================================================================
--- clang/lib/Format/TokenAnalyzer.h
+++ clang/lib/Format/TokenAnalyzer.h
@@ -46,7 +46,7 @@
 
   FileID getFileID() const { return ID; }
 
-  const SourceManager &getSourceManager() const { return SM; }
+  SourceManager const &getSourceManager() const { return SM; }
 
   ArrayRef<CharSourceRange> getCharRanges() const { return CharRanges; }
 
@@ -79,7 +79,7 @@
 
 class TokenAnalyzer : public UnwrappedLineConsumer {
 public:
-  TokenAnalyzer(const Environment &Env, const FormatStyle &Style);
+  TokenAnalyzer(Environment const &Env, FormatStyle const &Style);
 
   std::pair<tooling::Replacements, unsigned> process();
 
@@ -89,13 +89,13 @@
           SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
           FormatTokenLexer &Tokens) = 0;
 
-  void consumeUnwrappedLine(const UnwrappedLine &TheLine) override;
+  void consumeUnwrappedLine(UnwrappedLine const &TheLine) override;
 
   void finishRun() override;
 
   FormatStyle Style;
   // Stores Style, FileID and SourceManager etc.
-  const Environment &Env;
+  Environment const &Env;
   // AffectedRangeMgr stores ranges to be fixed.
   AffectedRangeManager AffectedRangeMgr;
   SmallVector<SmallVector<UnwrappedLine, 16>, 2> UnwrappedLines;
Index: clang/lib/Format/TokenAnalyzer.cpp
===================================================================
--- clang/lib/Format/TokenAnalyzer.cpp
+++ clang/lib/Format/TokenAnalyzer.cpp
@@ -41,14 +41,14 @@
       ID(VirtualSM->get().getMainFileID()), FirstStartColumn(FirstStartColumn),
       NextStartColumn(NextStartColumn), LastStartColumn(LastStartColumn) {
   SourceLocation StartOfFile = SM.getLocForStartOfFile(ID);
-  for (const tooling::Range &Range : Ranges) {
+  for (tooling::Range const &Range : Ranges) {
     SourceLocation Start = StartOfFile.getLocWithOffset(Range.getOffset());
     SourceLocation End = Start.getLocWithOffset(Range.getLength());
     CharRanges.push_back(CharSourceRange::getCharRange(Start, End));
   }
 }
 
-TokenAnalyzer::TokenAnalyzer(const Environment &Env, const FormatStyle &Style)
+TokenAnalyzer::TokenAnalyzer(Environment const &Env, FormatStyle const &Style)
     : Style(Style), Env(Env),
       AffectedRangeMgr(Env.getSourceManager(), Env.getCharRanges()),
       UnwrappedLines(1),
@@ -103,7 +103,7 @@
     }
 
     Penalty += RunResult.second;
-    for (const auto &R : RunResult.first) {
+    for (auto const &R : RunResult.first) {
       auto Err = Result.add(R);
       // FIXME: better error handling here. For now, simply return an empty
       // Replacements to indicate failure.
@@ -116,7 +116,7 @@
   return {Result, Penalty};
 }
 
-void TokenAnalyzer::consumeUnwrappedLine(const UnwrappedLine &TheLine) {
+void TokenAnalyzer::consumeUnwrappedLine(UnwrappedLine const &TheLine) {
   assert(!UnwrappedLines.empty());
   UnwrappedLines.back().push_back(TheLine);
 }
Index: clang/lib/Format/TokenAnnotator.h
===================================================================
--- clang/lib/Format/TokenAnnotator.h
+++ clang/lib/Format/TokenAnnotator.h
@@ -37,7 +37,7 @@
 
 class AnnotatedLine {
 public:
-  AnnotatedLine(const UnwrappedLine &Line)
+  AnnotatedLine(UnwrappedLine const &Line)
       : First(Line.Tokens.front().Tok), Level(Line.Level),
         MatchingOpeningBlockLineIndex(Line.MatchingOpeningBlockLineIndex),
         MatchingClosingBlockLineIndex(Line.MatchingClosingBlockLineIndex),
@@ -56,12 +56,12 @@
     for (std::list<UnwrappedLineNode>::const_iterator I = ++Line.Tokens.begin(),
                                                       E = Line.Tokens.end();
          I != E; ++I) {
-      const UnwrappedLineNode &Node = *I;
+      UnwrappedLineNode const &Node = *I;
       Current->Next = I->Tok;
       I->Tok->Previous = Current;
       Current = Current->Next;
       Current->Children.clear();
-      for (const auto &Child : Node.Children) {
+      for (auto const &Child : Node.Children) {
         Children.push_back(new AnnotatedLine(Child));
         Current->Children.push_back(Children.back());
       }
@@ -149,15 +149,15 @@
 
 private:
   // Disallow copying.
-  AnnotatedLine(const AnnotatedLine &) = delete;
-  void operator=(const AnnotatedLine &) = delete;
+  AnnotatedLine(AnnotatedLine const &) = delete;
+  void operator=(AnnotatedLine const &) = delete;
 };
 
 /// Determines extra information about the tokens comprising an
 /// \c UnwrappedLine.
 class TokenAnnotator {
 public:
-  TokenAnnotator(const FormatStyle &Style, const AdditionalKeywords &Keywords)
+  TokenAnnotator(FormatStyle const &Style, AdditionalKeywords const &Keywords)
       : Style(Style), Keywords(Keywords) {}
 
   /// Adapts the indent levels of comment lines to the indent of the
@@ -170,23 +170,23 @@
 
 private:
   /// Calculate the penalty for splitting before \c Tok.
-  unsigned splitPenalty(const AnnotatedLine &Line, const FormatToken &Tok,
+  unsigned splitPenalty(AnnotatedLine const &Line, FormatToken const &Tok,
                         bool InFunctionDecl);
 
-  bool spaceRequiredBeforeParens(const FormatToken &Right) const;
+  bool spaceRequiredBeforeParens(FormatToken const &Right) const;
 
-  bool spaceRequiredBetween(const AnnotatedLine &Line, const FormatToken &Left,
-                            const FormatToken &Right);
+  bool spaceRequiredBetween(AnnotatedLine const &Line, FormatToken const &Left,
+                            FormatToken const &Right);
 
-  bool spaceRequiredBefore(const AnnotatedLine &Line, const FormatToken &Right);
+  bool spaceRequiredBefore(AnnotatedLine const &Line, FormatToken const &Right);
 
-  bool mustBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
+  bool mustBreakBefore(AnnotatedLine const &Line, FormatToken const &Right);
 
-  bool canBreakBefore(const AnnotatedLine &Line, const FormatToken &Right);
+  bool canBreakBefore(AnnotatedLine const &Line, FormatToken const &Right);
 
-  bool mustBreakForReturnType(const AnnotatedLine &Line) const;
+  bool mustBreakForReturnType(AnnotatedLine const &Line) const;
 
-  void printDebugInfo(const AnnotatedLine &Line);
+  void printDebugInfo(AnnotatedLine const &Line);
 
   void calculateUnbreakableTailLengths(AnnotatedLine &Line);
 
@@ -196,14 +196,14 @@
                                               FormatToken *CurrentToken,
                                               unsigned Depth);
   FormatStyle::PointerAlignmentStyle
-  getTokenReferenceAlignment(const FormatToken &PointerOrReference);
+  getTokenReferenceAlignment(FormatToken const &PointerOrReference);
 
   FormatStyle::PointerAlignmentStyle
-  getTokenPointerOrReferenceAlignment(const FormatToken &PointerOrReference);
+  getTokenPointerOrReferenceAlignment(FormatToken const &PointerOrReference);
 
-  const FormatStyle &Style;
+  FormatStyle const &Style;
 
-  const AdditionalKeywords &Keywords;
+  AdditionalKeywords const &Keywords;
 };
 
 } // end namespace format
Index: clang/lib/Format/TokenAnnotator.cpp
===================================================================
--- clang/lib/Format/TokenAnnotator.cpp
+++ clang/lib/Format/TokenAnnotator.cpp
@@ -37,13 +37,13 @@
 /// are valid inside @selector(...) (or a macro which
 /// invokes @selector(...)). So, we allow treat any identifier or
 /// keyword as a potential Objective-C selector component.
-static bool canBeObjCSelectorComponent(const FormatToken &Tok) {
+static bool canBeObjCSelectorComponent(FormatToken const &Tok) {
   return Tok.Tok.getIdentifierInfo() != nullptr;
 }
 
 /// With `Left` being '(', check if we're at either `[...](` or
 /// `[...]<...>(`, where the [ opens a lambda capture list.
-static bool isLambdaParameterList(const FormatToken *Left) {
+static bool isLambdaParameterList(FormatToken const *Left) {
   // Skip <...> if present.
   if (Left->Previous && Left->Previous->is(tok::greater) &&
       Left->Previous->MatchingParen &&
@@ -58,7 +58,7 @@
 
 /// Returns \c true if the token is followed by a boolean condition, \c false
 /// otherwise.
-static bool isKeywordWithCondition(const FormatToken &Tok) {
+static bool isKeywordWithCondition(FormatToken const &Tok) {
   return Tok.isOneOf(tok::kw_if, tok::kw_for, tok::kw_while, tok::kw_switch,
                      tok::kw_constexpr, tok::kw_catch);
 }
@@ -70,8 +70,8 @@
 /// into template parameter lists.
 class AnnotatingParser {
 public:
-  AnnotatingParser(const FormatStyle &Style, AnnotatedLine &Line,
-                   const AdditionalKeywords &Keywords)
+  AnnotatingParser(FormatStyle const &Style, AnnotatedLine &Line,
+                   AdditionalKeywords const &Keywords)
       : Style(Style), Line(Line), CurrentToken(Line.First), AutoFound(false),
         Keywords(Keywords) {
     Contexts.push_back(Context(tok::unknown, 1, /*IsExpression=*/false));
@@ -85,7 +85,7 @@
     if (NonTemplateLess.count(CurrentToken->Previous))
       return false;
 
-    const FormatToken &Previous = *CurrentToken->Previous; // The '<'.
+    FormatToken const &Previous = *CurrentToken->Previous; // The '<'.
     if (Previous.Previous) {
       if (Previous.Previous->Tok.isLiteral())
         return false;
@@ -443,7 +443,7 @@
     return false;
   }
 
-  bool isCSharpAttributeSpecifier(const FormatToken &Tok) {
+  bool isCSharpAttributeSpecifier(FormatToken const &Tok) {
     if (!Style.isCSharp())
       return false;
 
@@ -458,7 +458,7 @@
         return false;
     }
 
-    const FormatToken *AttrTok = Tok.Next;
+    FormatToken const *AttrTok = Tok.Next;
     if (!AttrTok)
       return false;
 
@@ -494,14 +494,14 @@
     return false;
   }
 
-  bool isCpp11AttributeSpecifier(const FormatToken &Tok) {
+  bool isCpp11AttributeSpecifier(FormatToken const &Tok) {
     if (!Style.isCpp() || !Tok.startsSequence(tok::l_square, tok::l_square))
       return false;
     // The first square bracket is part of an ObjC array literal
     if (Tok.Previous && Tok.Previous->is(tok::at)) {
       return false;
     }
-    const FormatToken *AttrTok = Tok.Next->Next;
+    FormatToken const *AttrTok = Tok.Next->Next;
     if (!AttrTok)
       return false;
     // C++17 '[[using ns: foo, bar(baz, blech)]]'
@@ -750,7 +750,7 @@
       return false;
     // We want to back up no more then 2 context levels i.e.
     // . { { <-
-    const auto End = std::next(Contexts.rbegin(), 2);
+    auto const End = std::next(Contexts.rbegin(), 2);
     auto Last = Contexts.rbegin();
     unsigned Depth = 0;
     for (; Last != End; ++Last) {
@@ -913,7 +913,7 @@
       } else if (Contexts.back().ColonIsObjCMethodExpr ||
                  Line.startsWith(TT_ObjCMethodSpecifier)) {
         Tok->setType(TT_ObjCMethodExpr);
-        const FormatToken *BeforePrevious = Tok->Previous->Previous;
+        FormatToken const *BeforePrevious = Tok->Previous->Previous;
         // Ensure we tag all identifiers in method declarations as
         // TT_SelectorName.
         bool UnknownIdentifierInMethodDeclaration =
@@ -1379,7 +1379,7 @@
       return LT_ObjCMethodDecl;
     }
 
-    for (const auto &ctx : Contexts) {
+    for (auto const &ctx : Contexts) {
       if (ctx.InStructArrayInitializer) {
         return LT_ArrayOfStructInitializer;
       }
@@ -1389,7 +1389,7 @@
   }
 
 private:
-  bool isClosureImportStatement(const FormatToken &Tok) {
+  bool isClosureImportStatement(FormatToken const &Tok) {
     // FIXME: Closure-library specific stuff should not be hard-coded but be
     // configurable.
     return Tok.TokenText == "goog" && Tok.Next && Tok.Next->is(tok::period) &&
@@ -1488,7 +1488,7 @@
     }
   };
 
-  void modifyContext(const FormatToken &Current) {
+  void modifyContext(FormatToken const &Current) {
     if (Current.getPrecedence() == prec::Assignment &&
         !Line.First->isOneOf(tok::kw_template, tok::kw_using, tok::kw_return) &&
         // Type aliases use `type X = ...;` in TypeScript and can be exported
@@ -1787,8 +1787,8 @@
                Current.Previous) {
       if (Current.Previous->is(tok::at) &&
           Current.isNot(Keywords.kw_interface)) {
-        const FormatToken &AtToken = *Current.Previous;
-        const FormatToken *Previous = AtToken.getPreviousNonComment();
+        FormatToken const &AtToken = *Current.Previous;
+        FormatToken const *Previous = AtToken.getPreviousNonComment();
         if (!Previous || Previous->is(TT_LeadingJavaAnnotation))
           Current.setType(TT_LeadingJavaAnnotation);
         else
@@ -1806,7 +1806,7 @@
   ///
   /// This is a heuristic based on whether \p Tok is an identifier following
   /// something that is likely a type.
-  bool isStartOfName(const FormatToken &Tok) {
+  bool isStartOfName(FormatToken const &Tok) {
     if (Tok.isNot(tok::identifier) || !Tok.Previous)
       return false;
 
@@ -1846,7 +1846,7 @@
   }
 
   /// Determine whether ')' is ending a cast.
-  bool rParenEndsCast(const FormatToken &Tok) {
+  bool rParenEndsCast(FormatToken const &Tok) {
     // C-style casts are only used in C++, C# and Java.
     if (!Style.isCSharp() && !Style.isCpp() &&
         Style.Language != FormatStyle::LK_Java)
@@ -1953,7 +1953,7 @@
 
     // Certain token types inside the parentheses mean that this can't be a
     // cast.
-    for (const FormatToken *Token = Tok.MatchingParen->Next; Token != &Tok;
+    for (FormatToken const *Token = Tok.MatchingParen->Next; Token != &Tok;
          Token = Token->Next)
       if (Token->is(TT_BinaryOperator))
         return false;
@@ -1991,7 +1991,7 @@
   }
 
   /// Return the type of the given token assuming it is * or &.
-  TokenType determineStarAmpUsage(const FormatToken &Tok, bool IsExpression,
+  TokenType determineStarAmpUsage(FormatToken const &Tok, bool IsExpression,
                                   bool InTemplateArgument) {
     if (Style.Language == FormatStyle::LK_JavaScript)
       return TT_BinaryOperator;
@@ -2000,11 +2000,11 @@
     if (Style.isCSharp() && Tok.is(tok::ampamp))
       return TT_BinaryOperator;
 
-    const FormatToken *PrevToken = Tok.getPreviousNonComment();
+    FormatToken const *PrevToken = Tok.getPreviousNonComment();
     if (!PrevToken)
       return TT_UnaryOperator;
 
-    const FormatToken *NextToken = Tok.getNextNonComment();
+    FormatToken const *NextToken = Tok.getNextNonComment();
     if (!NextToken ||
         NextToken->isOneOf(tok::arrow, tok::equal, tok::kw_noexcept) ||
         NextToken->canBePointerOrReferenceQualifier() ||
@@ -2052,7 +2052,7 @@
     // This catches some cases where evaluation order is used as control flow:
     //   aaa && aaa->f();
     if (NextToken->Tok.isAnyIdentifier()) {
-      const FormatToken *NextNextToken = NextToken->getNextNonComment();
+      FormatToken const *NextNextToken = NextToken->getNextNonComment();
       if (NextNextToken && NextNextToken->is(tok::arrow))
         return TT_BinaryOperator;
     }
@@ -2065,8 +2065,8 @@
     return TT_PointerOrReference;
   }
 
-  TokenType determinePlusMinusCaretUsage(const FormatToken &Tok) {
-    const FormatToken *PrevToken = Tok.getPreviousNonComment();
+  TokenType determinePlusMinusCaretUsage(FormatToken const &Tok) {
+    FormatToken const *PrevToken = Tok.getPreviousNonComment();
     if (!PrevToken)
       return TT_UnaryOperator;
 
@@ -2090,8 +2090,8 @@
   }
 
   /// Determine whether ++/-- are pre- or post-increments/-decrements.
-  TokenType determineIncrementUsage(const FormatToken &Tok) {
-    const FormatToken *PrevToken = Tok.getPreviousNonComment();
+  TokenType determineIncrementUsage(FormatToken const &Tok) {
+    FormatToken const *PrevToken = Tok.getPreviousNonComment();
     if (!PrevToken || PrevToken->is(TT_CastRParen))
       return TT_UnaryOperator;
     if (PrevToken->isOneOf(tok::r_paren, tok::r_square, tok::identifier))
@@ -2102,11 +2102,11 @@
 
   SmallVector<Context, 8> Contexts;
 
-  const FormatStyle &Style;
+  FormatStyle const &Style;
   AnnotatedLine &Line;
   FormatToken *CurrentToken;
   bool AutoFound;
-  const AdditionalKeywords &Keywords;
+  AdditionalKeywords const &Keywords;
 
   // Set of "<" tokens that do not open a template parameter list. If parseAngle
   // determines that a specific token can't be a template opener, it will make
@@ -2115,14 +2115,14 @@
   llvm::SmallPtrSet<FormatToken *, 16> NonTemplateLess;
 };
 
-static const int PrecedenceUnaryOperator = prec::PointerToMember + 1;
-static const int PrecedenceArrowAndPeriod = prec::PointerToMember + 2;
+static int const PrecedenceUnaryOperator = prec::PointerToMember + 1;
+static int const PrecedenceArrowAndPeriod = prec::PointerToMember + 2;
 
 /// Parses binary expressions by inserting fake parenthesis based on
 /// operator precedence.
 class ExpressionParser {
 public:
-  ExpressionParser(const FormatStyle &Style, const AdditionalKeywords &Keywords,
+  ExpressionParser(FormatStyle const &Style, AdditionalKeywords const &Keywords,
                    AnnotatedLine &Line)
       : Style(Style), Keywords(Keywords), Current(Line.First) {}
 
@@ -2217,7 +2217,7 @@
   /// and other tokens that we treat like binary operators.
   int getCurrentPrecedence() {
     if (Current) {
-      const FormatToken *NextNonComment = Current->getNextNonComment();
+      FormatToken const *NextNonComment = Current->getNextNonComment();
       if (Current->is(TT_ConditionalExpr))
         return prec::Conditional;
       if (NextNonComment && Current->is(TT_SelectorName) &&
@@ -2312,8 +2312,8 @@
       Current = Current->Next;
   }
 
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
   FormatToken *Current;
 };
 
@@ -2321,12 +2321,12 @@
 
 void TokenAnnotator::setCommentLineLevels(
     SmallVectorImpl<AnnotatedLine *> &Lines) {
-  const AnnotatedLine *NextNonCommentLine = nullptr;
+  AnnotatedLine const *NextNonCommentLine = nullptr;
   for (SmallVectorImpl<AnnotatedLine *>::reverse_iterator I = Lines.rbegin(),
                                                           E = Lines.rend();
        I != E; ++I) {
     bool CommentLine = true;
-    for (const FormatToken *Tok = (*I)->First; Tok; Tok = Tok->Next) {
+    for (FormatToken const *Tok = (*I)->First; Tok; Tok = Tok->Next) {
       if (!Tok->is(tok::comment)) {
         CommentLine = false;
         break;
@@ -2356,9 +2356,9 @@
   }
 }
 
-static unsigned maxNestingDepth(const AnnotatedLine &Line) {
+static unsigned maxNestingDepth(AnnotatedLine const &Line) {
   unsigned Result = 0;
-  for (const auto *Tok = Line.First; Tok != nullptr; Tok = Tok->Next)
+  for (auto const *Tok = Line.First; Tok != nullptr; Tok = Tok->Next)
     Result = std::max(Result, Tok->NestingLevel);
   return Result;
 }
@@ -2398,9 +2398,9 @@
 
 // This function heuristically determines whether 'Current' starts the name of a
 // function declaration.
-static bool isFunctionDeclarationName(bool IsCpp, const FormatToken &Current,
-                                      const AnnotatedLine &Line) {
-  auto skipOperatorName = [](const FormatToken *Next) -> const FormatToken * {
+static bool isFunctionDeclarationName(bool IsCpp, FormatToken const &Current,
+                                      AnnotatedLine const &Line) {
+  auto skipOperatorName = [](FormatToken const *Next) -> FormatToken const * {
     for (; Next; Next = Next->Next) {
       if (Next->is(TT_OverloadedOperatorLParen))
         return Next;
@@ -2435,7 +2435,7 @@
   };
 
   // Find parentheses of parameter list.
-  const FormatToken *Next = Current.Next;
+  FormatToken const *Next = Current.Next;
   if (Current.is(tok::kw_operator)) {
     if (Current.Previous && Current.Previous->is(tok::coloncolon))
       return false;
@@ -2491,7 +2491,7 @@
       !Line.endsWith(tok::semi))
     return true;
 
-  for (const FormatToken *Tok = Next->Next; Tok && Tok != Next->MatchingParen;
+  for (FormatToken const *Tok = Next->Next; Tok && Tok != Next->MatchingParen;
        Tok = Tok->Next) {
     if (Tok->is(TT_TypeDeclarationParen))
       return true;
@@ -2509,7 +2509,7 @@
   return false;
 }
 
-bool TokenAnnotator::mustBreakForReturnType(const AnnotatedLine &Line) const {
+bool TokenAnnotator::mustBreakForReturnType(AnnotatedLine const &Line) const {
   assert(Line.MightBeFunctionDecl);
 
   if ((Style.AlwaysBreakAfterReturnType == FormatStyle::RTBS_TopLevel ||
@@ -2601,7 +2601,7 @@
       ChildSize = LastOfChild.isTrailingComment() ? Style.ColumnLimit
                                                   : LastOfChild.TotalLength + 1;
     }
-    const FormatToken *Prev = Current->Previous;
+    FormatToken const *Prev = Current->Previous;
     if (Current->MustBreakBefore || Prev->Children.size() > 1 ||
         (Prev->Children.size() == 1 &&
          Prev->Children[0]->First->MustBreakBefore) ||
@@ -2708,11 +2708,11 @@
   return CurrentToken;
 }
 
-unsigned TokenAnnotator::splitPenalty(const AnnotatedLine &Line,
-                                      const FormatToken &Tok,
+unsigned TokenAnnotator::splitPenalty(AnnotatedLine const &Line,
+                                      FormatToken const &Tok,
                                       bool InFunctionDecl) {
-  const FormatToken &Left = *Tok.Previous;
-  const FormatToken &Right = Tok;
+  FormatToken const &Left = *Tok.Previous;
+  FormatToken const &Right = Tok;
 
   if (Left.is(tok::semi))
     return 0;
@@ -2904,15 +2904,15 @@
   return 3;
 }
 
-bool TokenAnnotator::spaceRequiredBeforeParens(const FormatToken &Right) const {
+bool TokenAnnotator::spaceRequiredBeforeParens(FormatToken const &Right) const {
   return Style.SpaceBeforeParens == FormatStyle::SBPO_Always ||
          (Style.SpaceBeforeParens == FormatStyle::SBPO_NonEmptyParentheses &&
           Right.ParameterCount > 0);
 }
 
-bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
-                                          const FormatToken &Left,
-                                          const FormatToken &Right) {
+bool TokenAnnotator::spaceRequiredBetween(AnnotatedLine const &Line,
+                                          FormatToken const &Left,
+                                          FormatToken const &Right) {
   if (Left.is(tok::kw_return) && Right.isNot(tok::semi))
     return true;
   if (Style.isJson() && Left.is(tok::string_literal) && Right.is(tok::colon))
@@ -3048,7 +3048,7 @@
   if (Left.is(tok::star) && Right.isOneOf(tok::star, tok::amp, tok::ampamp))
     return false;
   if (Right.isOneOf(tok::star, tok::amp, tok::ampamp)) {
-    const FormatToken *Previous = &Left;
+    FormatToken const *Previous = &Left;
     while (Previous && !Previous->is(tok::kw_operator)) {
       if (Previous->is(tok::identifier) || Previous->isSimpleTypeSpecifier()) {
         Previous = Previous->getPreviousNonComment();
@@ -3086,8 +3086,8 @@
                (Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_Both);
     }
   }
-  const auto SpaceRequiredForArrayInitializerLSquare =
-      [](const FormatToken &LSquareTok, const FormatStyle &Style) {
+  auto const SpaceRequiredForArrayInitializerLSquare =
+      [](FormatToken const &LSquareTok, FormatStyle const &Style) {
         return Style.SpacesInContainerLiterals ||
                ((Style.Language == FormatStyle::LK_Proto ||
                  Style.Language == FormatStyle::LK_TextProto) &&
@@ -3205,9 +3205,9 @@
   return true;
 }
 
-bool TokenAnnotator::spaceRequiredBefore(const AnnotatedLine &Line,
-                                         const FormatToken &Right) {
-  const FormatToken &Left = *Right.Previous;
+bool TokenAnnotator::spaceRequiredBefore(AnnotatedLine const &Line,
+                                         FormatToken const &Right) {
+  FormatToken const &Left = *Right.Previous;
   auto HasExistingWhitespace = [&Right]() {
     return Right.WhitespaceRange.getBegin() != Right.WhitespaceRange.getEnd();
   };
@@ -3328,7 +3328,7 @@
       return true;
     if (Left.is(Keywords.kw_async) && Right.is(tok::l_paren) &&
         Right.MatchingParen) {
-      const FormatToken *Next = Right.MatchingParen->getNextNonComment();
+      FormatToken const *Next = Right.MatchingParen->getNextNonComment();
       // An async arrow function, for example: `x = async () => foo();`,
       // as opposed to calling a function called async: `x = async();`
       if (Next && Next->is(TT_FatArrow))
@@ -3582,31 +3582,31 @@
 }
 
 // Returns 'true' if 'Tok' is a brace we'd want to break before in Allman style.
-static bool isAllmanBrace(const FormatToken &Tok) {
+static bool isAllmanBrace(FormatToken const &Tok) {
   return Tok.is(tok::l_brace) && Tok.is(BK_Block) &&
          !Tok.isOneOf(TT_ObjCBlockLBrace, TT_LambdaLBrace, TT_DictLiteral);
 }
 
 // Returns 'true' if 'Tok' is an function argument.
-static bool IsFunctionArgument(const FormatToken &Tok) {
+static bool IsFunctionArgument(FormatToken const &Tok) {
   return Tok.MatchingParen && Tok.MatchingParen->Next &&
          Tok.MatchingParen->Next->isOneOf(tok::comma, tok::r_paren);
 }
 
 static bool
-isItAnEmptyLambdaAllowed(const FormatToken &Tok,
+isItAnEmptyLambdaAllowed(FormatToken const &Tok,
                          FormatStyle::ShortLambdaStyle ShortLambdaOption) {
   return Tok.Children.empty() && ShortLambdaOption != FormatStyle::SLS_None;
 }
 
-static bool isAllmanLambdaBrace(const FormatToken &Tok) {
+static bool isAllmanLambdaBrace(FormatToken const &Tok) {
   return (Tok.is(tok::l_brace) && Tok.is(BK_Block) &&
           !Tok.isOneOf(TT_ObjCBlockLBrace, TT_DictLiteral));
 }
 
 // Returns the first token on the line that is not a comment.
-static const FormatToken *getFirstNonComment(const AnnotatedLine &Line) {
-  const FormatToken *Next = Line.First;
+static FormatToken const *getFirstNonComment(AnnotatedLine const &Line) {
+  FormatToken const *Next = Line.First;
   if (!Next)
     return Next;
   if (Next->is(tok::comment))
@@ -3614,9 +3614,9 @@
   return Next;
 }
 
-bool TokenAnnotator::mustBreakBefore(const AnnotatedLine &Line,
-                                     const FormatToken &Right) {
-  const FormatToken &Left = *Right.Previous;
+bool TokenAnnotator::mustBreakBefore(AnnotatedLine const &Line,
+                                     FormatToken const &Right) {
+  FormatToken const &Left = *Right.Previous;
   if (Right.NewlinesBefore > 1 && Style.MaxEmptyLinesToKeep > 0)
     return true;
 
@@ -3725,7 +3725,7 @@
   // shuffling around entries easier. Import statements, especially in
   // JavaScript, can be an exception to this rule.
   if (Style.JavaScriptWrapImports || Line.Type != LT_ImportStatement) {
-    const FormatToken *BeforeClosingBrace = nullptr;
+    FormatToken const *BeforeClosingBrace = nullptr;
     if ((Left.isOneOf(tok::l_brace, TT_ArrayInitializerLSquare) ||
          (Style.Language == FormatStyle::LK_JavaScript &&
           Left.is(tok::l_paren))) &&
@@ -3972,9 +3972,9 @@
   return false;
 }
 
-bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
-                                    const FormatToken &Right) {
-  const FormatToken &Left = *Right.Previous;
+bool TokenAnnotator::canBreakBefore(AnnotatedLine const &Line,
+                                    FormatToken const &Right) {
+  FormatToken const &Left = *Right.Previous;
   // Language-specific stuff.
   if (Style.isCSharp()) {
     if (Left.isOneOf(TT_CSharpNamedArgumentColon, TT_AttributeColon) ||
@@ -3995,7 +3995,7 @@
                       Keywords.kw_implements))
       return true;
   } else if (Style.Language == FormatStyle::LK_JavaScript) {
-    const FormatToken *NonComment = Right.getPreviousNonComment();
+    FormatToken const *NonComment = Right.getPreviousNonComment();
     if (NonComment &&
         NonComment->isOneOf(
             tok::kw_return, Keywords.kw_yield, tok::kw_continue, tok::kw_break,
@@ -4024,7 +4024,7 @@
     // function f(): a is B { ... }
     // Do not break before is in these cases.
     if (Right.is(Keywords.kw_is)) {
-      const FormatToken *Next = Right.getNextNonComment();
+      FormatToken const *Next = Right.getNextNonComment();
       // If `is` is followed by a colon, it's likely that it's a dict key, so
       // ignore it for this check.
       // For example this is common in Polymer:
@@ -4272,9 +4272,9 @@
          (Left.is(TT_TemplateOpener) && !Right.is(TT_TemplateCloser));
 }
 
-void TokenAnnotator::printDebugInfo(const AnnotatedLine &Line) {
+void TokenAnnotator::printDebugInfo(AnnotatedLine const &Line) {
   llvm::errs() << "AnnotatedTokens(L=" << Line.Level << "):\n";
-  const FormatToken *Tok = Line.First;
+  FormatToken const *Tok = Line.First;
   while (Tok) {
     llvm::errs() << " M=" << Tok->MustBreakBefore
                  << " C=" << Tok->CanBreakBefore
@@ -4297,7 +4297,7 @@
 }
 
 FormatStyle::PointerAlignmentStyle
-TokenAnnotator::getTokenReferenceAlignment(const FormatToken &Reference) {
+TokenAnnotator::getTokenReferenceAlignment(FormatToken const &Reference) {
   assert(Reference.isOneOf(tok::amp, tok::ampamp));
   switch (Style.ReferenceAlignment) {
   case FormatStyle::RAS_Pointer:
@@ -4315,7 +4315,7 @@
 
 FormatStyle::PointerAlignmentStyle
 TokenAnnotator::getTokenPointerOrReferenceAlignment(
-    const FormatToken &PointerOrReference) {
+    FormatToken const &PointerOrReference) {
   if (PointerOrReference.isOneOf(tok::amp, tok::ampamp)) {
     switch (Style.ReferenceAlignment) {
     case FormatStyle::RAS_Pointer:
Index: clang/lib/Format/UnwrappedLineFormatter.h
===================================================================
--- clang/lib/Format/UnwrappedLineFormatter.h
+++ clang/lib/Format/UnwrappedLineFormatter.h
@@ -29,15 +29,15 @@
 public:
   UnwrappedLineFormatter(ContinuationIndenter *Indenter,
                          WhitespaceManager *Whitespaces,
-                         const FormatStyle &Style,
-                         const AdditionalKeywords &Keywords,
-                         const SourceManager &SourceMgr,
+                         FormatStyle const &Style,
+                         AdditionalKeywords const &Keywords,
+                         SourceManager const &SourceMgr,
                          FormattingAttemptStatus *Status)
       : Indenter(Indenter), Whitespaces(Whitespaces), Style(Style),
         Keywords(Keywords), SourceMgr(SourceMgr), Status(Status) {}
 
   /// Format the current block and return the penalty.
-  unsigned format(const SmallVectorImpl<AnnotatedLine *> &Lines,
+  unsigned format(SmallVectorImpl<AnnotatedLine *> const &Lines,
                   bool DryRun = false, int AdditionalIndent = 0,
                   bool FixBadIndentation = false, unsigned FirstStartColumn = 0,
                   unsigned NextStartColumn = 0, unsigned LastStartColumn = 0);
@@ -45,29 +45,29 @@
 private:
   /// Add a new line and the required indent before the first Token
   /// of the \c UnwrappedLine if there was no structural parsing error.
-  void formatFirstToken(const AnnotatedLine &Line,
-                        const AnnotatedLine *PreviousLine,
-                        const AnnotatedLine *PrevPrevLine,
-                        const SmallVectorImpl<AnnotatedLine *> &Lines,
+  void formatFirstToken(AnnotatedLine const &Line,
+                        AnnotatedLine const *PreviousLine,
+                        AnnotatedLine const *PrevPrevLine,
+                        SmallVectorImpl<AnnotatedLine *> const &Lines,
                         unsigned Indent, unsigned NewlineIndent);
 
   /// Returns the column limit for a line, taking into account whether we
   /// need an escaped newline due to a continued preprocessor directive.
   unsigned getColumnLimit(bool InPPDirective,
-                          const AnnotatedLine *NextLine) const;
+                          AnnotatedLine const *NextLine) const;
 
   // Cache to store the penalty of formatting a vector of AnnotatedLines
   // starting from a specific additional offset. Improves performance if there
   // are many nested blocks.
-  std::map<std::pair<const SmallVectorImpl<AnnotatedLine *> *, unsigned>,
+  std::map<std::pair<SmallVectorImpl<AnnotatedLine *> const *, unsigned>,
            unsigned>
       PenaltyCache;
 
   ContinuationIndenter *Indenter;
   WhitespaceManager *Whitespaces;
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
-  const SourceManager &SourceMgr;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
+  SourceManager const &SourceMgr;
   FormattingAttemptStatus *Status;
 };
 } // end namespace format
Index: clang/lib/Format/UnwrappedLineFormatter.cpp
===================================================================
--- clang/lib/Format/UnwrappedLineFormatter.cpp
+++ clang/lib/Format/UnwrappedLineFormatter.cpp
@@ -19,9 +19,9 @@
 
 namespace {
 
-bool startsExternCBlock(const AnnotatedLine &Line) {
-  const FormatToken *Next = Line.First->getNextNonComment();
-  const FormatToken *NextNext = Next ? Next->getNextNonComment() : nullptr;
+bool startsExternCBlock(AnnotatedLine const &Line) {
+  FormatToken const *Next = Line.First->getNextNonComment();
+  FormatToken const *NextNext = Next ? Next->getNextNonComment() : nullptr;
   return Line.startsWith(tok::kw_extern) && Next && Next->isStringLiteral() &&
          NextNext && NextNext->is(tok::l_brace);
 }
@@ -37,8 +37,8 @@
 /// given line.
 class LevelIndentTracker {
 public:
-  LevelIndentTracker(const FormatStyle &Style,
-                     const AdditionalKeywords &Keywords, unsigned StartLevel,
+  LevelIndentTracker(FormatStyle const &Style,
+                     AdditionalKeywords const &Keywords, unsigned StartLevel,
                      int AdditionalIndent)
       : Style(Style), Keywords(Keywords), AdditionalIndent(AdditionalIndent) {
     for (unsigned i = 0; i != StartLevel; ++i)
@@ -50,7 +50,7 @@
 
   /// Update the indent state given that \p Line is going to be formatted
   /// next.
-  void nextLine(const AnnotatedLine &Line) {
+  void nextLine(AnnotatedLine const &Line) {
     Offset = getIndentOffset(*Line.First);
     // Update the indent level cache size so that we can rely on it
     // having the right size in adjustToUnmodifiedline.
@@ -72,7 +72,7 @@
 
   /// Update the indent state given that \p Line indent should be
   /// skipped.
-  void skipLine(const AnnotatedLine &Line) {
+  void skipLine(AnnotatedLine const &Line) {
     while (IndentForLevel.size() <= Line.Level)
       IndentForLevel.push_back(Indent);
   }
@@ -82,7 +82,7 @@
   /// When a line is not formatted, we move the subsequent lines on the same
   /// level to the same indent.
   /// Note that \c nextLine must have been called before this method.
-  void adjustToUnmodifiedLine(const AnnotatedLine &Line) {
+  void adjustToUnmodifiedLine(AnnotatedLine const &Line) {
     unsigned LevelIndent = Line.First->OriginalColumn;
     if (static_cast<int>(LevelIndent) - Offset >= 0)
       LevelIndent -= Offset;
@@ -96,7 +96,7 @@
   ///
   /// For example, 'public:' labels in classes are offset by 1 or 2
   /// characters to the left from their level.
-  int getIndentOffset(const FormatToken &RootToken) {
+  int getIndentOffset(FormatToken const &RootToken) {
     if (Style.Language == FormatStyle::LK_Java ||
         Style.Language == FormatStyle::LK_JavaScript || Style.isCSharp())
       return 0;
@@ -126,9 +126,9 @@
     return getIndent(IndentForLevel, Level - 1) + Style.IndentWidth;
   }
 
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
-  const unsigned AdditionalIndent;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
+  unsigned const AdditionalIndent;
 
   /// The indent in characters for each level.
   std::vector<int> IndentForLevel;
@@ -143,9 +143,9 @@
   unsigned Indent = 0;
 };
 
-const FormatToken *getMatchingNamespaceToken(
-    const AnnotatedLine *Line,
-    const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
+FormatToken const *getMatchingNamespaceToken(
+    AnnotatedLine const *Line,
+    SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
   if (!Line->startsWith(tok::r_brace))
     return nullptr;
   size_t StartLineIndex = Line->MatchingOpeningBlockLineIndex;
@@ -155,32 +155,32 @@
   return AnnotatedLines[StartLineIndex]->First->getNamespaceToken();
 }
 
-StringRef getNamespaceTokenText(const AnnotatedLine *Line) {
-  const FormatToken *NamespaceToken = Line->First->getNamespaceToken();
+StringRef getNamespaceTokenText(AnnotatedLine const *Line) {
+  FormatToken const *NamespaceToken = Line->First->getNamespaceToken();
   return NamespaceToken ? NamespaceToken->TokenText : StringRef();
 }
 
 StringRef getMatchingNamespaceTokenText(
-    const AnnotatedLine *Line,
-    const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines) {
-  const FormatToken *NamespaceToken =
+    AnnotatedLine const *Line,
+    SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines) {
+  FormatToken const *NamespaceToken =
       getMatchingNamespaceToken(Line, AnnotatedLines);
   return NamespaceToken ? NamespaceToken->TokenText : StringRef();
 }
 
 class LineJoiner {
 public:
-  LineJoiner(const FormatStyle &Style, const AdditionalKeywords &Keywords,
-             const SmallVectorImpl<AnnotatedLine *> &Lines)
+  LineJoiner(FormatStyle const &Style, AdditionalKeywords const &Keywords,
+             SmallVectorImpl<AnnotatedLine *> const &Lines)
       : Style(Style), Keywords(Keywords), End(Lines.end()), Next(Lines.begin()),
         AnnotatedLines(Lines) {}
 
   /// Returns the next line, merging multiple lines into one if possible.
-  const AnnotatedLine *getNextMergedLine(bool DryRun,
+  AnnotatedLine const *getNextMergedLine(bool DryRun,
                                          LevelIndentTracker &IndentTracker) {
     if (Next == End)
       return nullptr;
-    const AnnotatedLine *Current = *Next;
+    AnnotatedLine const *Current = *Next;
     IndentTracker.nextLine(*Current);
     unsigned MergedLines = tryFitMultipleLinesInOne(IndentTracker, Next, End);
     if (MergedLines > 0 && Style.ColumnLimit == 0)
@@ -202,13 +202,13 @@
   tryFitMultipleLinesInOne(LevelIndentTracker &IndentTracker,
                            SmallVectorImpl<AnnotatedLine *>::const_iterator I,
                            SmallVectorImpl<AnnotatedLine *>::const_iterator E) {
-    const unsigned Indent = IndentTracker.getIndent();
+    unsigned const Indent = IndentTracker.getIndent();
 
     // Can't join the last line with anything.
     if (I + 1 == E)
       return 0;
     // We can never merge stuff if there are trailing line comments.
-    const AnnotatedLine *TheLine = *I;
+    AnnotatedLine const *TheLine = *I;
     if (TheLine->Last->is(TT_LineComment))
       return 0;
     if (I[1]->Type == LT_Invalid || I[1]->First->MustBreakBefore)
@@ -239,7 +239,7 @@
         I != AnnotatedLines.begin()) {
       bool EmptyBlock = I[1]->First->is(tok::r_brace);
 
-      const FormatToken *Tok = I[-1]->First;
+      FormatToken const *Tok = I[-1]->First;
       if (Tok && Tok->is(tok::comment))
         Tok = Tok->getNextNonComment();
 
@@ -373,7 +373,7 @@
     if (Style.BraceWrapping.SplitEmptyRecord &&
         TheLine->Last->is(tok::l_brace) && I != AnnotatedLines.begin() &&
         I[-1]->Last) {
-      const FormatToken *Previous = I[-1]->Last;
+      FormatToken const *Previous = I[-1]->Last;
       if (Previous) {
         if (Previous->is(tok::comment))
           Previous = Previous->getPreviousNonComment();
@@ -381,7 +381,7 @@
           if (Previous->is(tok::greater) && !I[-1]->InPPDirective)
             return 0;
           if (Previous->is(tok::identifier)) {
-            const FormatToken *PreviousPrevious =
+            FormatToken const *PreviousPrevious =
                 Previous->getPreviousNonComment();
             if (PreviousPrevious &&
                 PreviousPrevious->isOneOf(tok::kw_class, tok::kw_struct))
@@ -517,11 +517,11 @@
     unsigned Length = 0;
     bool EndsWithComment = false;
     bool InPPDirective = I[0]->InPPDirective;
-    const unsigned Level = I[0]->Level;
+    unsigned const Level = I[0]->Level;
     for (; NumStmts < 3; ++NumStmts) {
       if (I + 1 + NumStmts == E)
         break;
-      const AnnotatedLine *Line = I[1 + NumStmts];
+      AnnotatedLine const *Line = I[1 + NumStmts];
       if (Line->InPPDirective != InPPDirective)
         break;
       if (Line->First->isOneOf(tok::kw_case, tok::kw_default, tok::r_brace))
@@ -574,7 +574,7 @@
       return 0;
     // default: in switch statement
     if (Line.First->is(tok::kw_default)) {
-      const FormatToken *Tok = Line.First->getNextNonComment();
+      FormatToken const *Tok = Line.First->getNextNonComment();
       if (Tok && Tok->is(tok::colon))
         return 0;
     }
@@ -726,15 +726,15 @@
     return 1 + I[1]->Last->TotalLength + 1 + I[2]->Last->TotalLength <= Limit;
   }
 
-  bool containsMustBreak(const AnnotatedLine *Line) {
-    for (const FormatToken *Tok = Line->First; Tok; Tok = Tok->Next) {
+  bool containsMustBreak(AnnotatedLine const *Line) {
+    for (FormatToken const *Tok = Line->First; Tok; Tok = Tok->Next) {
       if (Tok->MustBreakBefore)
         return true;
     }
     return false;
   }
 
-  void join(AnnotatedLine &A, const AnnotatedLine &B) {
+  void join(AnnotatedLine &A, AnnotatedLine const &B) {
     assert(!A.Last->Next);
     assert(!B.First->Previous);
     if (B.Affected)
@@ -749,12 +749,12 @@
     }
   }
 
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
-  const SmallVectorImpl<AnnotatedLine *>::const_iterator End;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
+  SmallVectorImpl<AnnotatedLine *>::const_iterator const End;
 
   SmallVectorImpl<AnnotatedLine *>::const_iterator Next;
-  const SmallVectorImpl<AnnotatedLine *> &AnnotatedLines;
+  SmallVectorImpl<AnnotatedLine *> const &AnnotatedLines;
 };
 
 static void markFinalized(FormatToken *Tok) {
@@ -766,9 +766,9 @@
 }
 
 #ifndef NDEBUG
-static void printLineState(const LineState &State) {
+static void printLineState(LineState const &State) {
   llvm::dbgs() << "State: ";
-  for (const ParenState &P : State.Stack) {
+  for (ParenState const &P : State.Stack) {
     llvm::dbgs() << (P.Tok ? P.Tok->TokenText : "F") << "|" << P.Indent << "|"
                  << P.LastSpace << "|" << P.NestedBlockIndent << " ";
   }
@@ -780,7 +780,7 @@
 class LineFormatter {
 public:
   LineFormatter(ContinuationIndenter *Indenter, WhitespaceManager *Whitespaces,
-                const FormatStyle &Style,
+                FormatStyle const &Style,
                 UnwrappedLineFormatter *BlockFormatter)
       : Indenter(Indenter), Whitespaces(Whitespaces), Style(Style),
         BlockFormatter(BlockFormatter) {}
@@ -789,7 +789,7 @@
   /// Formats an \c AnnotatedLine and returns the penalty.
   ///
   /// If \p DryRun is \c false, directly applies the changes.
-  virtual unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
+  virtual unsigned formatLine(AnnotatedLine const &Line, unsigned FirstIndent,
                               unsigned FirstStartColumn, bool DryRun) = 0;
 
 protected:
@@ -815,7 +815,7 @@
   /// break or don't break.
   bool formatChildren(LineState &State, bool NewLine, bool DryRun,
                       unsigned &Penalty) {
-    const FormatToken *LBrace = State.NextToken->getPreviousNonComment();
+    FormatToken const *LBrace = State.NextToken->getPreviousNonComment();
     FormatToken &Previous = *State.NextToken->Previous;
     if (!LBrace || LBrace->isNot(tok::l_brace) || LBrace->isNot(BK_Block) ||
         Previous.Children.size() == 0)
@@ -824,7 +824,7 @@
       return true;
 
     if (NewLine) {
-      const ParenState &P = State.Stack.back();
+      ParenState const &P = State.Stack.back();
 
       int AdditionalIndent =
           P.Indent - Previous.Children[0]->Level * Style.IndentWidth;
@@ -856,7 +856,7 @@
     if (Previous.Children.size() > 1)
       return false;
 
-    const AnnotatedLine *Child = Previous.Children[0];
+    AnnotatedLine const *Child = Previous.Children[0];
     // We can't put the closing "}" on a line with a trailing comment.
     if (Child->Last->isTrailingComment())
       return false;
@@ -884,7 +884,7 @@
 
 private:
   WhitespaceManager *Whitespaces;
-  const FormatStyle &Style;
+  FormatStyle const &Style;
   UnwrappedLineFormatter *BlockFormatter;
 };
 
@@ -893,13 +893,13 @@
 public:
   NoColumnLimitLineFormatter(ContinuationIndenter *Indenter,
                              WhitespaceManager *Whitespaces,
-                             const FormatStyle &Style,
+                             FormatStyle const &Style,
                              UnwrappedLineFormatter *BlockFormatter)
       : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
 
   /// Formats the line, simply keeping all of the input's line breaking
   /// decisions.
-  unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
+  unsigned formatLine(AnnotatedLine const &Line, unsigned FirstIndent,
                       unsigned FirstStartColumn, bool DryRun) override {
     assert(!DryRun);
     LineState State = Indenter->getInitialState(FirstIndent, FirstStartColumn,
@@ -920,12 +920,12 @@
 class NoLineBreakFormatter : public LineFormatter {
 public:
   NoLineBreakFormatter(ContinuationIndenter *Indenter,
-                       WhitespaceManager *Whitespaces, const FormatStyle &Style,
+                       WhitespaceManager *Whitespaces, FormatStyle const &Style,
                        UnwrappedLineFormatter *BlockFormatter)
       : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
 
   /// Puts all tokens into a single line.
-  unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
+  unsigned formatLine(AnnotatedLine const &Line, unsigned FirstIndent,
                       unsigned FirstStartColumn, bool DryRun) override {
     unsigned Penalty = 0;
     LineState State =
@@ -944,13 +944,13 @@
 public:
   OptimizingLineFormatter(ContinuationIndenter *Indenter,
                           WhitespaceManager *Whitespaces,
-                          const FormatStyle &Style,
+                          FormatStyle const &Style,
                           UnwrappedLineFormatter *BlockFormatter)
       : LineFormatter(Indenter, Whitespaces, Style, BlockFormatter) {}
 
   /// Formats the line by finding the best line breaks with line lengths
   /// below the column limit.
-  unsigned formatLine(const AnnotatedLine &Line, unsigned FirstIndent,
+  unsigned formatLine(AnnotatedLine const &Line, unsigned FirstIndent,
                       unsigned FirstStartColumn, bool DryRun) override {
     LineState State =
         Indenter->getInitialState(FirstIndent, FirstStartColumn, &Line, DryRun);
@@ -981,7 +981,7 @@
   /// An edge in the solution space from \c Previous->State to \c State,
   /// inserting a newline dependent on the \c NewLine.
   struct StateNode {
-    StateNode(const LineState &State, bool NewLine, StateNode *Previous)
+    StateNode(LineState const &State, bool NewLine, StateNode *Previous)
         : State(State), NewLine(NewLine), Previous(Previous) {}
     LineState State;
     bool NewLine;
@@ -1119,13 +1119,13 @@
 } // anonymous namespace
 
 unsigned UnwrappedLineFormatter::format(
-    const SmallVectorImpl<AnnotatedLine *> &Lines, bool DryRun,
+    SmallVectorImpl<AnnotatedLine *> const &Lines, bool DryRun,
     int AdditionalIndent, bool FixBadIndentation, unsigned FirstStartColumn,
     unsigned NextStartColumn, unsigned LastStartColumn) {
   LineJoiner Joiner(Style, Keywords, Lines);
 
   // Try to look up already computed penalty in DryRun-mode.
-  std::pair<const SmallVectorImpl<AnnotatedLine *> *, unsigned> CacheKey(
+  std::pair<SmallVectorImpl<AnnotatedLine *> const *, unsigned> CacheKey(
       &Lines, AdditionalIndent);
   auto CacheIt = PenaltyCache.find(CacheKey);
   if (DryRun && CacheIt != PenaltyCache.end())
@@ -1135,18 +1135,18 @@
   unsigned Penalty = 0;
   LevelIndentTracker IndentTracker(Style, Keywords, Lines[0]->Level,
                                    AdditionalIndent);
-  const AnnotatedLine *PrevPrevLine = nullptr;
-  const AnnotatedLine *PreviousLine = nullptr;
-  const AnnotatedLine *NextLine = nullptr;
+  AnnotatedLine const *PrevPrevLine = nullptr;
+  AnnotatedLine const *PreviousLine = nullptr;
+  AnnotatedLine const *NextLine = nullptr;
 
   // The minimum level of consecutive lines that have been formatted.
   unsigned RangeMinLevel = UINT_MAX;
 
   bool FirstLine = true;
-  for (const AnnotatedLine *Line =
+  for (AnnotatedLine const *Line =
            Joiner.getNextMergedLine(DryRun, IndentTracker);
        Line; Line = NextLine, FirstLine = false) {
-    const AnnotatedLine &TheLine = *Line;
+    AnnotatedLine const &TheLine = *Line;
     unsigned Indent = IndentTracker.getIndent();
 
     // We continue formatting unchanged lines to adjust their indent, e.g. if a
@@ -1204,7 +1204,7 @@
       // If no token in the current line is affected, we still need to format
       // affected children.
       if (TheLine.ChildrenAffected)
-        for (const FormatToken *Tok = TheLine.First; Tok; Tok = Tok->Next)
+        for (FormatToken const *Tok = TheLine.First; Tok; Tok = Tok->Next)
           if (!Tok->Children.empty())
             format(Tok->Children, DryRun);
 
@@ -1244,9 +1244,9 @@
 }
 
 void UnwrappedLineFormatter::formatFirstToken(
-    const AnnotatedLine &Line, const AnnotatedLine *PreviousLine,
-    const AnnotatedLine *PrevPrevLine,
-    const SmallVectorImpl<AnnotatedLine *> &Lines, unsigned Indent,
+    AnnotatedLine const &Line, AnnotatedLine const *PreviousLine,
+    AnnotatedLine const *PrevPrevLine,
+    SmallVectorImpl<AnnotatedLine *> const &Lines, unsigned Indent,
     unsigned NewlineIndent) {
   FormatToken &RootToken = *Line.First;
   if (RootToken.is(tok::eof)) {
@@ -1299,7 +1299,7 @@
         Newlines = 1; // Previous is an access modifier remove all new lines.
       break;
     case FormatStyle::ELBAMS_Always: {
-      const FormatToken *previousToken;
+      FormatToken const *previousToken;
       if (PreviousLine->Last->is(tok::comment))
         previousToken = PreviousLine->Last->getPreviousNonComment();
       else
@@ -1350,7 +1350,7 @@
 
 unsigned
 UnwrappedLineFormatter::getColumnLimit(bool InPPDirective,
-                                       const AnnotatedLine *NextLine) const {
+                                       AnnotatedLine const *NextLine) const {
   // In preprocessor directives reserve two chars for trailing " \" if the
   // next line continues the preprocessor directive.
   bool ContinuesPPDirective =
Index: clang/lib/Format/UnwrappedLineParser.h
===================================================================
--- clang/lib/Format/UnwrappedLineParser.h
+++ clang/lib/Format/UnwrappedLineParser.h
@@ -66,7 +66,7 @@
 class UnwrappedLineConsumer {
 public:
   virtual ~UnwrappedLineConsumer() {}
-  virtual void consumeUnwrappedLine(const UnwrappedLine &Line) = 0;
+  virtual void consumeUnwrappedLine(UnwrappedLine const &Line) = 0;
   virtual void finishRun() = 0;
 };
 
@@ -74,8 +74,8 @@
 
 class UnwrappedLineParser {
 public:
-  UnwrappedLineParser(const FormatStyle &Style,
-                      const AdditionalKeywords &Keywords,
+  UnwrappedLineParser(FormatStyle const &Style,
+                      AdditionalKeywords const &Keywords,
                       unsigned FirstStartColumn, ArrayRef<FormatToken *> Tokens,
                       UnwrappedLineConsumer &Callback);
 
@@ -166,8 +166,8 @@
   // NextTok specifies the next token. A null pointer NextTok is supported, and
   // signifies either the absence of a next token, or that the next token
   // shouldn't be taken into accunt for the analysis.
-  void distributeComments(const SmallVectorImpl<FormatToken *> &Comments,
-                          const FormatToken *NextTok);
+  void distributeComments(SmallVectorImpl<FormatToken *> const &Comments,
+                          FormatToken const *NextTok);
 
   // Adds the comment preceding the next token to unwrapped lines.
   void flushComments(bool NewlineBeforeNext);
@@ -183,7 +183,7 @@
   void conditionalCompilationAlternative();
   void conditionalCompilationEnd();
 
-  bool isOnNewLine(const FormatToken &FormatTok);
+  bool isOnNewLine(FormatToken const &FormatTok);
 
   // Compute hash of the current preprocessor branch.
   // This is used to identify the different branches, and thus track if block
@@ -221,8 +221,8 @@
   // whether we are in a compound statement or not.
   std::vector<bool> DeclarationScopeStack;
 
-  const FormatStyle &Style;
-  const AdditionalKeywords &Keywords;
+  FormatStyle const &Style;
+  AdditionalKeywords const &Keywords;
 
   llvm::Regex CommentPragmasRegex;
 
Index: clang/lib/Format/UnwrappedLineParser.cpp
===================================================================
--- clang/lib/Format/UnwrappedLineParser.cpp
+++ clang/lib/Format/UnwrappedLineParser.cpp
@@ -57,16 +57,16 @@
   std::vector<bool> &Stack;
 };
 
-static bool isLineComment(const FormatToken &FormatTok) {
+static bool isLineComment(FormatToken const &FormatTok) {
   return FormatTok.is(tok::comment) && !FormatTok.TokenText.startswith("/*");
 }
 
 // Checks if \p FormatTok is a line comment that continues the line comment
 // \p Previous. The original column of \p MinColumnToken is used to determine
 // whether \p FormatTok is indented enough to the right to continue \p Previous.
-static bool continuesLineComment(const FormatToken &FormatTok,
-                                 const FormatToken *Previous,
-                                 const FormatToken *MinColumnToken) {
+static bool continuesLineComment(FormatToken const &FormatTok,
+                                 FormatToken const *Previous,
+                                 FormatToken const *MinColumnToken) {
   if (!Previous || !MinColumnToken)
     return false;
   unsigned MinContinueColumn =
@@ -172,7 +172,7 @@
 class CompoundStatementIndenter {
 public:
   CompoundStatementIndenter(UnwrappedLineParser *Parser,
-                            const FormatStyle &Style, unsigned &LineLevel)
+                            FormatStyle const &Style, unsigned &LineLevel)
       : CompoundStatementIndenter(Parser, LineLevel,
                                   Style.BraceWrapping.AfterControlStatement,
                                   Style.BraceWrapping.IndentBraces) {}
@@ -222,8 +222,8 @@
 
 } // end anonymous namespace
 
-UnwrappedLineParser::UnwrappedLineParser(const FormatStyle &Style,
-                                         const AdditionalKeywords &Keywords,
+UnwrappedLineParser::UnwrappedLineParser(FormatStyle const &Style,
+                                         AdditionalKeywords const &Keywords,
                                          unsigned FirstStartColumn,
                                          ArrayRef<FormatToken *> Tokens,
                                          UnwrappedLineConsumer &Callback)
@@ -444,7 +444,7 @@
   // definitions, too.
   unsigned StoredPosition = Tokens->getPosition();
   FormatToken *Tok = FormatTok;
-  const FormatToken *PrevTok = Tok->Previous;
+  FormatToken const *PrevTok = Tok->Previous;
   // Keep a stack of positions of lbrace tokens. We will
   // update information about whether an lbrace starts a
   // braced init list or a different block during the loop.
@@ -565,14 +565,14 @@
 }
 
 template <class T>
-static inline void hash_combine(std::size_t &seed, const T &v) {
+inline static void hash_combine(std::size_t &seed, const T &v) {
   std::hash<T> hasher;
   seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 }
 
 size_t UnwrappedLineParser::computePPHash() const {
   size_t h = 0;
-  for (const auto &i : PPStack) {
+  for (auto const &i : PPStack) {
     hash_combine(h, size_t(i.Kind));
     hash_combine(h, i.Line);
   }
@@ -584,7 +584,7 @@
                                      bool UnindentWhitesmithsBraces) {
   assert(FormatTok->isOneOf(tok::l_brace, TT_MacroBlockBegin) &&
          "'{' or macro block token expected");
-  const bool MacroBlock = FormatTok->is(TT_MacroBlockBegin);
+  bool const MacroBlock = FormatTok->is(TT_MacroBlockBegin);
   FormatTok->setBlockKind(BK_Block);
 
   // For Whitesmiths mode, jump to the next level prior to skipping over the
@@ -660,7 +660,7 @@
   }
 }
 
-static bool isGoogScope(const UnwrappedLine &Line) {
+static bool isGoogScope(UnwrappedLine const &Line) {
   // FIXME: Closure-library specific stuff should not be hard-coded but be
   // configurable.
   if (Line.Tokens.size() < 4)
@@ -678,8 +678,8 @@
   return I->Tok->is(tok::l_paren);
 }
 
-static bool isIIFE(const UnwrappedLine &Line,
-                   const AdditionalKeywords &Keywords) {
+static bool isIIFE(UnwrappedLine const &Line,
+                   AdditionalKeywords const &Keywords) {
   // Look for the start of an immediately invoked anonymous function.
   // https://en.wikipedia.org/wiki/Immediately-invoked_function_expression
   // This is commonly done in JavaScript to create a new, anonymous scope.
@@ -696,8 +696,8 @@
   return I->Tok->is(tok::l_paren);
 }
 
-static bool ShouldBreakBeforeBrace(const FormatStyle &Style,
-                                   const FormatToken &InitialToken) {
+static bool ShouldBreakBeforeBrace(FormatStyle const &Style,
+                                   FormatToken const &InitialToken) {
   if (InitialToken.isOneOf(tok::kw_namespace, TT_NamespaceMacro))
     return Style.BraceWrapping.AfterNamespace;
   if (InitialToken.is(tok::kw_class))
@@ -925,7 +925,7 @@
 // Here we exclude certain tokens that are not usually the first token in an
 // unwrapped line. This is used in attempt to distinguish macro calls without
 // trailing semicolons from other constructs split to several lines.
-static bool tokenCanStartNewLine(const FormatToken &Tok) {
+static bool tokenCanStartNewLine(FormatToken const &Tok) {
   // Semicolon can be a null-statement, l_square can be a start of a macro or
   // a C++11 attribute, but this doesn't seem to be common.
   return Tok.isNot(tok::semi) && Tok.isNot(tok::l_brace) &&
@@ -951,8 +951,8 @@
          Tok.isNot(tok::kw_noexcept);
 }
 
-static bool mustBeJSIdent(const AdditionalKeywords &Keywords,
-                          const FormatToken *FormatTok) {
+static bool mustBeJSIdent(AdditionalKeywords const &Keywords,
+                          FormatToken const *FormatTok) {
   // FIXME: This returns true for C/C++ keywords like 'struct'.
   return FormatTok->is(tok::identifier) &&
          (FormatTok->Tok.getIdentifierInfo() == nullptr ||
@@ -966,8 +966,8 @@
               Keywords.kw_override, Keywords.kw_throws, Keywords.kw_from));
 }
 
-static bool mustBeJSIdentOrValue(const AdditionalKeywords &Keywords,
-                                 const FormatToken *FormatTok) {
+static bool mustBeJSIdentOrValue(AdditionalKeywords const &Keywords,
+                                 FormatToken const *FormatTok) {
   return FormatTok->Tok.isLiteral() ||
          FormatTok->isOneOf(tok::kw_true, tok::kw_false) ||
          mustBeJSIdent(Keywords, FormatTok);
@@ -975,8 +975,8 @@
 
 // isJSDeclOrStmt returns true if |FormatTok| starts a declaration or statement
 // when encountered after a value (see mustBeJSIdentOrValue).
-static bool isJSDeclOrStmt(const AdditionalKeywords &Keywords,
-                           const FormatToken *FormatTok) {
+static bool isJSDeclOrStmt(AdditionalKeywords const &Keywords,
+                           FormatToken const *FormatTok) {
   return FormatTok->isOneOf(
       tok::kw_return, Keywords.kw_yield,
       // conditionals
@@ -995,7 +995,7 @@
 }
 
 // Checks whether a token is a type in K&R C (aka C78).
-static bool isC78Type(const FormatToken &Tok) {
+static bool isC78Type(FormatToken const &Tok) {
   return Tok.isOneOf(tok::kw_char, tok::kw_short, tok::kw_int, tok::kw_long,
                      tok::kw_unsigned, tok::kw_float, tok::kw_double,
                      tok::identifier);
@@ -1008,8 +1008,8 @@
 //   {
 //      return a + b;
 //   }
-static bool isC78ParameterDecl(const FormatToken *Tok, const FormatToken *Next,
-                               const FormatToken *FuncName) {
+static bool isC78ParameterDecl(FormatToken const *Tok, FormatToken const *Next,
+                               FormatToken const *FuncName) {
   assert(Tok);
   assert(Next);
   assert(FuncName);
@@ -1017,7 +1017,7 @@
   if (FuncName->isNot(tok::identifier))
     return false;
 
-  const FormatToken *Prev = FuncName->Previous;
+  FormatToken const *Prev = FuncName->Previous;
   if (!Prev || (Prev->isNot(tok::star) && !isC78Type(*Prev)))
     return false;
 
@@ -1264,7 +1264,7 @@
     break;
   }
   do {
-    const FormatToken *Previous = FormatTok->Previous;
+    FormatToken const *Previous = FormatTok->Previous;
     switch (FormatTok->Tok.getKind()) {
     case tok::at:
       nextToken();
@@ -1392,7 +1392,7 @@
       // declaration.
       if (!IsTopLevel || !Style.isCpp() || !Previous || FormatTok->is(tok::eof))
         break;
-      const unsigned Position = Tokens->getPosition() + 1;
+      unsigned const Position = Tokens->getPosition() + 1;
       assert(Position < AllTokens.size());
       if (isC78ParameterDecl(FormatTok, AllTokens[Position], Previous)) {
         addUnwrappedLine();
@@ -1769,7 +1769,7 @@
 }
 
 bool UnwrappedLineParser::tryToParseLambdaIntroducer() {
-  const FormatToken *Previous = FormatTok->Previous;
+  FormatToken const *Previous = FormatTok->Previous;
   if (Previous &&
       (Previous->isOneOf(tok::identifier, tok::kw_operator, tok::kw_new,
                          tok::kw_delete, tok::l_square) ||
@@ -2200,7 +2200,7 @@
   assert(FormatTok->isOneOf(tok::kw_namespace, TT_NamespaceMacro) &&
          "'namespace' expected");
 
-  const FormatToken &InitialToken = *FormatTok;
+  FormatToken const &InitialToken = *FormatTok;
   nextToken();
   if (InitialToken.is(TT_NamespaceMacro)) {
     parseParens();
@@ -2532,7 +2532,7 @@
   if (FormatTok->Tok.is(tok::kw_enum))
     nextToken();
 
-  const FormatToken &InitialToken = *FormatTok;
+  FormatToken const &InitialToken = *FormatTok;
 
   // In TypeScript, "enum" can also be used as property name, e.g. in interface
   // declarations. An "enum" keyword followed by a colon would be a syntax
@@ -2729,7 +2729,7 @@
 }
 
 void UnwrappedLineParser::parseRecord(bool ParseAsExpr) {
-  const FormatToken &InitialToken = *FormatTok;
+  FormatToken const &InitialToken = *FormatTok;
   nextToken();
 
   // The actual identifier can be a nested name specifier, and in macros
@@ -3019,7 +3019,7 @@
   addUnwrappedLine();
 }
 
-LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(const UnwrappedLine &Line,
+LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(UnwrappedLine const &Line,
                                                  StringRef Prefix = "") {
   llvm::dbgs() << Prefix << "Line(" << Line.Level
                << ", FSC=" << Line.FirstStartColumn << ")"
@@ -3034,7 +3034,7 @@
   for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
                                                     E = Line.Tokens.end();
        I != E; ++I) {
-    const UnwrappedLineNode &Node = *I;
+    UnwrappedLineNode const &Node = *I;
     for (SmallVectorImpl<UnwrappedLine>::const_iterator
              I = Node.Children.begin(),
              E = Node.Children.end();
@@ -3080,7 +3080,7 @@
 
 bool UnwrappedLineParser::eof() const { return FormatTok->Tok.is(tok::eof); }
 
-bool UnwrappedLineParser::isOnNewLine(const FormatToken &FormatTok) {
+bool UnwrappedLineParser::isOnNewLine(FormatToken const &FormatTok) {
   return (Line->InPPDirective || FormatTok.HasUnescapedNewline) &&
          FormatTok.NewlinesBefore > 0;
 }
@@ -3088,9 +3088,9 @@
 // Checks if \p FormatTok is a line comment that continues the line comment
 // section on \p Line.
 static bool
-continuesLineCommentSection(const FormatToken &FormatTok,
-                            const UnwrappedLine &Line,
-                            const llvm::Regex &CommentPragmasRegex) {
+continuesLineCommentSection(FormatToken const &FormatTok,
+                            UnwrappedLine const &Line,
+                            llvm::Regex const &CommentPragmasRegex) {
   if (Line.Tokens.empty())
     return false;
 
@@ -3167,12 +3167,12 @@
   //   a, // first line
   //   // second line
   // };
-  const FormatToken *MinColumnToken = Line.Tokens.front().Tok;
+  FormatToken const *MinColumnToken = Line.Tokens.front().Tok;
 
   // Scan for '{//'. If found, use the column of '{' as a min column for line
   // comment section continuation.
-  const FormatToken *PreviousToken = nullptr;
-  for (const UnwrappedLineNode &Node : Line.Tokens) {
+  FormatToken const *PreviousToken = nullptr;
+  for (UnwrappedLineNode const &Node : Line.Tokens) {
     if (PreviousToken && PreviousToken->is(tok::l_brace) &&
         isLineComment(*Node.Tok)) {
       MinColumnToken = PreviousToken;
@@ -3232,8 +3232,8 @@
 }
 
 void UnwrappedLineParser::distributeComments(
-    const SmallVectorImpl<FormatToken *> &Comments,
-    const FormatToken *NextTok) {
+    SmallVectorImpl<FormatToken *> const &Comments,
+    FormatToken const *NextTok) {
   // Whether or not a line comment token continues a line is controlled by
   // the method continuesLineCommentSection, with the following caveat:
   //
Index: clang/lib/Format/UsingDeclarationsSorter.h
===================================================================
--- clang/lib/Format/UsingDeclarationsSorter.h
+++ clang/lib/Format/UsingDeclarationsSorter.h
@@ -22,7 +22,7 @@
 
 class UsingDeclarationsSorter : public TokenAnalyzer {
 public:
-  UsingDeclarationsSorter(const Environment &Env, const FormatStyle &Style);
+  UsingDeclarationsSorter(Environment const &Env, FormatStyle const &Style);
 
   std::pair<tooling::Replacements, unsigned>
   analyze(TokenAnnotator &Annotator,
Index: clang/lib/Format/UsingDeclarationsSorter.cpp
===================================================================
--- clang/lib/Format/UsingDeclarationsSorter.cpp
+++ clang/lib/Format/UsingDeclarationsSorter.cpp
@@ -65,13 +65,13 @@
 }
 
 struct UsingDeclaration {
-  const AnnotatedLine *Line;
+  AnnotatedLine const *Line;
   std::string Label;
 
-  UsingDeclaration(const AnnotatedLine *Line, const std::string &Label)
+  UsingDeclaration(AnnotatedLine const *Line, std::string const &Label)
       : Line(Line), Label(Label) {}
 
-  bool operator<(const UsingDeclaration &Other) const {
+  bool operator<(UsingDeclaration const &Other) const {
     return compareLabels(Label, Other.Label) < 0;
   }
 };
@@ -84,10 +84,10 @@
 /// and not type aliases, as in:
 /// using A = B::C;
 /// Type aliases are in general not safe to permute.
-std::string computeUsingDeclarationLabel(const FormatToken *UsingTok) {
+std::string computeUsingDeclarationLabel(FormatToken const *UsingTok) {
   assert(UsingTok && UsingTok->is(tok::kw_using) && "Expecting a using token");
   std::string Label;
-  const FormatToken *Tok = UsingTok->Next;
+  FormatToken const *Tok = UsingTok->Next;
   if (Tok && Tok->is(tok::kw_typename)) {
     Label.append("typename ");
     Tok = Tok->Next;
@@ -113,9 +113,9 @@
 
 void endUsingDeclarationBlock(
     SmallVectorImpl<UsingDeclaration> *UsingDeclarations,
-    const SourceManager &SourceMgr, tooling::Replacements *Fixes) {
+    SourceManager const &SourceMgr, tooling::Replacements *Fixes) {
   bool BlockAffected = false;
-  for (const UsingDeclaration &Declaration : *UsingDeclarations) {
+  for (UsingDeclaration const &Declaration : *UsingDeclarations) {
     if (Declaration.Line->Affected) {
       BlockAffected = true;
       break;
@@ -131,7 +131,7 @@
   SortedUsingDeclarations.erase(
       std::unique(SortedUsingDeclarations.begin(),
                   SortedUsingDeclarations.end(),
-                  [](const UsingDeclaration &a, const UsingDeclaration &b) {
+                  [](UsingDeclaration const &a, UsingDeclaration const &b) {
                     return a.Label == b.Label;
                   }),
       SortedUsingDeclarations.end());
@@ -177,19 +177,19 @@
 
 } // namespace
 
-UsingDeclarationsSorter::UsingDeclarationsSorter(const Environment &Env,
-                                                 const FormatStyle &Style)
+UsingDeclarationsSorter::UsingDeclarationsSorter(Environment const &Env,
+                                                 FormatStyle const &Style)
     : TokenAnalyzer(Env, Style) {}
 
 std::pair<tooling::Replacements, unsigned> UsingDeclarationsSorter::analyze(
     TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
     FormatTokenLexer &Tokens) {
-  const SourceManager &SourceMgr = Env.getSourceManager();
+  SourceManager const &SourceMgr = Env.getSourceManager();
   AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
   tooling::Replacements Fixes;
   SmallVector<UsingDeclaration, 4> UsingDeclarations;
   for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
-    const auto *FirstTok = AnnotatedLines[I]->First;
+    auto const *FirstTok = AnnotatedLines[I]->First;
     if (AnnotatedLines[I]->InPPDirective ||
         !AnnotatedLines[I]->startsWith(tok::kw_using) || FirstTok->Finalized) {
       endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
@@ -197,7 +197,7 @@
     }
     if (FirstTok->NewlinesBefore > 1)
       endUsingDeclarationBlock(&UsingDeclarations, SourceMgr, &Fixes);
-    const auto *UsingTok =
+    auto const *UsingTok =
         FirstTok->is(tok::comment) ? FirstTok->getNextNonComment() : FirstTok;
     std::string Label = computeUsingDeclarationLabel(UsingTok);
     if (Label.empty()) {
Index: clang/lib/Format/WhitespaceManager.h
===================================================================
--- clang/lib/Format/WhitespaceManager.h
+++ clang/lib/Format/WhitespaceManager.h
@@ -39,7 +39,7 @@
 /// There may be multiple calls to \c breakToken for a given token.
 class WhitespaceManager {
 public:
-  WhitespaceManager(const SourceManager &SourceMgr, const FormatStyle &Style,
+  WhitespaceManager(SourceManager const &SourceMgr, FormatStyle const &Style,
                     bool UseCRLF)
       : SourceMgr(SourceMgr), Style(Style), UseCRLF(UseCRLF) {}
 
@@ -59,9 +59,9 @@
   ///
   /// Needs to be called for every token for which \c replaceWhitespace
   /// was not called.
-  void addUntouchableToken(const FormatToken &Tok, bool InPPDirective);
+  void addUntouchableToken(FormatToken const &Tok, bool InPPDirective);
 
-  llvm::Error addReplacement(const tooling::Replacement &Replacement);
+  llvm::Error addReplacement(tooling::Replacement const &Replacement);
 
   /// Inserts or replaces whitespace in the middle of a token.
   ///
@@ -77,14 +77,14 @@
   ///
   /// When \p InPPDirective is true, escaped newlines are inserted. \p Spaces is
   /// used to align backslashes correctly.
-  void replaceWhitespaceInToken(const FormatToken &Tok, unsigned Offset,
+  void replaceWhitespaceInToken(FormatToken const &Tok, unsigned Offset,
                                 unsigned ReplaceChars,
                                 StringRef PreviousPostfix,
                                 StringRef CurrentPrefix, bool InPPDirective,
                                 unsigned Newlines, int Spaces);
 
   /// Returns all the \c Replacements created during formatting.
-  const tooling::Replacements &generateReplacements();
+  tooling::Replacements const &generateReplacements();
 
   /// Represents a change before a token, a break inside a token,
   /// or the layout of an unchanged token (or whitespace within).
@@ -92,11 +92,11 @@
     /// Functor to sort changes in original source order.
     class IsBeforeInFile {
     public:
-      IsBeforeInFile(const SourceManager &SourceMgr) : SourceMgr(SourceMgr) {}
-      bool operator()(const Change &C1, const Change &C2) const;
+      IsBeforeInFile(SourceManager const &SourceMgr) : SourceMgr(SourceMgr) {}
+      bool operator()(Change const &C1, Change const &C2) const;
 
     private:
-      const SourceManager &SourceMgr;
+      SourceManager const &SourceMgr;
     };
 
     /// Creates a \c Change.
@@ -108,7 +108,7 @@
     ///
     /// \p StartOfTokenColumn and \p InPPDirective will be used to lay out
     /// trailing comments and escaped newlines.
-    Change(const FormatToken &Tok, bool CreateReplacement,
+    Change(FormatToken const &Tok, bool CreateReplacement,
            SourceRange OriginalWhitespaceRange, int Spaces,
            unsigned StartOfTokenColumn, unsigned NewlinesBefore,
            StringRef PreviousLinePostfix, StringRef CurrentLinePrefix,
@@ -118,7 +118,7 @@
     // this change inserts whitespace.
     // FIXME: Currently this is not set correctly for breaks inside comments, as
     // the \c BreakableToken is still doing its own alignment.
-    const FormatToken *Tok;
+    FormatToken const *Tok;
 
     bool CreateReplacement;
     // Changes might be in the middle of a token, so we cannot just keep the
@@ -158,7 +158,7 @@
     // comment. \c IndentationOffset is a relative column offset to this
     // change, so that the correct column can be reconstructed at the end of
     // the alignment process.
-    const Change *StartOfBlockComment;
+    Change const *StartOfBlockComment;
     int IndentationOffset;
 
     // Depth of conditionals. Computed from tracking fake parenthesis, except
@@ -182,11 +182,11 @@
     bool HasSplit = false;
     CellDescription *NextColumnElement = nullptr;
 
-    constexpr bool operator==(const CellDescription &Other) const {
+    constexpr bool operator==(CellDescription const &Other) const {
       return Index == Other.Index && Cell == Other.Cell &&
              EndIndex == Other.EndIndex;
     }
-    constexpr bool operator!=(const CellDescription &Other) const {
+    constexpr bool operator!=(CellDescription const &Other) const {
       return !(*this == Other);
     }
   };
@@ -255,7 +255,7 @@
   CellDescriptions getCells(unsigned Start, unsigned End);
 
   /// Does this \p Cell contain a split element?
-  static bool isSplitCell(const CellDescription &Cell);
+  static bool isSplitCell(CellDescription const &Cell);
 
   /// Get the width of the preceeding cells from \p Start to \p End.
   template <typename I>
@@ -279,7 +279,7 @@
         calculateCellWidth(CellIter->Index, CellIter->EndIndex, true);
     if (Changes[CellIter->Index].NewlinesBefore == 0)
       CellWidth += NetWidth;
-    for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+    for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
          Next = Next->NextColumnElement) {
       auto ThisWidth = calculateCellWidth(Next->Index, Next->EndIndex, true);
       if (Changes[Next->Index].NewlinesBefore == 0)
@@ -297,7 +297,7 @@
     auto MaxNetWidth = getNetWidth(CellStart, CellStop, InitialSpaces);
     auto RowCount = 1U;
     auto Offset = std::distance(CellStart, CellStop);
-    for (const auto *Next = CellStop->NextColumnElement; Next != nullptr;
+    for (auto const *Next = CellStop->NextColumnElement; Next != nullptr;
          Next = Next->NextColumnElement) {
       auto Start = (CellStart + RowCount * CellCount);
       auto End = Start + Offset;
@@ -330,9 +330,9 @@
                            unsigned Indentation);
 
   SmallVector<Change, 16> Changes;
-  const SourceManager &SourceMgr;
+  SourceManager const &SourceMgr;
   tooling::Replacements Replaces;
-  const FormatStyle &Style;
+  FormatStyle const &Style;
   bool UseCRLF;
 };
 
Index: clang/lib/Format/WhitespaceManager.cpp
===================================================================
--- clang/lib/Format/WhitespaceManager.cpp
+++ clang/lib/Format/WhitespaceManager.cpp
@@ -20,13 +20,13 @@
 namespace format {
 
 bool WhitespaceManager::Change::IsBeforeInFile::operator()(
-    const Change &C1, const Change &C2) const {
+    Change const &C1, Change const &C2) const {
   return SourceMgr.isBeforeInTranslationUnit(
       C1.OriginalWhitespaceRange.getBegin(),
       C2.OriginalWhitespaceRange.getBegin());
 }
 
-WhitespaceManager::Change::Change(const FormatToken &Tok,
+WhitespaceManager::Change::Change(FormatToken const &Tok,
                                   bool CreateReplacement,
                                   SourceRange OriginalWhitespaceRange,
                                   int Spaces, unsigned StartOfTokenColumn,
@@ -58,7 +58,7 @@
                            /*IsInsideToken=*/false));
 }
 
-void WhitespaceManager::addUntouchableToken(const FormatToken &Tok,
+void WhitespaceManager::addUntouchableToken(FormatToken const &Tok,
                                             bool InPPDirective) {
   if (Tok.Finalized)
     return;
@@ -70,12 +70,12 @@
 }
 
 llvm::Error
-WhitespaceManager::addReplacement(const tooling::Replacement &Replacement) {
+WhitespaceManager::addReplacement(tooling::Replacement const &Replacement) {
   return Replaces.add(Replacement);
 }
 
 void WhitespaceManager::replaceWhitespaceInToken(
-    const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars,
+    FormatToken const &Tok, unsigned Offset, unsigned ReplaceChars,
     StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective,
     unsigned Newlines, int Spaces) {
   if (Tok.Finalized)
@@ -89,7 +89,7 @@
              /*IsInsideToken=*/true));
 }
 
-const tooling::Replacements &WhitespaceManager::generateReplacements() {
+tooling::Replacements const &WhitespaceManager::generateReplacements() {
   if (Changes.empty())
     return Replaces;
 
@@ -122,7 +122,7 @@
         SourceMgr.getFileOffset(PreviousOriginalWhitespaceEnd);
     assert(PreviousOriginalWhitespaceEndOffset <=
            OriginalWhitespaceStartOffset);
-    const char *const PreviousOriginalWhitespaceEndData =
+    char const *const PreviousOriginalWhitespaceEndData =
         SourceMgr.getCharacterData(PreviousOriginalWhitespaceEnd);
     StringRef Text(PreviousOriginalWhitespaceEndData,
                    SourceMgr.getCharacterData(OriginalWhitespaceStart) -
@@ -211,7 +211,7 @@
   Changes.back().TokenLength = 0;
   Changes.back().IsTrailingComment = Changes.back().Tok->is(tok::comment);
 
-  const WhitespaceManager::Change *LastBlockComment = nullptr;
+  WhitespaceManager::Change const *LastBlockComment = nullptr;
   for (auto &Change : Changes) {
     // Reset the IsTrailingComment flag for changes inside of trailing comments
     // so they don't get realigned later. Comment line breaks however still need
@@ -265,7 +265,7 @@
 // Align a single sequence of tokens, see AlignTokens below.
 template <typename F>
 static void
-AlignTokenSequence(const FormatStyle &Style, unsigned Start, unsigned End,
+AlignTokenSequence(FormatStyle const &Style, unsigned Start, unsigned End,
                    unsigned Column, F &&Matches,
                    SmallVector<WhitespaceManager::Change, 16> &Changes) {
   bool FoundMatchOnLine = false;
@@ -421,9 +421,9 @@
 // that mentions "split function parameter alignment" for an example of this.
 template <typename F>
 static unsigned AlignTokens(
-    const FormatStyle &Style, F &&Matches,
+    FormatStyle const &Style, F &&Matches,
     SmallVector<WhitespaceManager::Change, 16> &Changes, unsigned StartAt,
-    const FormatStyle::AlignConsecutiveStyle &ACS = FormatStyle::ACS_None) {
+    FormatStyle::AlignConsecutiveStyle const &ACS = FormatStyle::ACS_None) {
   unsigned MinColumn = 0;
   unsigned MaxColumn = UINT_MAX;
 
@@ -567,7 +567,7 @@
 static void AlignMacroSequence(
     unsigned &StartOfSequence, unsigned &EndOfSequence, unsigned &MinColumn,
     unsigned &MaxColumn, bool &FoundMatchOnLine,
-    std::function<bool(const WhitespaceManager::Change &C)> AlignMacrosMatches,
+    std::function<bool(WhitespaceManager::Change const &C)> AlignMacrosMatches,
     SmallVector<WhitespaceManager::Change, 16> &Changes) {
   if (StartOfSequence > 0 && StartOfSequence < EndOfSequence) {
 
@@ -606,7 +606,7 @@
   if (Style.AlignConsecutiveMacros == FormatStyle::ACS_None)
     return;
 
-  auto AlignMacrosMatches = [](const Change &C) {
+  auto AlignMacrosMatches = [](Change const &C) {
     const FormatToken *Current = C.Tok;
     unsigned SpacesRequiredBefore = 1;
 
@@ -711,7 +711,7 @@
 
   AlignTokens(
       Style,
-      [&](const Change &C) {
+      [&](Change const &C) {
         // Do not align on equal signs that are first on a line.
         if (C.NewlinesBefore > 0)
           return false;
@@ -1009,7 +1009,7 @@
       // the spaces in front of the brace are enough.
       Changes[CellIter->Index].NewlinesBefore = 0;
       Changes[CellIter->Index].Spaces = 0;
-      for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+      for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
            Next = Next->NextColumnElement) {
         Changes[Next->Index].Spaces = 0;
         Changes[Next->Index].NewlinesBefore = 0;
@@ -1026,7 +1026,7 @@
           Changes[CellIter->Index].Spaces = (MaxNetWidth - ThisNetWidth);
         auto RowCount = 1U;
         auto Offset = std::distance(Cells.begin(), CellIter);
-        for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+        for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
              Next = Next->NextColumnElement) {
           auto *Start = (Cells.begin() + RowCount * CellDescs.CellCount);
           auto *End = Start + Offset;
@@ -1045,7 +1045,7 @@
         Changes[CellIter->Index].Spaces += (i > 0) ? 1 : 0;
       }
       alignToStartOfCell(CellIter->Index, CellIter->EndIndex);
-      for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+      for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
            Next = Next->NextColumnElement) {
         ThisWidth =
             calculateCellWidth(Next->Index, Next->EndIndex, true) + NetWidth;
@@ -1083,7 +1083,7 @@
     }
     auto RowCount = 1U;
     auto Offset = std::distance(Cells.begin(), CellIter);
-    for (const auto *Next = CellIter->NextColumnElement; Next != nullptr;
+    for (auto const *Next = CellIter->NextColumnElement; Next != nullptr;
          Next = Next->NextColumnElement) {
       auto *Start = (Cells.begin() + RowCount * CellDescs.CellCount);
       auto *End = Start + Offset;
@@ -1098,10 +1098,10 @@
   }
 }
 
-bool WhitespaceManager::isSplitCell(const CellDescription &Cell) {
+bool WhitespaceManager::isSplitCell(CellDescription const &Cell) {
   if (Cell.HasSplit)
     return true;
-  for (const auto *Next = Cell.NextColumnElement; Next != nullptr;
+  for (auto const *Next = Cell.NextColumnElement; Next != nullptr;
        Next = Next->NextColumnElement) {
     if (Next->HasSplit)
       return true;
@@ -1119,7 +1119,7 @@
   unsigned InitialTokenLength = 0;
   unsigned EndSpaces = 0;
   SmallVector<CellDescription> Cells;
-  const FormatToken *MatchingParen = nullptr;
+  FormatToken const *MatchingParen = nullptr;
   for (unsigned i = Start; i < End; ++i) {
     auto &C = Changes[i];
     if (C.Tok->is(tok::l_brace))
@@ -1155,7 +1155,7 @@
         Cells.push_back(CellDescription{i, ++Cell, i + 1, false, nullptr});
         CellCount = Cell + 1;
         // Go to the next non-comment and ensure there is a break in front
-        const auto *NextNonComment = C.Tok->getNextNonComment();
+        auto const *NextNonComment = C.Tok->getNextNonComment();
         while (NextNonComment->is(tok::comma))
           NextNonComment = NextNonComment->getNextNonComment();
         auto j = i;
@@ -1257,7 +1257,7 @@
 
 void WhitespaceManager::generateChanges() {
   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
-    const Change &C = Changes[i];
+    Change const &C = Changes[i];
     if (i > 0) {
       assert(Changes[i - 1].OriginalWhitespaceRange.getBegin() !=
                  C.OriginalWhitespaceRange.getBegin() &&
Index: clang/tools/clang-format/ClangFormat.cpp
===================================================================
--- clang/tools/clang-format/ClangFormat.cpp
+++ clang/tools/clang-format/ClangFormat.cpp
@@ -19,6 +19,7 @@
 #include "clang/Basic/Version.h"
 #include "clang/Format/Format.h"
 #include "clang/Rewrite/Core/Rewriter.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
@@ -104,6 +105,13 @@
              "SortIncludes style flag"),
     cl::cat(ClangFormatCategory));
 
+static cl::opt<std::string> QualifierAlignment(
+    "qualifier-aligment",
+    cl::desc(
+        "If set, overrides the cvqualifier style behavior determined by the "
+        "QualifierAlignment style flag"),
+    cl::init(""), cl::cat(ClangFormatCategory));
+
 static cl::opt<bool>
     Verbose("verbose", cl::desc("If set, shows the list of processed files"),
             cl::cat(ClangFormatCategory));
@@ -402,6 +410,14 @@
     return true;
   }
 
+  StringRef ConstAlignment = QualifierAlignment;
+
+  FormatStyle->QualifierAlignment =
+      StringSwitch<FormatStyle::QualifierAlignmentStyle>(ConstAlignment.lower())
+          .Case("right", FormatStyle::QAS_Right)
+          .Case("left", FormatStyle::QAS_Left)
+          .Default(FormatStyle->QualifierAlignment);
+
   if (SortIncludes.getNumOccurrences() != 0) {
     if (SortIncludes)
       FormatStyle->SortIncludes = FormatStyle::SI_CaseSensitive;
Index: clang/unittests/Format/CMakeLists.txt
===================================================================
--- clang/unittests/Format/CMakeLists.txt
+++ clang/unittests/Format/CMakeLists.txt
@@ -18,6 +18,7 @@
   FormatTestTextProto.cpp
   MacroExpanderTest.cpp
   NamespaceEndCommentsFixerTest.cpp
+  QualifierFixerTest.cpp
   SortImportsTestJS.cpp
   SortImportsTestJava.cpp
   SortIncludesTest.cpp
Index: clang/unittests/Format/FormatTest.cpp
===================================================================
--- clang/unittests/Format/FormatTest.cpp
+++ clang/unittests/Format/FormatTest.cpp
@@ -18230,6 +18230,10 @@
   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
 
+#define FAIL_PARSE(TEXT, FIELD, VALUE)                                         \
+  EXPECT_NE(0, parseConfiguration(TEXT, &Style).value());                      \
+  EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
+
 TEST_F(FormatTest, ParsesConfigurationBools) {
   FormatStyle Style = {};
   Style.Language = FormatStyle::LK_Cpp;
@@ -18325,6 +18329,26 @@
   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
 
+  Style.QualifierAlignment = FormatStyle::QAS_Right;
+  CHECK_PARSE("QualifierAlignment: Leave", QualifierAlignment,
+              FormatStyle::QAS_Leave);
+  CHECK_PARSE("QualifierAlignment: Right", QualifierAlignment,
+              FormatStyle::QAS_Right);
+  CHECK_PARSE("QualifierAlignment: Left", QualifierAlignment,
+              FormatStyle::QAS_Left);
+  CHECK_PARSE("QualifierAlignment: Custom", QualifierAlignment,
+              FormatStyle::QAS_Custom);
+
+  Style.QualifierOrder.clear();
+  CHECK_PARSE("QualifierOrder: [ const, volatile, type ]", QualifierOrder,
+              std::vector<std::string>({"const", "volatile", "type"}));
+  Style.QualifierOrder.clear();
+  CHECK_PARSE("QualifierOrder: [const, type]", QualifierOrder,
+              std::vector<std::string>({"const", "type"}));
+  Style.QualifierOrder.clear();
+  CHECK_PARSE("QualifierOrder: [volatile, type]", QualifierOrder,
+              std::vector<std::string>({"volatile", "type"}));
+
   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
   CHECK_PARSE("AlignConsecutiveAssignments: None", AlignConsecutiveAssignments,
               FormatStyle::ACS_None);
@@ -18992,8 +19016,6 @@
   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
 }
 
-#undef CHECK_PARSE
-
 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
   FormatStyle Style = {};
   Style.Language = FormatStyle::LK_JavaScript;
@@ -22294,6 +22316,7 @@
       "}";
   EXPECT_EQ(Code, format(Code, Style));
 }
+
 } // namespace
 } // namespace format
 } // namespace clang