[AST] Fix some Clang-tidy modernize-use-auto warnings; other minor fixes (NFC).

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@329630 91177308-0d34-0410-b5e6-96231b3b80d8

4 files changed, 233 insertions, 274 deletions

diff --git a/include/clang/AST/ASTStructuralEquivalence.h b/include/clang/AST/ASTStructuralEquivalence.h
index 23674c65f3..d21be992c4 100644
--- a/include/clang/AST/ASTStructuralEquivalence.h
+++ b/include/clang/AST/ASTStructuralEquivalence.h
@@ -1,4 +1,4 @@
-//===--- ASTStructuralEquivalence.h - ---------------------------*- C++ -*-===//
+//===- ASTStructuralEquivalence.h -------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -19,6 +19,7 @@
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include <deque>
+#include <utility>
 
 namespace clang {
 
@@ -57,7 +58,7 @@ struct StructuralEquivalenceContext {
   bool Complain;
 
   /// \c true if the last diagnostic came from ToCtx.
-  bool LastDiagFromC2;
+  bool LastDiagFromC2 = false;
 
   StructuralEquivalenceContext(
       ASTContext &FromCtx, ASTContext &ToCtx,
@@ -66,8 +67,7 @@ struct StructuralEquivalenceContext {
       bool ErrorOnTagTypeMismatch = false)
       : FromCtx(FromCtx), ToCtx(ToCtx), NonEquivalentDecls(NonEquivalentDecls),
         StrictTypeSpelling(StrictTypeSpelling),
-        ErrorOnTagTypeMismatch(ErrorOnTagTypeMismatch), Complain(Complain),
-        LastDiagFromC2(false) {}
+        ErrorOnTagTypeMismatch(ErrorOnTagTypeMismatch), Complain(Complain) {}
 
   DiagnosticBuilder Diag1(SourceLocation Loc, unsigned DiagID);
   DiagnosticBuilder Diag2(SourceLocation Loc, unsigned DiagID);
@@ -98,6 +98,7 @@ private:
   /// \returns true if an error occurred, false otherwise.
   bool Finish();
 };
+
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_ASTSTRUCTURALEQUIVALENCE_H
diff --git a/lib/AST/ASTStructuralEquivalence.cpp b/lib/AST/ASTStructuralEquivalence.cpp
index d74042c883..618d27e9b6 100644
--- a/lib/AST/ASTStructuralEquivalence.cpp
+++ b/lib/AST/ASTStructuralEquivalence.cpp
@@ -1,4 +1,4 @@
-//===--- ASTStructuralEquivalence.cpp - -------------------------*- C++ -*-===//
+//===- ASTStructuralEquivalence.cpp ---------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -15,15 +15,28 @@
 #include "clang/AST/ASTStructuralEquivalence.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
-#include "clang/AST/ASTImporter.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
-#include "clang/AST/DeclVisitor.h"
-#include "clang/AST/StmtVisitor.h"
-#include "clang/AST/TypeVisitor.h"
-#include "clang/Basic/SourceManager.h"
-
-namespace {
+#include "clang/AST/DeclTemplate.h"
+#include "clang/AST/NestedNameSpecifier.h"
+#include "clang/AST/TemplateBase.h"
+#include "clang/AST/TemplateName.h"
+#include "clang/AST/Type.h"
+#include "clang/Basic/ExceptionSpecificationType.h"
+#include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <cassert>
+#include <utility>
 
 using namespace clang;
 
@@ -144,6 +157,7 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
            IsStructurallyEquivalent(Context, TS1->getReplacement(),
                                     TS2->getReplacement());
   }
+
   case TemplateName::SubstTemplateTemplateParmPack: {
     SubstTemplateTemplateParmPackStorage
         *P1 = N1.getAsSubstTemplateTemplateParmPack(),
@@ -298,8 +312,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 
   case Type::LValueReference:
   case Type::RValueReference: {
-    const ReferenceType *Ref1 = cast<ReferenceType>(T1);
-    const ReferenceType *Ref2 = cast<ReferenceType>(T2);
+    const auto *Ref1 = cast<ReferenceType>(T1);
+    const auto *Ref2 = cast<ReferenceType>(T2);
     if (Ref1->isSpelledAsLValue() != Ref2->isSpelledAsLValue())
       return false;
     if (Ref1->isInnerRef() != Ref2->isInnerRef())
@@ -311,8 +325,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::MemberPointer: {
-    const MemberPointerType *MemPtr1 = cast<MemberPointerType>(T1);
-    const MemberPointerType *MemPtr2 = cast<MemberPointerType>(T2);
+    const auto *MemPtr1 = cast<MemberPointerType>(T1);
+    const auto *MemPtr2 = cast<MemberPointerType>(T2);
     if (!IsStructurallyEquivalent(Context, MemPtr1->getPointeeType(),
                                   MemPtr2->getPointeeType()))
       return false;
@@ -323,8 +337,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::ConstantArray: {
-    const ConstantArrayType *Array1 = cast<ConstantArrayType>(T1);
-    const ConstantArrayType *Array2 = cast<ConstantArrayType>(T2);
+    const auto *Array1 = cast<ConstantArrayType>(T1);
+    const auto *Array2 = cast<ConstantArrayType>(T2);
     if (!llvm::APInt::isSameValue(Array1->getSize(), Array2->getSize()))
       return false;
 
@@ -340,8 +354,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
     break;
 
   case Type::VariableArray: {
-    const VariableArrayType *Array1 = cast<VariableArrayType>(T1);
-    const VariableArrayType *Array2 = cast<VariableArrayType>(T2);
+    const auto *Array1 = cast<VariableArrayType>(T1);
+    const auto *Array2 = cast<VariableArrayType>(T2);
     if (!IsStructurallyEquivalent(Context, Array1->getSizeExpr(),
                                   Array2->getSizeExpr()))
       return false;
@@ -353,8 +367,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::DependentSizedArray: {
-    const DependentSizedArrayType *Array1 = cast<DependentSizedArrayType>(T1);
-    const DependentSizedArrayType *Array2 = cast<DependentSizedArrayType>(T2);
+    const auto *Array1 = cast<DependentSizedArrayType>(T1);
+    const auto *Array2 = cast<DependentSizedArrayType>(T2);
     if (!IsStructurallyEquivalent(Context, Array1->getSizeExpr(),
                                   Array2->getSizeExpr()))
       return false;
@@ -366,10 +380,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::DependentAddressSpace: {
-    const DependentAddressSpaceType *DepAddressSpace1 =
-        cast<DependentAddressSpaceType>(T1);
-    const DependentAddressSpaceType *DepAddressSpace2 =
-        cast<DependentAddressSpaceType>(T2);
+    const auto *DepAddressSpace1 = cast<DependentAddressSpaceType>(T1);
+    const auto *DepAddressSpace2 = cast<DependentAddressSpaceType>(T2);
     if (!IsStructurallyEquivalent(Context, DepAddressSpace1->getAddrSpaceExpr(),
                                   DepAddressSpace2->getAddrSpaceExpr()))
       return false;
@@ -381,10 +393,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::DependentSizedExtVector: {
-    const DependentSizedExtVectorType *Vec1 =
-        cast<DependentSizedExtVectorType>(T1);
-    const DependentSizedExtVectorType *Vec2 =
-        cast<DependentSizedExtVectorType>(T2);
+    const auto *Vec1 = cast<DependentSizedExtVectorType>(T1);
+    const auto *Vec2 = cast<DependentSizedExtVectorType>(T2);
     if (!IsStructurallyEquivalent(Context, Vec1->getSizeExpr(),
                                   Vec2->getSizeExpr()))
       return false;
@@ -396,8 +406,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 
   case Type::Vector:
   case Type::ExtVector: {
-    const VectorType *Vec1 = cast<VectorType>(T1);
-    const VectorType *Vec2 = cast<VectorType>(T2);
+    const auto *Vec1 = cast<VectorType>(T1);
+    const auto *Vec2 = cast<VectorType>(T2);
     if (!IsStructurallyEquivalent(Context, Vec1->getElementType(),
                                   Vec2->getElementType()))
       return false;
@@ -409,8 +419,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::FunctionProto: {
-    const FunctionProtoType *Proto1 = cast<FunctionProtoType>(T1);
-    const FunctionProtoType *Proto2 = cast<FunctionProtoType>(T2);
+    const auto *Proto1 = cast<FunctionProtoType>(T1);
+    const auto *Proto2 = cast<FunctionProtoType>(T2);
     if (Proto1->getNumParams() != Proto2->getNumParams())
       return false;
     for (unsigned I = 0, N = Proto1->getNumParams(); I != N; ++I) {
@@ -443,8 +453,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::FunctionNoProto: {
-    const FunctionType *Function1 = cast<FunctionType>(T1);
-    const FunctionType *Function2 = cast<FunctionType>(T2);
+    const auto *Function1 = cast<FunctionType>(T1);
+    const auto *Function2 = cast<FunctionType>(T2);
     if (!IsStructurallyEquivalent(Context, Function1->getReturnType(),
                                   Function2->getReturnType()))
       return false;
@@ -458,7 +468,6 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                   cast<UnresolvedUsingType>(T1)->getDecl(),
                                   cast<UnresolvedUsingType>(T2)->getDecl()))
       return false;
-
     break;
 
   case Type::Attributed:
@@ -519,8 +528,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
     break;
 
   case Type::DeducedTemplateSpecialization: {
-    auto *DT1 = cast<DeducedTemplateSpecializationType>(T1);
-    auto *DT2 = cast<DeducedTemplateSpecializationType>(T2);
+    const auto *DT1 = cast<DeducedTemplateSpecializationType>(T1);
+    const auto *DT2 = cast<DeducedTemplateSpecializationType>(T2);
     if (!IsStructurallyEquivalent(Context, DT1->getTemplateName(),
                                   DT2->getTemplateName()))
       return false;
@@ -538,8 +547,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
     break;
 
   case Type::TemplateTypeParm: {
-    const TemplateTypeParmType *Parm1 = cast<TemplateTypeParmType>(T1);
-    const TemplateTypeParmType *Parm2 = cast<TemplateTypeParmType>(T2);
+    const auto *Parm1 = cast<TemplateTypeParmType>(T1);
+    const auto *Parm2 = cast<TemplateTypeParmType>(T2);
     if (Parm1->getDepth() != Parm2->getDepth())
       return false;
     if (Parm1->getIndex() != Parm2->getIndex())
@@ -552,10 +561,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::SubstTemplateTypeParm: {
-    const SubstTemplateTypeParmType *Subst1 =
-        cast<SubstTemplateTypeParmType>(T1);
-    const SubstTemplateTypeParmType *Subst2 =
-        cast<SubstTemplateTypeParmType>(T2);
+    const auto *Subst1 = cast<SubstTemplateTypeParmType>(T1);
+    const auto *Subst2 = cast<SubstTemplateTypeParmType>(T2);
     if (!IsStructurallyEquivalent(Context,
                                   QualType(Subst1->getReplacedParameter(), 0),
                                   QualType(Subst2->getReplacedParameter(), 0)))
@@ -567,10 +574,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::SubstTemplateTypeParmPack: {
-    const SubstTemplateTypeParmPackType *Subst1 =
-        cast<SubstTemplateTypeParmPackType>(T1);
-    const SubstTemplateTypeParmPackType *Subst2 =
-        cast<SubstTemplateTypeParmPackType>(T2);
+    const auto *Subst1 = cast<SubstTemplateTypeParmPackType>(T1);
+    const auto *Subst2 = cast<SubstTemplateTypeParmPackType>(T2);
     if (!IsStructurallyEquivalent(Context,
                                   QualType(Subst1->getReplacedParameter(), 0),
                                   QualType(Subst2->getReplacedParameter(), 0)))
@@ -580,11 +585,10 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
       return false;
     break;
   }
+
   case Type::TemplateSpecialization: {
-    const TemplateSpecializationType *Spec1 =
-        cast<TemplateSpecializationType>(T1);
-    const TemplateSpecializationType *Spec2 =
-        cast<TemplateSpecializationType>(T2);
+    const auto *Spec1 = cast<TemplateSpecializationType>(T1);
+    const auto *Spec2 = cast<TemplateSpecializationType>(T2);
     if (!IsStructurallyEquivalent(Context, Spec1->getTemplateName(),
                                   Spec2->getTemplateName()))
       return false;
@@ -599,8 +603,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::Elaborated: {
-    const ElaboratedType *Elab1 = cast<ElaboratedType>(T1);
-    const ElaboratedType *Elab2 = cast<ElaboratedType>(T2);
+    const auto *Elab1 = cast<ElaboratedType>(T1);
+    const auto *Elab2 = cast<ElaboratedType>(T2);
     // CHECKME: what if a keyword is ETK_None or ETK_typename ?
     if (Elab1->getKeyword() != Elab2->getKeyword())
       return false;
@@ -614,8 +618,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::InjectedClassName: {
-    const InjectedClassNameType *Inj1 = cast<InjectedClassNameType>(T1);
-    const InjectedClassNameType *Inj2 = cast<InjectedClassNameType>(T2);
+    const auto *Inj1 = cast<InjectedClassNameType>(T1);
+    const auto *Inj2 = cast<InjectedClassNameType>(T2);
     if (!IsStructurallyEquivalent(Context,
                                   Inj1->getInjectedSpecializationType(),
                                   Inj2->getInjectedSpecializationType()))
@@ -624,8 +628,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::DependentName: {
-    const DependentNameType *Typename1 = cast<DependentNameType>(T1);
-    const DependentNameType *Typename2 = cast<DependentNameType>(T2);
+    const auto *Typename1 = cast<DependentNameType>(T1);
+    const auto *Typename2 = cast<DependentNameType>(T2);
     if (!IsStructurallyEquivalent(Context, Typename1->getQualifier(),
                                   Typename2->getQualifier()))
       return false;
@@ -637,10 +641,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::DependentTemplateSpecialization: {
-    const DependentTemplateSpecializationType *Spec1 =
-        cast<DependentTemplateSpecializationType>(T1);
-    const DependentTemplateSpecializationType *Spec2 =
-        cast<DependentTemplateSpecializationType>(T2);
+    const auto *Spec1 = cast<DependentTemplateSpecializationType>(T1);
+    const auto *Spec2 = cast<DependentTemplateSpecializationType>(T2);
     if (!IsStructurallyEquivalent(Context, Spec1->getQualifier(),
                                   Spec2->getQualifier()))
       return false;
@@ -665,8 +667,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
     break;
 
   case Type::ObjCInterface: {
-    const ObjCInterfaceType *Iface1 = cast<ObjCInterfaceType>(T1);
-    const ObjCInterfaceType *Iface2 = cast<ObjCInterfaceType>(T2);
+    const auto *Iface1 = cast<ObjCInterfaceType>(T1);
+    const auto *Iface2 = cast<ObjCInterfaceType>(T2);
     if (!IsStructurallyEquivalent(Context, Iface1->getDecl(),
                                   Iface2->getDecl()))
       return false;
@@ -674,8 +676,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::ObjCTypeParam: {
-    const ObjCTypeParamType *Obj1 = cast<ObjCTypeParamType>(T1);
-    const ObjCTypeParamType *Obj2 = cast<ObjCTypeParamType>(T2);
+    const auto *Obj1 = cast<ObjCTypeParamType>(T1);
+    const auto *Obj2 = cast<ObjCTypeParamType>(T2);
     if (!IsStructurallyEquivalent(Context, Obj1->getDecl(), Obj2->getDecl()))
       return false;
 
@@ -688,9 +690,10 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
     }
     break;
   }
+
   case Type::ObjCObject: {
-    const ObjCObjectType *Obj1 = cast<ObjCObjectType>(T1);
-    const ObjCObjectType *Obj2 = cast<ObjCObjectType>(T2);
+    const auto *Obj1 = cast<ObjCObjectType>(T1);
+    const auto *Obj2 = cast<ObjCObjectType>(T2);
     if (!IsStructurallyEquivalent(Context, Obj1->getBaseType(),
                                   Obj2->getBaseType()))
       return false;
@@ -705,28 +708,25 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   }
 
   case Type::ObjCObjectPointer: {
-    const ObjCObjectPointerType *Ptr1 = cast<ObjCObjectPointerType>(T1);
-    const ObjCObjectPointerType *Ptr2 = cast<ObjCObjectPointerType>(T2);
+    const auto *Ptr1 = cast<ObjCObjectPointerType>(T1);
+    const auto *Ptr2 = cast<ObjCObjectPointerType>(T2);
     if (!IsStructurallyEquivalent(Context, Ptr1->getPointeeType(),
                                   Ptr2->getPointeeType()))
       return false;
     break;
   }
 
-  case Type::Atomic: {
+  case Type::Atomic:
     if (!IsStructurallyEquivalent(Context, cast<AtomicType>(T1)->getValueType(),
                                   cast<AtomicType>(T2)->getValueType()))
       return false;
     break;
-  }
 
-  case Type::Pipe: {
+  case Type::Pipe:
     if (!IsStructurallyEquivalent(Context, cast<PipeType>(T1)->getElementType(),
                                   cast<PipeType>(T2)->getElementType()))
       return false;
     break;
-  }
-
   } // end switch
 
   return true;
@@ -735,7 +735,7 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 /// Determine structural equivalence of two fields.
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      FieldDecl *Field1, FieldDecl *Field2) {
-  RecordDecl *Owner2 = cast<RecordDecl>(Field2->getDeclContext());
+  const auto *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
@@ -861,10 +861,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 
   // If both declarations are class template specializations, we know
   // the ODR applies, so check the template and template arguments.
-  ClassTemplateSpecializationDecl *Spec1 =
-      dyn_cast<ClassTemplateSpecializationDecl>(D1);
-  ClassTemplateSpecializationDecl *Spec2 =
-      dyn_cast<ClassTemplateSpecializationDecl>(D2);
+  const auto *Spec1 = dyn_cast<ClassTemplateSpecializationDecl>(D1);
+  const auto *Spec2 = dyn_cast<ClassTemplateSpecializationDecl>(D2);
   if (Spec1 && Spec2) {
     // Check that the specialized templates are the same.
     if (!IsStructurallyEquivalent(Context, Spec1->getSpecializedTemplate(),
@@ -892,8 +890,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   if (!D1 || !D2)
     return true;
 
-  if (CXXRecordDecl *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
-    if (CXXRecordDecl *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
+  if (auto *D1CXX = dyn_cast<CXXRecordDecl>(D1)) {
+    if (auto *D2CXX = dyn_cast<CXXRecordDecl>(D2)) {
       if (D1CXX->hasExternalLexicalStorage() &&
           !D1CXX->isCompleteDefinition()) {
         D1CXX->getASTContext().getExternalSource()->CompleteType(D1CXX);
@@ -1082,10 +1080,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
     }
 
     if (!Context.IsStructurallyEquivalent(Params1->getParam(I),
-                                          Params2->getParam(I))) {
-
+                                          Params2->getParam(I)))
       return false;
-    }
   }
 
   return true;
@@ -1209,9 +1205,6 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
   Context.DeclsToCheck.push_back(D1->getCanonicalDecl());
   return true;
 }
-} // namespace
-
-namespace clang {
 
 DiagnosticBuilder StructuralEquivalenceContext::Diag1(SourceLocation Loc,
                                                       unsigned DiagID) {
@@ -1236,7 +1229,7 @@ StructuralEquivalenceContext::findUntaggedStructOrUnionIndex(RecordDecl *Anon) {
   ASTContext &Context = Anon->getASTContext();
   QualType AnonTy = Context.getRecordType(Anon);
 
-  RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
+  const auto *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext());
   if (!Owner)
     return None;
 
@@ -1303,8 +1296,8 @@ bool StructuralEquivalenceContext::Finish() {
 
     // FIXME: Switch on all declaration kinds. For now, we're just going to
     // check the obvious ones.
-    if (RecordDecl *Record1 = dyn_cast<RecordDecl>(D1)) {
-      if (RecordDecl *Record2 = dyn_cast<RecordDecl>(D2)) {
+    if (auto *Record1 = dyn_cast<RecordDecl>(D1)) {
+      if (auto *Record2 = dyn_cast<RecordDecl>(D2)) {
         // Check for equivalent structure names.
         IdentifierInfo *Name1 = Record1->getIdentifier();
         if (!Name1 && Record1->getTypedefNameForAnonDecl())
@@ -1319,9 +1312,8 @@ bool StructuralEquivalenceContext::Finish() {
         // Record/non-record mismatch.
         Equivalent = false;
       }
-
-    } else if (EnumDecl *Enum1 = dyn_cast<EnumDecl>(D1)) {
-      if (EnumDecl *Enum2 = dyn_cast<EnumDecl>(D2)) {
+    } else if (auto *Enum1 = dyn_cast<EnumDecl>(D1)) {
+      if (auto *Enum2 = dyn_cast<EnumDecl>(D2)) {
         // Check for equivalent enum names.
         IdentifierInfo *Name1 = Enum1->getIdentifier();
         if (!Name1 && Enum1->getTypedefNameForAnonDecl())
@@ -1336,9 +1328,8 @@ bool StructuralEquivalenceContext::Finish() {
         // Enum/non-enum mismatch
         Equivalent = false;
       }
-
-    } else if (TypedefNameDecl *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
-      if (TypedefNameDecl *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
+    } else if (const auto *Typedef1 = dyn_cast<TypedefNameDecl>(D1)) {
+      if (const auto *Typedef2 = dyn_cast<TypedefNameDecl>(D2)) {
         if (!::IsStructurallyEquivalent(Typedef1->getIdentifier(),
                                         Typedef2->getIdentifier()) ||
             !::IsStructurallyEquivalent(*this, Typedef1->getUnderlyingType(),
@@ -1348,10 +1339,8 @@ bool StructuralEquivalenceContext::Finish() {
         // Typedef/non-typedef mismatch.
         Equivalent = false;
       }
-
-    } else if (ClassTemplateDecl *ClassTemplate1 =
-                   dyn_cast<ClassTemplateDecl>(D1)) {
-      if (ClassTemplateDecl *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
+    } else if (auto *ClassTemplate1 = dyn_cast<ClassTemplateDecl>(D1)) {
+      if (auto *ClassTemplate2 = dyn_cast<ClassTemplateDecl>(D2)) {
         if (!::IsStructurallyEquivalent(*this, ClassTemplate1,
                                         ClassTemplate2))
           Equivalent = false;
@@ -1359,11 +1348,8 @@ bool StructuralEquivalenceContext::Finish() {
         // Class template/non-class-template mismatch.
         Equivalent = false;
       }
-
-    } else if (FunctionTemplateDecl *FunctionTemplate1 =
-               dyn_cast<FunctionTemplateDecl>(D1)) {
-      if (FunctionTemplateDecl *FunctionTemplate2 =
-          dyn_cast<FunctionTemplateDecl>(D2)) {
+    } else if (auto *FunctionTemplate1 = dyn_cast<FunctionTemplateDecl>(D1)) {
+      if (auto *FunctionTemplate2 = dyn_cast<FunctionTemplateDecl>(D2)) {
         if (!::IsStructurallyEquivalent(*this, FunctionTemplate1,
                                         FunctionTemplate2))
           Equivalent = false;
@@ -1371,31 +1357,24 @@ bool StructuralEquivalenceContext::Finish() {
         // Class template/non-class-template mismatch.
         Equivalent = false;
       }
-
-    } else if (TemplateTypeParmDecl *TTP1 =
-                   dyn_cast<TemplateTypeParmDecl>(D1)) {
-      if (TemplateTypeParmDecl *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
+    } else if (auto *TTP1 = dyn_cast<TemplateTypeParmDecl>(D1)) {
+      if (auto *TTP2 = dyn_cast<TemplateTypeParmDecl>(D2)) {
         if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
           Equivalent = false;
       } else {
         // Kind mismatch.
         Equivalent = false;
       }
-    } else if (NonTypeTemplateParmDecl *NTTP1 =
-                   dyn_cast<NonTypeTemplateParmDecl>(D1)) {
-      if (NonTypeTemplateParmDecl *NTTP2 =
-              dyn_cast<NonTypeTemplateParmDecl>(D2)) {
+    } else if (auto *NTTP1 = dyn_cast<NonTypeTemplateParmDecl>(D1)) {
+      if (auto *NTTP2 = dyn_cast<NonTypeTemplateParmDecl>(D2)) {
         if (!::IsStructurallyEquivalent(*this, NTTP1, NTTP2))
           Equivalent = false;
       } else {
         // Kind mismatch.
         Equivalent = false;
       }
-
-    } else if (TemplateTemplateParmDecl *TTP1 =
-                   dyn_cast<TemplateTemplateParmDecl>(D1)) {
-      if (TemplateTemplateParmDecl *TTP2 =
-              dyn_cast<TemplateTemplateParmDecl>(D2)) {
+    } else if (auto *TTP1 = dyn_cast<TemplateTemplateParmDecl>(D1)) {
+      if (auto *TTP2 = dyn_cast<TemplateTemplateParmDecl>(D2)) {
         if (!::IsStructurallyEquivalent(*this, TTP1, TTP2))
           Equivalent = false;
       } else {
@@ -1416,4 +1395,3 @@ bool StructuralEquivalenceContext::Finish() {
 
   return false;
 }
-} // namespace clang
diff --git a/lib/AST/DeclBase.cpp b/lib/AST/DeclBase.cpp
index 04fd62f738..baf83a393c 100644
--- a/lib/AST/DeclBase.cpp
+++ b/lib/AST/DeclBase.cpp
@@ -101,7 +101,7 @@ void *Decl::operator new(std::size_t Size, const ASTContext &Ctx,
     // padding at the start if required.
     size_t ExtraAlign =
         llvm::OffsetToAlignment(sizeof(Module *), alignof(Decl));
-    char *Buffer = reinterpret_cast<char *>(
+    auto *Buffer = reinterpret_cast<char *>(
         ::operator new(ExtraAlign + sizeof(Module *) + Size + Extra, Ctx));
     Buffer += ExtraAlign;
     auto *ParentModule =
@@ -145,8 +145,8 @@ void Decl::setInvalidDecl(bool Invalid) {
 
   // Marking a DecompositionDecl as invalid implies all the child BindingDecl's
   // are invalid too.
-  if (DecompositionDecl *DD = dyn_cast<DecompositionDecl>(this)) {
-    for (BindingDecl *Binding : DD->bindings()) {
+  if (auto *DD = dyn_cast<DecompositionDecl>(this)) {
+    for (auto *Binding : DD->bindings()) {
       Binding->setInvalidDecl();
     }
   }
@@ -199,28 +199,26 @@ void Decl::add(Kind k) {
 }
 
 bool Decl::isTemplateParameterPack() const {
-  if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(this))
+  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(this))
     return TTP->isParameterPack();
-  if (const NonTypeTemplateParmDecl *NTTP
-                                = dyn_cast<NonTypeTemplateParmDecl>(this))
+  if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(this))
     return NTTP->isParameterPack();
-  if (const TemplateTemplateParmDecl *TTP
-                                    = dyn_cast<TemplateTemplateParmDecl>(this))
+  if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(this))
     return TTP->isParameterPack();
   return false;
 }
 
 bool Decl::isParameterPack() const {
-  if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(this))
+  if (const auto *Parm = dyn_cast<ParmVarDecl>(this))
     return Parm->isParameterPack();
   
   return isTemplateParameterPack();
 }
 
 FunctionDecl *Decl::getAsFunction() {
-  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(this))
+  if (auto *FD = dyn_cast<FunctionDecl>(this))
     return FD;
-  if (const FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(this))
+  if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(this))
     return FTD->getTemplatedDecl();
   return nullptr;
 }
@@ -279,7 +277,7 @@ void PrettyStackTraceDecl::print(raw_ostream &OS) const {
 
   OS << Message;
 
-  if (const NamedDecl *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) {
+  if (const auto *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) {
     OS << " '";
     DN->printQualifiedName(OS);
     OS << '\'';
@@ -327,7 +325,7 @@ void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
   if (SemaDC == LexicalDC) {
     DeclCtx = SemaDC;
   } else {
-    Decl::MultipleDC *MDC = new (Ctx) Decl::MultipleDC();
+    auto *MDC = new (Ctx) Decl::MultipleDC();
     MDC->SemanticDC = SemaDC;
     MDC->LexicalDC = LexicalDC;
     DeclCtx = MDC;
@@ -348,7 +346,7 @@ bool Decl::isLexicallyWithinFunctionOrMethod() const {
 
 bool Decl::isInAnonymousNamespace() const {
   for (const DeclContext *DC = getDeclContext(); DC; DC = DC->getParent()) {
-    if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
+    if (const auto *ND = dyn_cast<NamespaceDecl>(DC))
       if (ND->isAnonymousNamespace())
         return true;
   }
@@ -361,7 +359,7 @@ bool Decl::isInStdNamespace() const {
 }
 
 TranslationUnitDecl *Decl::getTranslationUnitDecl() {
-  if (TranslationUnitDecl *TUD = dyn_cast<TranslationUnitDecl>(this))
+  if (auto *TUD = dyn_cast<TranslationUnitDecl>(this))
     return TUD;
 
   DeclContext *DC = getDeclContext();
@@ -426,7 +424,7 @@ bool Decl::isReferenced() const {
     return true;
 
   // Check redeclarations.
-  for (auto I : redecls())
+  for (const auto *I : redecls())
     if (I->Referenced)
       return true;
 
@@ -451,11 +449,11 @@ bool Decl::isExported() const {
 
 ExternalSourceSymbolAttr *Decl::getExternalSourceSymbolAttr() const {
   const Decl *Definition = nullptr;
-  if (auto ID = dyn_cast<ObjCInterfaceDecl>(this)) {
+  if (auto *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
     Definition = ID->getDefinition();
-  } else if (auto PD = dyn_cast<ObjCProtocolDecl>(this)) {
+  } else if (auto *PD = dyn_cast<ObjCProtocolDecl>(this)) {
     Definition = PD->getDefinition();
-  } else if (auto TD = dyn_cast<TagDecl>(this)) {
+  } else if (auto *TD = dyn_cast<TagDecl>(this)) {
     Definition = TD->getDefinition();
   }
   if (!Definition)
@@ -475,9 +473,9 @@ bool Decl::hasDefiningAttr() const {
 }
 
 const Attr *Decl::getDefiningAttr() const {
-  if (AliasAttr *AA = getAttr<AliasAttr>())
+  if (auto *AA = getAttr<AliasAttr>())
     return AA;
-  if (IFuncAttr *IFA = getAttr<IFuncAttr>())
+  if (auto *IFA = getAttr<IFuncAttr>())
     return IFA;
   return nullptr;
 }
@@ -649,14 +647,14 @@ VersionTuple Decl::getVersionIntroduced() const {
         return Availability->getIntroduced();
     }
   }
-  return VersionTuple();
+  return {};
 }
 
 bool Decl::canBeWeakImported(bool &IsDefinition) const {
   IsDefinition = false;
 
   // Variables, if they aren't definitions.
-  if (const VarDecl *Var = dyn_cast<VarDecl>(this)) {
+  if (const auto *Var = dyn_cast<VarDecl>(this)) {
     if (Var->isThisDeclarationADefinition()) {
       IsDefinition = true;
       return false;
@@ -664,7 +662,7 @@ bool Decl::canBeWeakImported(bool &IsDefinition) const {
     return true;
 
   // Functions, if they aren't definitions.
-  } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) {
+  } else if (const auto *FD = dyn_cast<FunctionDecl>(this)) {
     if (FD->hasBody()) {
       IsDefinition = true;
       return false;
@@ -847,14 +845,14 @@ Decl *Decl::castFromDeclContext (const DeclContext *D) {
 #define DECL(NAME, BASE)
 #define DECL_CONTEXT(NAME) \
     case Decl::NAME:       \
-      return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D));
+      return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));
 #define DECL_CONTEXT_BASE(NAME)
 #include "clang/AST/DeclNodes.inc"
     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));
+        return static_cast<NAME##Decl *>(const_cast<DeclContext *>(D));
 #include "clang/AST/DeclNodes.inc"
       llvm_unreachable("a decl that inherits DeclContext isn't handled");
   }
@@ -866,14 +864,14 @@ DeclContext *Decl::castToDeclContext(const Decl *D) {
 #define DECL(NAME, BASE)
 #define DECL_CONTEXT(NAME) \
     case Decl::NAME:       \
-      return static_cast<NAME##Decl*>(const_cast<Decl*>(D));
+      return static_cast<NAME##Decl *>(const_cast<Decl *>(D));
 #define DECL_CONTEXT_BASE(NAME)
 #include "clang/AST/DeclNodes.inc"
     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));
+        return static_cast<NAME##Decl *>(const_cast<Decl *>(D));
 #include "clang/AST/DeclNodes.inc"
       llvm_unreachable("a decl that inherits DeclContext isn't handled");
   }
@@ -882,17 +880,17 @@ DeclContext *Decl::castToDeclContext(const Decl *D) {
 SourceLocation Decl::getBodyRBrace() const {
   // Special handling of FunctionDecl to avoid de-serializing the body from PCH.
   // FunctionDecl stores EndRangeLoc for this purpose.
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) {
+  if (const auto *FD = dyn_cast<FunctionDecl>(this)) {
     const FunctionDecl *Definition;
     if (FD->hasBody(Definition))
       return Definition->getSourceRange().getEnd();
-    return SourceLocation();
+    return {};
   }
 
   if (Stmt *Body = getBody())
     return Body->getSourceRange().getEnd();
 
-  return SourceLocation();
+  return {};
 }
 
 bool Decl::AccessDeclContextSanity() const {
@@ -932,9 +930,9 @@ static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); }
 
 const FunctionType *Decl::getFunctionType(bool BlocksToo) const {
   QualType Ty;
-  if (const ValueDecl *D = dyn_cast<ValueDecl>(this))
+  if (const auto *D = dyn_cast<ValueDecl>(this))
     Ty = D->getType();
-  else if (const TypedefNameDecl *D = dyn_cast<TypedefNameDecl>(this))
+  else if (const auto *D = dyn_cast<TypedefNameDecl>(this))
     Ty = D->getUnderlyingType();
   else
     return nullptr;
@@ -951,22 +949,21 @@ const FunctionType *Decl::getFunctionType(bool BlocksToo) const {
 /// code context that is not a closure (a lambda, block, etc.).
 template <class T> static Decl *getNonClosureContext(T *D) {
   if (getKind(D) == Decl::CXXMethod) {
-    CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
+    auto *MD = cast<CXXMethodDecl>(D);
     if (MD->getOverloadedOperator() == OO_Call &&
         MD->getParent()->isLambda())
       return getNonClosureContext(MD->getParent()->getParent());
     return MD;
-  } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+  } else if (auto *FD = dyn_cast<FunctionDecl>(D))
     return FD;
-  } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
+  else if (auto *MD = dyn_cast<ObjCMethodDecl>(D))
     return MD;
-  } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
+  else if (auto *BD = dyn_cast<BlockDecl>(D))
     return getNonClosureContext(BD->getParent());
-  } else if (CapturedDecl *CD = dyn_cast<CapturedDecl>(D)) {
+  else if (auto *CD = dyn_cast<CapturedDecl>(D))
     return getNonClosureContext(CD->getParent());
-  } else {
+  else
     return nullptr;
-  }
 }
 
 Decl *Decl::getNonClosureContext() {
@@ -1026,7 +1023,7 @@ bool DeclContext::isStdNamespace() const {
   if (!isNamespace())
     return false;
 
-  const NamespaceDecl *ND = cast<NamespaceDecl>(this);
+  const auto *ND = cast<NamespaceDecl>(this);
   if (ND->isInline()) {
     return ND->getParent()->isStdNamespace();
   }
@@ -1045,7 +1042,7 @@ bool DeclContext::isDependentContext() const {
   if (isa<ClassTemplatePartialSpecializationDecl>(this))
     return true;
 
-  if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this)) {
+  if (const auto *Record = dyn_cast<CXXRecordDecl>(this)) {
     if (Record->getDescribedClassTemplate())
       return true;
     
@@ -1053,7 +1050,7 @@ bool DeclContext::isDependentContext() const {
       return true;
   }
   
-  if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this)) {
+  if (const auto *Function = dyn_cast<FunctionDecl>(this)) {
     if (Function->getDescribedFunctionTemplate())
       return true;
 
@@ -1132,18 +1129,18 @@ DeclContext *DeclContext::getPrimaryContext() {
 
   case Decl::Namespace:
     // The original namespace is our primary context.
-    return static_cast<NamespaceDecl*>(this)->getOriginalNamespace();
+    return static_cast<NamespaceDecl *>(this)->getOriginalNamespace();
 
   case Decl::ObjCMethod:
     return this;
 
   case Decl::ObjCInterface:
-    if (ObjCInterfaceDecl *Def = cast<ObjCInterfaceDecl>(this)->getDefinition())
+    if (auto *Def = cast<ObjCInterfaceDecl>(this)->getDefinition())
       return Def;
     return this;
       
   case Decl::ObjCProtocol:
-    if (ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(this)->getDefinition())
+    if (auto *Def = cast<ObjCProtocolDecl>(this)->getDefinition())
       return Def;
     return this;
       
@@ -1158,12 +1155,12 @@ DeclContext *DeclContext::getPrimaryContext() {
     if (DeclKind >= Decl::firstTag && DeclKind <= Decl::lastTag) {
       // If this is a tag type that has a definition or is currently
       // being defined, that definition is our primary context.
-      TagDecl *Tag = cast<TagDecl>(this);
+      auto *Tag = cast<TagDecl>(this);
 
       if (TagDecl *Def = Tag->getDefinition())
         return Def;
 
-      if (const TagType *TagTy = dyn_cast<TagType>(Tag->getTypeForDecl())) {
+      if (const auto *TagTy = dyn_cast<TagType>(Tag->getTypeForDecl())) {
         // Note, TagType::getDecl returns the (partial) definition one exists.
         TagDecl *PossiblePartialDef = TagTy->getDecl();
         if (PossiblePartialDef->isBeingDefined())
@@ -1190,7 +1187,7 @@ DeclContext::collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts){
     return;
   }
   
-  NamespaceDecl *Self = static_cast<NamespaceDecl *>(this);
+  auto *Self = static_cast<NamespaceDecl *>(this);
   for (NamespaceDecl *N = Self->getMostRecentDecl(); N;
        N = N->getPreviousDecl())
     Contexts.push_back(N);
@@ -1199,16 +1196,15 @@ DeclContext::collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts){
 }
 
 std::pair<Decl *, Decl *>
-DeclContext::BuildDeclChain(ArrayRef<Decl*> Decls,
+DeclContext::BuildDeclChain(ArrayRef<Decl *> Decls,
                             bool FieldsAlreadyLoaded) {
   // Build up a chain of declarations via the Decl::NextInContextAndBits field.
   Decl *FirstNewDecl = nullptr;
   Decl *PrevDecl = nullptr;
-  for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
-    if (FieldsAlreadyLoaded && isa<FieldDecl>(Decls[I]))
+  for (auto *D : Decls) {
+    if (FieldsAlreadyLoaded && isa<FieldDecl>(D))
       continue;
 
-    Decl *D = Decls[I];
     if (PrevDecl)
       PrevDecl->NextInContextAndBits.setPointer(D);
     else
@@ -1253,7 +1249,7 @@ DeclContext::LoadLexicalDeclsFromExternalStorage() const {
   // We may have already loaded just the fields of this record, in which case
   // we need to ignore them.
   bool FieldsAlreadyLoaded = false;
-  if (const RecordDecl *RD = dyn_cast<RecordDecl>(this))
+  if (const auto *RD = dyn_cast<RecordDecl>(this))
     FieldsAlreadyLoaded = RD->LoadedFieldsFromExternalStorage;
   
   // Splice the newly-read declarations into the beginning of the list
@@ -1320,12 +1316,11 @@ ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC,
     }
   } else {
     // Convert the array to a StoredDeclsList.
-    for (ArrayRef<NamedDecl*>::iterator
-           I = Decls.begin(), E = Decls.end(); I != E; ++I) {
+    for (auto *D : Decls) {
       if (List.isNull())
-        List.setOnlyValue(*I);
+        List.setOnlyValue(D);
       else
-        List.AddSubsequentDecl(*I);
+        List.AddSubsequentDecl(D);
     }
   }
 
@@ -1378,7 +1373,7 @@ void DeclContext::removeDecl(Decl *D) {
 
   // Remove D from the lookup table if necessary.
   if (isa<NamedDecl>(D)) {
-    NamedDecl *ND = cast<NamedDecl>(D);
+    auto *ND = cast<NamedDecl>(D);
 
     // Remove only decls that have a name
     if (!ND->getDeclName()) return;
@@ -1411,13 +1406,13 @@ void DeclContext::addHiddenDecl(Decl *D) {
 
   // Notify a C++ record declaration that we've added a member, so it can
   // update its class-specific state.
-  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this))
+  if (auto *Record = dyn_cast<CXXRecordDecl>(this))
     Record->addedMember(D);
 
   // If this is a newly-created (not de-serialized) import declaration, wire
   // it in to the list of local import declarations.
   if (!D->isFromASTFile()) {
-    if (ImportDecl *Import = dyn_cast<ImportDecl>(D))
+    if (auto *Import = dyn_cast<ImportDecl>(D))
       D->getASTContext().addedLocalImportDecl(Import);
   }
 }
@@ -1425,7 +1420,7 @@ void DeclContext::addHiddenDecl(Decl *D) {
 void DeclContext::addDecl(Decl *D) {
   addHiddenDecl(D);
 
-  if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
+  if (auto *ND = dyn_cast<NamedDecl>(D))
     ND->getDeclContext()->getPrimaryContext()->
         makeDeclVisibleInContextWithFlags(ND, false, true);
 }
@@ -1433,7 +1428,7 @@ void DeclContext::addDecl(Decl *D) {
 void DeclContext::addDeclInternal(Decl *D) {
   addHiddenDecl(D);
 
-  if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
+  if (auto *ND = dyn_cast<NamedDecl>(D))
     ND->getDeclContext()->getPrimaryContext()->
         makeDeclVisibleInContextWithFlags(ND, true, true);
 }
@@ -1457,7 +1452,7 @@ static bool shouldBeHidden(NamedDecl *D) {
   // from being visible?
   if (isa<ClassTemplateSpecializationDecl>(D))
     return true;
-  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
+  if (auto *FD = dyn_cast<FunctionDecl>(D))
     if (FD->isFunctionTemplateSpecialization())
       return true;
 
@@ -1505,7 +1500,7 @@ StoredDeclsMap *DeclContext::buildLookup() {
 /// DeclContext, a DeclContext linked to it, or a transparent context
 /// nested within it.
 void DeclContext::buildLookupImpl(DeclContext *DCtx, bool Internal) {
-  for (Decl *D : DCtx->noload_decls()) {
+  for (auto *D : DCtx->noload_decls()) {
     // Insert this declaration into the lookup structure, but only if
     // it's semantically within its decl context. Any other decls which
     // should be found in this context are added eagerly.
@@ -1514,7 +1509,7 @@ void DeclContext::buildLookupImpl(DeclContext *DCtx, bool Internal) {
     // FindExternalVisibleDeclsByName if needed. Exception: if we're not
     // in C++, we do not track external visible decls for the TU, so in
     // that case we need to collect them all here.
-    if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
+    if (auto *ND = dyn_cast<NamedDecl>(D))
       if (ND->getDeclContext() == DCtx && !shouldBeHidden(ND) &&
           (!ND->isFromASTFile() ||
            (isTranslationUnit() &&
@@ -1524,7 +1519,7 @@ void DeclContext::buildLookupImpl(DeclContext *DCtx, bool Internal) {
     // If this declaration is itself a transparent declaration context
     // or inline namespace, add the members of this declaration of that
     // context (recursively).
-    if (DeclContext *InnerCtx = dyn_cast<DeclContext>(D))
+    if (auto *InnerCtx = dyn_cast<DeclContext>(D))
       if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace())
         buildLookupImpl(InnerCtx, Internal);
   }
@@ -1577,7 +1572,7 @@ DeclContext::lookup(DeclarationName Name) const {
       }
     }
 
-    return lookup_result();
+    return {};
   }
 
   StoredDeclsMap *Map = LookupPtr;
@@ -1585,11 +1580,11 @@ DeclContext::lookup(DeclarationName Name) const {
     Map = const_cast<DeclContext*>(this)->buildLookup();
 
   if (!Map)
-    return lookup_result();
+    return {};
 
   StoredDeclsMap::iterator I = Map->find(Name);
   if (I == Map->end())
-    return lookup_result();
+    return {};
 
   return I->second.getLookupResult();
 }
@@ -1606,7 +1601,7 @@ DeclContext::noload_lookup(DeclarationName Name) {
   loadLazyLocalLexicalLookups();
   StoredDeclsMap *Map = LookupPtr;
   if (!Map)
-    return lookup_result();
+    return {};
 
   StoredDeclsMap::iterator I = Map->find(Name);
   return I != Map->end() ? I->second.getLookupResult()
@@ -1620,8 +1615,8 @@ void DeclContext::loadLazyLocalLexicalLookups() {
   if (HasLazyLocalLexicalLookups) {
     SmallVector<DeclContext *, 2> Contexts;
     collectAllContexts(Contexts);
-    for (unsigned I = 0, N = Contexts.size(); I != N; ++I)
-      buildLookupImpl(Contexts[I], hasExternalVisibleStorage());
+    for (auto *Context : Contexts)
+      buildLookupImpl(Context, hasExternalVisibleStorage());
     HasLazyLocalLexicalLookups = false;
   }
 }
@@ -1657,7 +1652,7 @@ void DeclContext::localUncachedLookup(DeclarationName Name,
   // FIXME: If we have lazy external declarations, this will not find them!
   // FIXME: Should we CollectAllContexts and walk them all here?
   for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) {
-    if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
+    if (auto *ND = dyn_cast<NamedDecl>(D))
       if (ND->getDeclName() == Name)
         Results.push_back(ND);
   }
@@ -1699,7 +1694,7 @@ bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const {
     if (O->Equals(this))
       return true;
 
-    const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(O);
+    const auto *NS = dyn_cast<NamespaceDecl>(O);
     if (!NS || !NS->isInline())
       break;
     O = NS->getParent();
@@ -1758,7 +1753,7 @@ void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
     getParent()->getPrimaryContext()->
         makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);
 
-  Decl *DCAsDecl = cast<Decl>(this);
+  auto *DCAsDecl = cast<Decl>(this);
   // Notify that a decl was made visible unless we are a Tag being defined.
   if (!(isa<TagDecl>(DCAsDecl) && cast<TagDecl>(DCAsDecl)->isBeingDefined()))
     if (ASTMutationListener *L = DCAsDecl->getASTMutationListener())
@@ -1876,8 +1871,7 @@ DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C,
   if (!Parent->LookupPtr)
     Parent->CreateStoredDeclsMap(C);
 
-  DependentStoredDeclsMap *Map =
-      static_cast<DependentStoredDeclsMap *>(Parent->LookupPtr);
+  auto *Map = static_cast<DependentStoredDeclsMap *>(Parent->LookupPtr);
 
   // Allocate the copy of the PartialDiagnostic via the ASTContext's
   // BumpPtrAllocator, rather than the ASTContext itself.
@@ -1885,7 +1879,7 @@ DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C,
   if (PDiag.hasStorage())
     DiagStorage = new (C) PartialDiagnostic::Storage;
   
-  DependentDiagnostic *DD = new (C) DependentDiagnostic(PDiag, DiagStorage);
+  auto *DD = new (C) DependentDiagnostic(PDiag, DiagStorage);
 
   // TODO: Maybe we shouldn't reverse the order during insertion.
   DD->NextDiagnostic = Map->FirstDiagnostic;
diff --git a/lib/AST/DeclObjC.cpp b/lib/AST/DeclObjC.cpp
index af6c16d997..16e063caac 100644
--- a/lib/AST/DeclObjC.cpp
+++ b/lib/AST/DeclObjC.cpp
@@ -74,7 +74,7 @@ ObjCContainerDecl::getIvarDecl(IdentifierInfo *Id) const {
   lookup_result R = lookup(Id);
   for (lookup_iterator Ivar = R.begin(), IvarEnd = R.end();
        Ivar != IvarEnd; ++Ivar) {
-    if (ObjCIvarDecl *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
+    if (auto *ivar = dyn_cast<ObjCIvarDecl>(*Ivar))
       return ivar;
   }
   return nullptr;
@@ -86,7 +86,7 @@ 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 ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
+  if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
     if (const ObjCProtocolDecl *Def = Proto->getDefinition())
       if (Def->isHidden() && !AllowHidden)
         return nullptr;
@@ -102,7 +102,7 @@ ObjCContainerDecl::getMethod(Selector Sel, bool isInstance,
   lookup_result R = lookup(Sel);
   for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
        Meth != MethEnd; ++Meth) {
-    ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
+    auto *MD = dyn_cast<ObjCMethodDecl>(*Meth);
     if (MD && MD->isInstanceMethod() == isInstance)
       return MD;
   }
@@ -120,12 +120,12 @@ bool ObjCContainerDecl::HasUserDeclaredSetterMethod(
   lookup_result R = lookup(Sel);
   for (lookup_iterator Meth = R.begin(), MethEnd = R.end();
        Meth != MethEnd; ++Meth) {
-    ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(*Meth);
+    auto *MD = dyn_cast<ObjCMethodDecl>(*Meth);
     if (MD && MD->isInstanceMethod() && !MD->isImplicit())
       return true;
   }
 
-  if (const ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(this)) {
+  if (const auto *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()) {
@@ -159,7 +159,7 @@ bool ObjCContainerDecl::HasUserDeclaredSetterMethod(
       OSC = OSC->getSuperClass();
     }
   }
-  if (const ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(this))
+  if (const auto *PD = dyn_cast<ObjCProtocolDecl>(this))
     for (const auto *PI : PD->protocols())
       if (PI->HasUserDeclaredSetterMethod(Property))
         return true;
@@ -172,7 +172,7 @@ ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
                                    ObjCPropertyQueryKind queryKind) {
   // If this context is a hidden protocol definition, don't find any
   // property.
-  if (const ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(DC)) {
+  if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(DC)) {
     if (const ObjCProtocolDecl *Def = Proto->getDefinition())
       if (Def->isHidden())
         return nullptr;
@@ -192,7 +192,7 @@ ObjCPropertyDecl::findPropertyDecl(const DeclContext *DC,
   ObjCPropertyDecl *classProp = nullptr;
   for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E;
        ++I)
-    if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(*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.
       if ((queryKind == ObjCPropertyQueryKind::OBJC_PR_query_unknown &&
@@ -230,7 +230,7 @@ ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration(
     const IdentifierInfo *PropertyId,
     ObjCPropertyQueryKind QueryKind) const {
   // Don't find properties within hidden protocol definitions.
-  if (const ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
+  if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(this)) {
     if (const ObjCProtocolDecl *Def = Proto->getDefinition())
       if (Def->isHidden())
         return nullptr;
@@ -254,7 +254,7 @@ ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration(
     default:
       break;
     case Decl::ObjCProtocol: {
-      const ObjCProtocolDecl *PID = cast<ObjCProtocolDecl>(this);
+      const auto *PID = cast<ObjCProtocolDecl>(this);
       for (const auto *I : PID->protocols())
         if (ObjCPropertyDecl *P = I->FindPropertyDeclaration(PropertyId,
                                                              QueryKind))
@@ -262,7 +262,7 @@ ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration(
       break;
     }
     case Decl::ObjCInterface: {
-      const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(this);
+      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())
@@ -283,7 +283,7 @@ ObjCPropertyDecl *ObjCContainerDecl::FindPropertyDeclaration(
       break;
     }
     case Decl::ObjCCategory: {
-      const ObjCCategoryDecl *OCD = cast<ObjCCategoryDecl>(this);
+      const auto *OCD = cast<ObjCCategoryDecl>(this);
       // Look through protocols.
       if (!OCD->IsClassExtension())
         for (const auto *I : OCD->protocols())
@@ -310,7 +310,8 @@ ObjCTypeParamList *ObjCInterfaceDecl::getTypeParamList() const {
   // Otherwise, look at previous declarations to determine whether any
   // of them has a type parameter list, skipping over those
   // declarations that do not.
-  for (auto decl = getMostRecentDecl(); decl; decl = decl->getPreviousDecl()) {
+  for (const ObjCInterfaceDecl *decl = getMostRecentDecl(); decl;
+       decl = decl->getPreviousDecl()) {
     if (ObjCTypeParamList *written = decl->getTypeParamListAsWritten())
       return written;
   }
@@ -323,7 +324,7 @@ void ObjCInterfaceDecl::setTypeParamList(ObjCTypeParamList *TPL) {
   if (!TPL)
     return;
   // Set the declaration context of each of the type parameters.
-  for (auto typeParam : *TypeParamList)
+  for (auto *typeParam : *TypeParamList)
     typeParam->setDeclContext(this);
 }
 
@@ -437,7 +438,7 @@ void ObjCInterfaceDecl::mergeClassExtensionProtocolList(
   // Check for duplicate protocol in class's protocol list.
   // This is O(n*m). But it is extremely rare and number of protocols in
   // class or its extension are very few.
-  SmallVector<ObjCProtocolDecl*, 8> ProtocolRefs;
+  SmallVector<ObjCProtocolDecl *, 8> ProtocolRefs;
   for (unsigned i = 0; i < ExtNum; i++) {
     bool protocolExists = false;
     ObjCProtocolDecl *ProtoInExtension = ExtList[i];
@@ -604,7 +605,7 @@ void ObjCInterfaceDecl::startDefinition() {
   allocateDefinitionData();
 
   // Update all of the declarations with a pointer to the definition.
-  for (auto RD : redecls()) {
+  for (auto *RD : redecls()) {
     if (RD != this)
       RD->Data = Data;
   }
@@ -710,9 +711,8 @@ ObjCMethodDecl *ObjCInterfaceDecl::lookupMethod(Selector Sel,
         // Didn't find one yet - look through protocols.
         const ObjCList<ObjCProtocolDecl> &Protocols =
           Cat->getReferencedProtocols();
-        for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
-             E = Protocols.end(); I != E; ++I)
-          if ((MethodDecl = (*I)->lookupMethod(Sel, isInstance)))
+        for (auto *Protocol : Protocols)
+          if ((MethodDecl = Protocol->lookupMethod(Sel, isInstance)))
             if (C != Cat || !MethodDecl->isImplicit())
               return MethodDecl;
       }
@@ -865,27 +865,25 @@ ObjCMethodDecl *ObjCMethodDecl::getNextRedeclarationImpl() {
   if (Redecl)
     return Redecl;
 
-  Decl *CtxD = cast<Decl>(getDeclContext());
+  auto *CtxD = cast<Decl>(getDeclContext());
 
   if (!CtxD->isInvalidDecl()) {
-    if (ObjCInterfaceDecl *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
+    if (auto *IFD = dyn_cast<ObjCInterfaceDecl>(CtxD)) {
       if (ObjCImplementationDecl *ImplD = Ctx.getObjCImplementation(IFD))
         if (!ImplD->isInvalidDecl())
           Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
 
-    } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
+    } else if (auto *CD = dyn_cast<ObjCCategoryDecl>(CtxD)) {
       if (ObjCCategoryImplDecl *ImplD = Ctx.getObjCImplementation(CD))
         if (!ImplD->isInvalidDecl())
           Redecl = ImplD->getMethod(getSelector(), isInstanceMethod());
 
-    } else if (ObjCImplementationDecl *ImplD =
-                 dyn_cast<ObjCImplementationDecl>(CtxD)) {
+    } else if (auto *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
       if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
         if (!IFD->isInvalidDecl())
           Redecl = IFD->getMethod(getSelector(), isInstanceMethod());
 
-    } else if (ObjCCategoryImplDecl *CImplD =
-                 dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
+    } else if (auto *CImplD = dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
       if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
         if (!CatD->isInvalidDecl())
           Redecl = CatD->getMethod(getSelector(), isInstanceMethod());
@@ -908,15 +906,14 @@ ObjCMethodDecl *ObjCMethodDecl::getNextRedeclarationImpl() {
 }
 
 ObjCMethodDecl *ObjCMethodDecl::getCanonicalDecl() {
-  Decl *CtxD = cast<Decl>(getDeclContext());
+  auto *CtxD = cast<Decl>(getDeclContext());
 
-  if (ObjCImplementationDecl *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
+  if (auto *ImplD = dyn_cast<ObjCImplementationDecl>(CtxD)) {
     if (ObjCInterfaceDecl *IFD = ImplD->getClassInterface())
       if (ObjCMethodDecl *MD = IFD->getMethod(getSelector(),
                                               isInstanceMethod()))
         return MD;
-  } else if (ObjCCategoryImplDecl *CImplD =
-               dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
+  } else if (auto *CImplD = dyn_cast<ObjCCategoryImplDecl>(CtxD)) {
     if (ObjCCategoryDecl *CatD = CImplD->getCategoryDecl())
       if (ObjCMethodDecl *MD = CatD->getMethod(getSelector(),
                                                isInstanceMethod()))
@@ -941,7 +938,7 @@ SourceLocation ObjCMethodDecl::getLocEnd() const {
 }
 
 ObjCMethodFamily ObjCMethodDecl::getMethodFamily() const {
-  ObjCMethodFamily family = static_cast<ObjCMethodFamily>(Family);
+  auto family = static_cast<ObjCMethodFamily>(Family);
   if (family != static_cast<unsigned>(InvalidObjCMethodFamily))
     return family;
 
@@ -1099,11 +1096,11 @@ void ObjCMethodDecl::createImplicitParams(ASTContext &Context,
 }
 
 ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() {
-  if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext()))
+  if (auto *ID = dyn_cast<ObjCInterfaceDecl>(getDeclContext()))
     return ID;
-  if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
+  if (auto *CD = dyn_cast<ObjCCategoryDecl>(getDeclContext()))
     return CD->getClassInterface();
-  if (ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(getDeclContext()))
+  if (auto *IMD = dyn_cast<ObjCImplDecl>(getDeclContext()))
     return IMD->getClassInterface();
   if (isa<ObjCProtocolDecl>(getDeclContext()))
     return nullptr;
@@ -1141,8 +1138,7 @@ static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
   // 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 ObjCCategoryDecl *
-        Category = dyn_cast<ObjCCategoryDecl>(Container)) {
+  if (const auto *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)
@@ -1174,13 +1170,12 @@ static void CollectOverriddenMethodsRecurse(const ObjCContainerDecl *Container,
       return;
     }
 
-  if (const ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)){
+  if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)){
     for (const auto *P : Protocol->protocols())
       CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
   }
 
-  if (const ObjCInterfaceDecl *
-        Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
+  if (const auto *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
     for (const auto *P : Interface->protocols())
       CollectOverriddenMethodsRecurse(P, Method, Methods, MovedToSuper);
 
@@ -1204,12 +1199,12 @@ static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method,
                           SmallVectorImpl<const ObjCMethodDecl *> &overridden) {
   assert(Method->isOverriding());
 
-  if (const ObjCProtocolDecl *
-        ProtD = dyn_cast<ObjCProtocolDecl>(Method->getDeclContext())) {
+  if (const auto *ProtD =
+          dyn_cast<ObjCProtocolDecl>(Method->getDeclContext())) {
     CollectOverriddenMethods(ProtD, Method, overridden);
 
-  } else if (const ObjCImplDecl *
-               IMD = dyn_cast<ObjCImplDecl>(Method->getDeclContext())) {
+  } else if (const auto *IMD =
+                 dyn_cast<ObjCImplDecl>(Method->getDeclContext())) {
     const ObjCInterfaceDecl *ID = IMD->getClassInterface();
     if (!ID)
       return;
@@ -1221,8 +1216,8 @@ static void collectOverriddenMethodsSlow(const ObjCMethodDecl *Method,
       Method = IFaceMeth;
     CollectOverriddenMethods(ID, Method, overridden);
 
-  } else if (const ObjCCategoryDecl *
-               CatD = dyn_cast<ObjCCategoryDecl>(Method->getDeclContext())) {
+  } else if (const auto *CatD =
+                 dyn_cast<ObjCCategoryDecl>(Method->getDeclContext())) {
     const ObjCInterfaceDecl *ID = CatD->getClassInterface();
     if (!ID)
       return;
@@ -1265,7 +1260,7 @@ ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const {
     return nullptr;
 
   if (isPropertyAccessor()) {
-    const ObjCContainerDecl *Container = cast<ObjCContainerDecl>(getParent());
+    const auto *Container = cast<ObjCContainerDecl>(getParent());
     bool IsGetter = (NumArgs == 0);
     bool IsInstance = isInstanceMethod();
 
@@ -1328,11 +1323,9 @@ ObjCMethodDecl::findPropertyDecl(bool CheckOverrides) const {
 
   OverridesTy Overrides;
   getOverriddenMethods(Overrides);
-  for (OverridesTy::const_iterator I = Overrides.begin(), E = Overrides.end();
-       I != E; ++I) {
-    if (const ObjCPropertyDecl *Prop = (*I)->findPropertyDecl(false))
+  for (const auto *Override : Overrides)
+    if (const ObjCPropertyDecl *Prop = Override->findPropertyDecl(false))
       return Prop;
-  }
 
   return nullptr;
 }
@@ -1422,7 +1415,7 @@ ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
                                              ObjCInterfaceDecl *PrevDecl,
                                              SourceLocation ClassLoc,
                                              bool isInternal){
-  ObjCInterfaceDecl *Result = new (C, DC)
+  auto *Result = new (C, DC)
       ObjCInterfaceDecl(C, DC, atLoc, Id, typeParamList, ClassLoc, PrevDecl,
                         isInternal);
   Result->Data.setInt(!C.getLangOpts().Modules);
@@ -1432,12 +1425,9 @@ ObjCInterfaceDecl *ObjCInterfaceDecl::Create(const ASTContext &C,
 
 ObjCInterfaceDecl *ObjCInterfaceDecl::CreateDeserialized(const ASTContext &C,
                                                          unsigned ID) {
-  ObjCInterfaceDecl *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;
 }
@@ -1495,7 +1485,7 @@ bool ObjCInterfaceDecl::hasDesignatedInitializers() const {
 
 StringRef
 ObjCInterfaceDecl::getObjCRuntimeNameAsString() const {
-  if (ObjCRuntimeNameAttr *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
+  if (const auto *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
     return ObjCRTName->getMetadataName();
 
   return getName();
@@ -1731,9 +1721,9 @@ ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, ObjCContainerDecl *DC,
            "Invalid ivar decl context!");
     // Once a new ivar is created in any of class/class-extension/implementation
     // decl contexts, the previously built IvarList must be rebuilt.
-    ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(DC);
+    auto *ID = dyn_cast<ObjCInterfaceDecl>(DC);
     if (!ID) {
-      if (ObjCImplementationDecl *IM = dyn_cast<ObjCImplementationDecl>(DC))
+      if (auto *IM = dyn_cast<ObjCImplementationDecl>(DC))
         ID = IM->getClassInterface();
       else
         ID = cast<ObjCCategoryDecl>(DC)->getClassInterface();
@@ -1752,7 +1742,7 @@ ObjCIvarDecl *ObjCIvarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
 }
 
 const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
-  const ObjCContainerDecl *DC = cast<ObjCContainerDecl>(getDeclContext());
+  const auto *DC = cast<ObjCContainerDecl>(getDeclContext());
 
   switch (DC->getKind()) {
   default:
@@ -1762,7 +1752,7 @@ const ObjCInterfaceDecl *ObjCIvarDecl::getContainingInterface() const {
 
     // Ivars can only appear in class extension categories.
   case ObjCCategory: {
-    const ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(DC);
+    const auto *CD = cast<ObjCCategoryDecl>(DC);
     assert(CD->IsClassExtension() && "invalid container for ivar!");
     return CD->getClassInterface();
   }
@@ -1822,7 +1812,7 @@ ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C, DeclContext *DC,
                                            SourceLocation nameLoc,
                                            SourceLocation atStartLoc,
                                            ObjCProtocolDecl *PrevDecl) {
-  ObjCProtocolDecl *Result =
+  auto *Result =
       new (C, DC) ObjCProtocolDecl(C, DC, Id, nameLoc, atStartLoc, PrevDecl);
   Result->Data.setInt(!C.getLangOpts().Modules);
   return Result;
@@ -1881,7 +1871,7 @@ void ObjCProtocolDecl::startDefinition() {
   allocateDefinitionData();
   
   // Update all of the declarations with a pointer to the definition.
-  for (auto RD : redecls())
+  for (auto *RD : redecls())
     RD->Data = this->Data;
 }
 
@@ -1923,7 +1913,7 @@ void ObjCProtocolDecl::collectInheritedProtocolProperties(
 
 StringRef
 ObjCProtocolDecl::getObjCRuntimeNameAsString() const {
-  if (ObjCRuntimeNameAttr *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
+  if (const auto *ObjCRTName = getAttr<ObjCRuntimeNameAttr>())
     return ObjCRTName->getMetadataName();
 
   return getName();
@@ -1957,7 +1947,7 @@ ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C, DeclContext *DC,
                                            ObjCTypeParamList *typeParamList,
                                            SourceLocation IvarLBraceLoc,
                                            SourceLocation IvarRBraceLoc) {
-  ObjCCategoryDecl *CatDecl =
+  auto *CatDecl =
       new (C, DC) ObjCCategoryDecl(DC, AtLoc, ClassNameLoc, CategoryNameLoc, Id,
                                    IDecl, typeParamList, IvarLBraceLoc,
                                    IvarRBraceLoc);
@@ -1995,11 +1985,10 @@ void ObjCCategoryDecl::setTypeParamList(ObjCTypeParamList *TPL) {
   if (!TPL)
     return;
   // Set the declaration context of each of the type parameters.
-  for (auto typeParam : *TypeParamList)
+  for (auto *typeParam : *TypeParamList)
     typeParam->setDeclContext(this);
 }
 
-
 //===----------------------------------------------------------------------===//
 // ObjCCategoryImplDecl
 //===----------------------------------------------------------------------===//
@@ -2044,13 +2033,11 @@ void ObjCImplDecl::addPropertyImplementation(ObjCPropertyImplDecl *property) {
 void ObjCImplDecl::setClassInterface(ObjCInterfaceDecl *IFace) {
   ASTContext &Ctx = getASTContext();
 
-  if (ObjCImplementationDecl *ImplD
-        = dyn_cast_or_null<ObjCImplementationDecl>(this)) {
+  if (auto *ImplD = dyn_cast_or_null<ObjCImplementationDecl>(this)) {
     if (IFace)
       Ctx.setObjCImplementation(IFace, ImplD);
 
-  } else if (ObjCCategoryImplDecl *ImplD =
-             dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
+  } else if (auto *ImplD = dyn_cast_or_null<ObjCCategoryImplDecl>(this)) {
     if (ObjCCategoryDecl *CD = IFace->FindCategoryDeclaration(getIdentifier()))
       Ctx.setObjCImplementation(CD, ImplD);
   }
@@ -2139,8 +2126,7 @@ void ObjCImplementationDecl::setIvarInitializers(ASTContext &C,
                                                  unsigned numInitializers) {
   if (numInitializers > 0) {
     NumIvarInitializers = numInitializers;
-    CXXCtorInitializer **ivarInitializers =
-    new (C) CXXCtorInitializer*[NumIvarInitializers];
+    auto **ivarInitializers = new (C) CXXCtorInitializer*[NumIvarInitializers];
     memcpy(ivarInitializers, initializers,
            numInitializers * sizeof(CXXCtorInitializer*));
     IvarInitializers = ivarInitializers;