Index: lib/AST/Expr.cpp
===================================================================
--- lib/AST/Expr.cpp
+++ lib/AST/Expr.cpp
@@ -1,4 +1,4 @@
-//===--- Expr.cpp - Expression AST Node Implementation --------------------===//
+//===--- Expr.cpp - Expression AST Node Implementation ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -34,6 +34,7 @@
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
+
 using namespace clang;
 
 const CXXRecordDecl *Expr::getBestDynamicClassType() const {
@@ -46,7 +47,7 @@
   if (DerivedType->isDependentType())
     return nullptr;
 
-  const RecordType *Ty = DerivedType->castAs<RecordType>();
+  const auto *Ty = DerivedType->castAs<RecordType>();
   Decl *D = Ty->getDecl();
   return cast<CXXRecordDecl>(D);
 }
@@ -58,12 +59,12 @@
   while (true) {
     E = E->IgnoreParens();
 
-    if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
+    if (const auto *CE = dyn_cast<CastExpr>(E)) {
       if ((CE->getCastKind() == CK_DerivedToBase ||
            CE->getCastKind() == CK_UncheckedDerivedToBase) &&
           E->getType()->isRecordType()) {
         E = CE->getSubExpr();
-        CXXRecordDecl *Derived
+        auto *Derived
           = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
         Adjustments.push_back(SubobjectAdjustment(CE, Derived));
         continue;
@@ -73,7 +74,7 @@
         E = CE->getSubExpr();
         continue;
       }
-    } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
+    } else if (const auto *ME = dyn_cast<MemberExpr>(E)) {
       if (!ME->isArrow()) {
         assert(ME->getBase()->getType()->isRecordType());
         if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
@@ -84,7 +85,7 @@
           }
         }
       }
-    } else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
+    } else if (const auto *BO = dyn_cast<BinaryOperator>(E)) {
       if (BO->isPtrMemOp()) {
         assert(BO->getRHS()->isRValue());
         E = BO->getLHS();
@@ -117,7 +118,7 @@
   // If this is a non-scalar-integer type, we don't care enough to try. 
   if (!E->getType()->isIntegralOrEnumerationType()) return false;
   
-  if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
+  if (const auto *UO = dyn_cast<UnaryOperator>(E)) {
     switch (UO->getOpcode()) {
     case UO_Plus:
       return UO->getSubExpr()->isKnownToHaveBooleanValue();
@@ -130,10 +131,10 @@
   
   // Only look through implicit casts.  If the user writes
   // '(int) (a && b)' treat it as an arbitrary int.
-  if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
+  if (const auto *CE = dyn_cast<ImplicitCastExpr>(E))
     return CE->getSubExpr()->isKnownToHaveBooleanValue();
   
-  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
+  if (const auto *BO = dyn_cast<BinaryOperator>(E)) {
     switch (BO->getOpcode()) {
     default: return false;
     case BO_LT:   // Relational operators.
@@ -159,7 +160,7 @@
     }
   }
   
-  if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
+  if (const auto *CO = dyn_cast<ConditionalOperator>(E))
     return CO->getTrueExpr()->isKnownToHaveBooleanValue() &&
            CO->getFalseExpr()->isKnownToHaveBooleanValue();
   
@@ -188,7 +189,7 @@
                                 SourceLocation (Expr::*v)() const) {
     return static_cast<const E*>(expr)->getLocStart();
   }
-}
+} // anonymous namespace
 
 SourceLocation Expr::getExprLoc() const {
   switch (getStmtClass()) {
@@ -266,7 +267,7 @@
   //  (VD) - FIXME: Missing from the standard:
   //       -  an entity with reference type and is initialized with an
   //          expression that is value-dependent [C++11]
-  if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
+  if (const auto *Var = dyn_cast<VarDecl>(D)) {
     if ((Ctx.getLangOpts().CPlusPlus11 ?
            Var->getType()->isLiteralType(Ctx) :
            Var->getType()->isIntegralOrEnumerationType()) &&
@@ -484,16 +485,16 @@
   ASTContext &Context = CurrentDecl->getASTContext();
 
   if (IT == PredefinedExpr::FuncDName) {
-    if (const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
+    if (const auto *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
       std::unique_ptr<MangleContext> MC;
       MC.reset(Context.createMangleContext());
 
       if (MC->shouldMangleDeclName(ND)) {
         SmallString<256> Buffer;
         llvm::raw_svector_ostream Out(Buffer);
-        if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(ND))
+        if (const auto *CD = dyn_cast<CXXConstructorDecl>(ND))
           MC->mangleCXXCtor(CD, Ctor_Base, Out);
-        else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(ND))
+        else if (const auto *DD = dyn_cast<CXXDestructorDecl>(ND))
           MC->mangleCXXDtor(DD, Dtor_Base, Out);
         else
           MC->mangleName(ND, Out);
@@ -522,14 +523,14 @@
       MC->mangleBlock(DC, BD, Out);
     return Out.str();
   }
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
+  if (const auto *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
     if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual && IT != FuncSig)
       return FD->getNameAsString();
 
     SmallString<256> Name;
     llvm::raw_svector_ostream Out(Name);
 
-    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
+    if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
       if (MD->isVirtual() && IT != PrettyFunctionNoVirtual)
         Out << "virtual ";
       if (MD->isStatic())
@@ -576,8 +577,8 @@
     }
     POut << ")";
 
-    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
-      const FunctionType *FT = MD->getType()->castAs<FunctionType>();
+    if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
+      const auto *FT = MD->getType()->castAs<FunctionType>();
       if (FT->isConst())
         POut << " const";
       if (FT->isVolatile())
@@ -593,8 +594,7 @@
     SpecsTy Specs;
     const DeclContext *Ctx = FD->getDeclContext();
     while (Ctx && isa<NamedDecl>(Ctx)) {
-      const ClassTemplateSpecializationDecl *Spec
-                               = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
+      const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
       if (Spec && !Spec->isExplicitSpecialization())
         Specs.push_back(Spec);
       Ctx = Ctx->getParent();
@@ -661,7 +661,7 @@
 
     return Name.str().str();
   }
-  if (const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
+  if (const auto *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
     for (const DeclContext *DC = CD->getParent(); DC; DC = DC->getParent())
       // Skip to its enclosing function or method, but not its enclosing
       // CapturedDecl.
@@ -671,7 +671,7 @@
       }
     llvm_unreachable("CapturedDecl not inside a function or method");
   }
-  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
+  if (const auto *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
     SmallString<256> Name;
     llvm::raw_svector_ostream Out(Name);
     Out << (MD->isInstanceMethod() ? '-' : '+');
@@ -682,8 +682,7 @@
     if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
       Out << *ID;
 
-    if (const ObjCCategoryImplDecl *CID =
-        dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
+    if (const auto *CID = dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
       Out << '(' << *CID << ')';
 
     Out <<  ' ';
@@ -846,7 +845,7 @@
   void *Mem = C.Allocate(sizeof(StringLiteral)+
                          sizeof(SourceLocation)*(NumStrs-1),
                          llvm::alignOf<StringLiteral>());
-  StringLiteral *SL = new (Mem) StringLiteral(Ty);
+  auto *SL = new (Mem) StringLiteral(Ty);
 
   // OPTIMIZE: could allocate this appended to the StringLiteral.
   SL->setString(C,Str,Kind,Pascal);
@@ -864,7 +863,7 @@
   void *Mem = C.Allocate(sizeof(StringLiteral)+
                          sizeof(SourceLocation)*(NumStrs-1),
                          llvm::alignOf<StringLiteral>());
-  StringLiteral *SL = new (Mem) StringLiteral(QualType());
+  auto *SL = new (Mem) StringLiteral(QualType());
   SL->CharByteWidth = 0;
   SL->Length = 0;
   SL->NumConcatenated = NumStrs;
@@ -978,19 +977,19 @@
 
   switch(CharByteWidth) {
     case 1: {
-      char *AStrData = new (C) char[Length];
+      auto *AStrData = new (C) char[Length];
       std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData));
       StrData.asChar = AStrData;
       break;
     }
     case 2: {
-      uint16_t *AStrData = new (C) uint16_t[Length];
+      auto *AStrData = new (C) uint16_t[Length];
       std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData));
       StrData.asUInt16 = AStrData;
       break;
     }
     case 4: {
-      uint32_t *AStrData = new (C) uint32_t[Length];
+      auto *AStrData = new (C) uint32_t[Length];
       std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData));
       StrData.asUInt32 = AStrData;
       break;
@@ -1060,8 +1059,6 @@
   }
 }
 
-
-
 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
 /// corresponds to, e.g. "sizeof" or "[pre]++".
 StringRef UnaryOperator::getOpcodeStr(Opcode Op) {
@@ -1115,7 +1112,6 @@
   }
 }
 
-
 //===----------------------------------------------------------------------===//
 // Postfix Operators.
 //===----------------------------------------------------------------------===//
@@ -1168,22 +1164,21 @@
 Decl *CallExpr::getCalleeDecl() {
   Expr *CEE = getCallee()->IgnoreParenImpCasts();
     
-  while (SubstNonTypeTemplateParmExpr *NTTP
-                                = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) {
+  while (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) {
     CEE = NTTP->getReplacement()->IgnoreParenCasts();
   }
   
   // If we're calling a dereference, look at the pointer instead.
-  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CEE)) {
+  if (auto *BO = dyn_cast<BinaryOperator>(CEE)) {
     if (BO->isPtrMemOp())
       CEE = BO->getRHS()->IgnoreParenCasts();
-  } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) {
+  } else if (auto *UO = dyn_cast<UnaryOperator>(CEE)) {
     if (UO->getOpcode() == UO_Deref)
       CEE = UO->getSubExpr()->IgnoreParenCasts();
   }
-  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
+  if (auto *DRE = dyn_cast<DeclRefExpr>(CEE))
     return DRE->getDecl();
-  if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
+  if (auto *ME = dyn_cast<MemberExpr>(CEE))
     return ME->getMemberDecl();
 
   return nullptr;
@@ -1208,7 +1203,7 @@
 
   // Otherwise, we are growing the # arguments.  New an bigger argument array.
   unsigned NumPreArgs = getNumPreArgs();
-  Stmt **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs];
+  auto **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs];
   // Copy over args.
   for (unsigned i = 0; i != getNumArgs()+PREARGS_START+NumPreArgs; ++i)
     NewSubExprs[i] = SubExprs[i];
@@ -1228,15 +1223,15 @@
   // All simple function calls (e.g. func()) are implicitly cast to pointer to
   // function. As a result, we try and obtain the DeclRefExpr from the
   // ImplicitCastExpr.
-  const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
+  const auto *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
   if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
     return 0;
 
-  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
+  const auto *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
   if (!DRE)
     return 0;
 
-  const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
+  const auto *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
   if (!FDecl)
     return 0;
 
@@ -1267,7 +1262,7 @@
     CalleeType = Expr::findBoundMemberType(Callee);
   }
 
-  const FunctionType *FnType = CalleeType->castAs<FunctionType>();
+  const auto *FnType = CalleeType->castAs<FunctionType>();
   return FnType->getReturnType();
 }
 
@@ -1404,7 +1399,7 @@
     Size += ASTTemplateKWAndArgsInfo::sizeFor(0);
 
   void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>());
-  MemberExpr *E = new (Mem)
+  auto *E = new (Mem)
       MemberExpr(base, isarrow, OperatorLoc, memberdecl, nameinfo, ty, vk, ok);
 
   if (hasQualOrFound) {
@@ -1702,12 +1697,11 @@
     SubExpr = E->getSubExpr();
 
     // Skip through reference binding to temporary.
-    if (MaterializeTemporaryExpr *Materialize 
-                                  = dyn_cast<MaterializeTemporaryExpr>(SubExpr))
+    if (auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(SubExpr))
       SubExpr = Materialize->GetTemporaryExpr();
         
     // Skip any temporary bindings; they're implicit.
-    if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
+    if (auto *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
       SubExpr = Binder->getSubExpr();
     
     // Conversions by constructor and conversion functions have a
@@ -1749,8 +1743,7 @@
   unsigned PathSize = (BasePath ? BasePath->size() : 0);
   void *Buffer =
     C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
-  ImplicitCastExpr *E =
-    new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK);
+  auto *E = new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK);
   if (PathSize) E->setCastPath(*BasePath);
   return E;
 }
@@ -1762,7 +1755,6 @@
   return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize);
 }
 
-
 CStyleCastExpr *CStyleCastExpr::Create(const ASTContext &C, QualType T,
                                        ExprValueKind VK, CastKind K, Expr *Op,
                                        const CXXCastPath *BasePath,
@@ -1771,7 +1763,7 @@
   unsigned PathSize = (BasePath ? BasePath->size() : 0);
   void *Buffer =
     C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
-  CStyleCastExpr *E =
+  auto *E =
     new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, R);
   if (PathSize) E->setCastPath(*BasePath);
   return E;
@@ -1925,7 +1917,7 @@
     return nullptr;
   }
 
-  Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
+  auto *Result = cast_or_null<Expr>(InitExprs[Init]);
   setInit(Init, expr);
   return Result;
 }
@@ -1960,10 +1952,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) {
-      if (Stmt *S = *I) {
+    for (const auto &I : InitExprs) {
+      if (Stmt *S = I) {
         Beg = S->getLocStart();
         break;
       }  
@@ -2008,7 +1998,6 @@
   return TheBlock->getBody();
 }
 
-
 //===----------------------------------------------------------------------===//
 // Generic Expression Routines
 //===----------------------------------------------------------------------===//
@@ -2043,7 +2032,7 @@
     return cast<ChooseExpr>(this)->getChosenSubExpr()->
       isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
   case UnaryOperatorClass: {
-    const UnaryOperator *UO = cast<UnaryOperator>(this);
+    const auto *UO = cast<UnaryOperator>(this);
 
     switch (UO->getOpcode()) {
     case UO_Plus:
@@ -2077,7 +2066,7 @@
     return true;
   }
   case BinaryOperatorClass: {
-    const BinaryOperator *BO = cast<BinaryOperator>(this);
+    const auto *BO = cast<BinaryOperator>(this);
     switch (BO->getOpcode()) {
       default:
         break;
@@ -2086,8 +2075,7 @@
       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 (auto *IE = dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
           if (IE->getValue() == 0)
             return false;
         return BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
@@ -2116,7 +2104,7 @@
     // 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 ConditionalOperator *Exp = cast<ConditionalOperator>(this);
+    const auto *Exp = cast<ConditionalOperator>(this);
     if (!Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx))
       return false;
     if (!Exp->getLHS())
@@ -2145,7 +2133,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);
+    const auto *Op = cast<CXXOperatorCallExpr>(this);
     switch (Op->getOperator()) {
     default:
       break;
@@ -2170,9 +2158,9 @@
   case CXXMemberCallExprClass:
   case UserDefinedLiteralClass: {
     // If this is a direct call, get the callee.
-    const CallExpr *CE = cast<CallExpr>(this);
+    const auto *CE = cast<CallExpr>(this);
     if (const Decl *FD = CE->getCalleeDecl()) {
-      const FunctionDecl *Func = dyn_cast<FunctionDecl>(FD);
+      const auto *Func = dyn_cast<FunctionDecl>(FD);
       bool HasWarnUnusedResultAttr = Func ? Func->hasUnusedResultAttr()
                                           : FD->hasAttr<WarnUnusedResultAttr>();
 
@@ -2215,7 +2203,7 @@
   }
 
   case ObjCMessageExprClass: {
-    const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
+    const auto *ME = cast<ObjCMessageExpr>(this);
     if (Ctx.getLangOpts().ObjCAutoRefCount &&
         ME->isInstanceMessage() &&
         !ME->getType()->isVoidType() &&
@@ -2243,7 +2231,7 @@
     return true;
 
   case PseudoObjectExprClass: {
-    const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this);
+    const auto *PO = cast<PseudoObjectExpr>(this);
 
     // Only complain about things that have the form of a getter.
     if (isa<UnaryOperator>(PO->getSyntacticForm()) ||
@@ -2264,10 +2252,10 @@
     // warning.
     const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
     if (!CS->body_empty()) {
-      if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
+      if (const auto *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 (const auto *Label = dyn_cast<LabelStmt>(CS->body_back()))
+        if (const auto *E = dyn_cast<Expr>(Label->getSubStmt()))
           return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
     }
 
@@ -2282,12 +2270,12 @@
   case CStyleCastExprClass: {
     // Ignore an explicit cast to void unless the operand is a non-trivial
     // volatile lvalue.
-    const CastExpr *CE = cast<CastExpr>(this);
+    const auto *CE = cast<CastExpr>(this);
     if (CE->getCastKind() == CK_ToVoid) {
       if (CE->getSubExpr()->isGLValue() &&
           CE->getSubExpr()->getType().isVolatileQualified()) {
-        const DeclRefExpr *DRE =
-            dyn_cast<DeclRefExpr>(CE->getSubExpr()->IgnoreParens());
+        const auto *DRE =
+          dyn_cast<DeclRefExpr>(CE->getSubExpr()->IgnoreParens());
         if (!(DRE && isa<VarDecl>(DRE->getDecl()) &&
               cast<VarDecl>(DRE->getDecl())->hasLocalStorage())) {
           return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc,
@@ -2303,19 +2291,18 @@
       return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
 
     WarnE = this;
-    if (const CXXFunctionalCastExpr *CXXCE =
-            dyn_cast<CXXFunctionalCastExpr>(this)) {
+    if (const auto *CXXCE = dyn_cast<CXXFunctionalCastExpr>(this)) {
       Loc = CXXCE->getLocStart();
       R1 = CXXCE->getSubExpr()->getSourceRange();
     } else {
-      const CStyleCastExpr *CStyleCE = cast<CStyleCastExpr>(this);
+      const auto *CStyleCE = cast<CStyleCastExpr>(this);
       Loc = CStyleCE->getLParenLoc();
       R1 = CStyleCE->getSubExpr()->getSourceRange();
     }
     return true;
   }
   case ImplicitCastExprClass: {
-    const CastExpr *ICE = cast<ImplicitCastExpr>(this);
+    const auto *ICE = cast<ImplicitCastExpr>(this);
 
     // lvalue-to-rvalue conversion on a volatile lvalue is a side-effect.
     if (ICE->getCastKind() == CK_LValueToRValue &&
@@ -2366,7 +2353,7 @@
   case DeclRefExprClass: {
     const Decl *D = cast<DeclRefExpr>(E)->getDecl();
         
-    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
+    if (const auto *VD = dyn_cast<VarDecl>(D)) {
       if (VD->hasGlobalStorage())
         return true;
       QualType T = VD->getType();
@@ -2378,7 +2365,7 @@
     return false;
   }
   case MemberExprClass: {
-    const MemberExpr *M = cast<MemberExpr>(E);
+    const auto *M = cast<MemberExpr>(E);
     return M->getBase()->isOBJCGCCandidate(Ctx);
   }
   case ArraySubscriptExprClass:
@@ -2400,12 +2387,12 @@
   // (possibly parenthesized)
 
   expr = expr->IgnoreParens();
-  if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) {
+  if (const auto *mem = dyn_cast<MemberExpr>(expr)) {
     assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
     return mem->getMemberDecl()->getType();
   }
 
-  if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) {
+  if (const auto *op = dyn_cast<BinaryOperator>(expr)) {
     QualType type = op->getRHS()->getType()->castAs<MemberPointerType>()
                       ->getPointeeType();
     assert(type->isFunctionType());
@@ -2419,23 +2406,23 @@
 Expr* Expr::IgnoreParens() {
   Expr* E = this;
   while (true) {
-    if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
+    if (auto *P = dyn_cast<ParenExpr>(E)) {
       E = P->getSubExpr();
       continue;
     }
-    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
+    if (auto *P = dyn_cast<UnaryOperator>(E)) {
       if (P->getOpcode() == UO_Extension) {
         E = P->getSubExpr();
         continue;
       }
     }
-    if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
+    if (auto *P = dyn_cast<GenericSelectionExpr>(E)) {
       if (!P->isResultDependent()) {
         E = P->getResultExpr();
         continue;
       }
     }
-    if (ChooseExpr* P = dyn_cast<ChooseExpr>(E)) {
+    if (auto *P = dyn_cast<ChooseExpr>(E)) {
       if (!P->isConditionDependent()) {
         E = P->getChosenSubExpr();
         continue;
@@ -2451,17 +2438,15 @@
   Expr *E = this;
   while (true) {
     E = E->IgnoreParens();
-    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
+    if (auto *P = dyn_cast<CastExpr>(E)) {
       E = P->getSubExpr();
       continue;
     }
-    if (MaterializeTemporaryExpr *Materialize 
-                                      = dyn_cast<MaterializeTemporaryExpr>(E)) {
+    if (auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E)) {
       E = Materialize->GetTemporaryExpr();
       continue;
     }
-    if (SubstNonTypeTemplateParmExpr *NTTP
-                                  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+    if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
       E = NTTP->getReplacement();
       continue;
     }      
@@ -2472,17 +2457,15 @@
 Expr *Expr::IgnoreCasts() {
   Expr *E = this;
   while (true) {
-    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
+    if (auto *P = dyn_cast<CastExpr>(E)) {
       E = P->getSubExpr();
       continue;
     }
-    if (MaterializeTemporaryExpr *Materialize
-        = dyn_cast<MaterializeTemporaryExpr>(E)) {
+    if (auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E)) {
       E = Materialize->GetTemporaryExpr();
       continue;
     }
-    if (SubstNonTypeTemplateParmExpr *NTTP
-        = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+    if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
       E = NTTP->getReplacement();
       continue;
     }
@@ -2498,17 +2481,15 @@
   Expr *E = this;
   while (true) {
     E = E->IgnoreParens();
-    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
+    if (auto *P = dyn_cast<CastExpr>(E)) {
       if (P->getCastKind() == CK_LValueToRValue) {
         E = P->getSubExpr();
         continue;
       }
-    } else if (MaterializeTemporaryExpr *Materialize 
-                                      = dyn_cast<MaterializeTemporaryExpr>(E)) {
+    } else if (auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E)) {
       E = Materialize->GetTemporaryExpr();
       continue;
-    } else if (SubstNonTypeTemplateParmExpr *NTTP
-                                  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+    } else if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
       E = NTTP->getReplacement();
       continue;
     }
@@ -2521,7 +2502,7 @@
   Expr *E = this;
   while (true) {
     E = E->IgnoreParens();
-    if (CastExpr *CE = dyn_cast<CastExpr>(E)) {
+    if (auto *CE = dyn_cast<CastExpr>(E)) {
       if (CE->getCastKind() == CK_DerivedToBase ||
           CE->getCastKind() == CK_UncheckedDerivedToBase ||
           CE->getCastKind() == CK_NoOp) {
@@ -2538,17 +2519,15 @@
   Expr *E = this;
   while (true) {
     E = E->IgnoreParens();
-    if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) {
+    if (auto *P = dyn_cast<ImplicitCastExpr>(E)) {
       E = P->getSubExpr();
       continue;
     }
-    if (MaterializeTemporaryExpr *Materialize 
-                                      = dyn_cast<MaterializeTemporaryExpr>(E)) {
+    if (auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E)) {
       E = Materialize->GetTemporaryExpr();
       continue;
     }
-    if (SubstNonTypeTemplateParmExpr *NTTP
-                                  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+    if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
       E = NTTP->getReplacement();
       continue;
     }
@@ -2557,7 +2536,7 @@
 }
 
 Expr *Expr::IgnoreConversionOperator() {
-  if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(this)) {
+  if (auto *MCE = dyn_cast<CXXMemberCallExpr>(this)) {
     if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
       return MCE->getImplicitObjectArgument();
   }
@@ -2572,7 +2551,7 @@
   while (true) {
     E = E->IgnoreParens();
 
-    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
+    if (auto *P = dyn_cast<CastExpr>(E)) {
       // We ignore integer <-> casts that are of the same width, ptr<->ptr and
       // ptr<->int casts of the same width.  We also ignore all identity casts.
       Expr *SE = P->getSubExpr();
@@ -2592,8 +2571,7 @@
       }
     }
 
-    if (SubstNonTypeTemplateParmExpr *NTTP
-                                  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+    if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
       E = NTTP->getReplacement();
       continue;
     }
@@ -2604,10 +2582,10 @@
 
 bool Expr::isDefaultArgument() const {
   const Expr *E = this;
-  if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
+  if (const auto *M = dyn_cast<MaterializeTemporaryExpr>(E))
     E = M->GetTemporaryExpr();
 
-  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
+  while (const auto *ICE = dyn_cast<ImplicitCastExpr>(E))
     E = ICE->getSubExprAsWritten();
   
   return isa<CXXDefaultArgExpr>(E);
@@ -2616,20 +2594,20 @@
 /// \brief 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))
+  if (const auto *M = dyn_cast<MaterializeTemporaryExpr>(E))
     E = M->GetTemporaryExpr();
 
-  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+  while (const auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
     if (ICE->getCastKind() == CK_NoOp)
       E = ICE->getSubExpr();
     else
       break;
   }
 
-  while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
+  while (const auto *BE = dyn_cast<CXXBindTemporaryExpr>(E))
     E = BE->getSubExpr();
 
-  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+  while (const auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
     if (ICE->getCastKind() == CK_NoOp)
       E = ICE->getSubExpr();
     else
@@ -2672,7 +2650,7 @@
   if (isa<MemberExpr>(E))
     return false;
 
-  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
+  if (const auto *BO = dyn_cast<BinaryOperator>(E))
     if (BO->isPtrMemOp())
       return false;
 
@@ -2688,12 +2666,12 @@
   
   // Strip away parentheses and casts we don't care about.
   while (true) {
-    if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) {
+    if (const auto *Paren = dyn_cast<ParenExpr>(E)) {
       E = Paren->getSubExpr();
       continue;
     }
     
-    if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+    if (const auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
       if (ICE->getCastKind() == CK_NoOp ||
           ICE->getCastKind() == CK_LValueToRValue ||
           ICE->getCastKind() == CK_DerivedToBase || 
@@ -2703,15 +2681,14 @@
       }
     }
     
-    if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
+    if (const auto* UnOp = dyn_cast<UnaryOperator>(E)) {
       if (UnOp->getOpcode() == UO_Extension) {
         E = UnOp->getSubExpr();
         continue;
       }
     }
     
-    if (const MaterializeTemporaryExpr *M
-                                      = dyn_cast<MaterializeTemporaryExpr>(E)) {
+    if (const auto *M = dyn_cast<MaterializeTemporaryExpr>(E)) {
       E = M->GetTemporaryExpr();
       continue;
     }
@@ -2719,7 +2696,7 @@
     break;
   }
   
-  if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
+  if (const auto *This = dyn_cast<CXXThisExpr>(E))
     return This->isImplicit();
   
   return false;
@@ -2728,8 +2705,8 @@
 /// hasAnyTypeDependentArguments - Determines if any of the expressions
 /// in Exprs is type-dependent.
 bool Expr::hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs) {
-  for (unsigned I = 0; I < Exprs.size(); ++I)
-    if (Exprs[I]->isTypeDependent())
+  for (const auto *Expr : Exprs)
+    if (Expr->isTypeDependent())
       return true;
 
   return false;
@@ -2762,7 +2739,7 @@
     return true;
   case CXXTemporaryObjectExprClass:
   case CXXConstructExprClass: {
-    const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
+    const auto *CE = cast<CXXConstructExpr>(this);
 
     if (CE->getConstructor()->isTrivial() &&
         CE->getConstructor()->getParent()->hasTrivialDestructor()) {
@@ -2784,12 +2761,12 @@
     return Exp->isConstantInitializer(Ctx, false, Culprit);
   }
   case DesignatedInitUpdateExprClass: {
-    const DesignatedInitUpdateExpr *DIUE = cast<DesignatedInitUpdateExpr>(this);
+    const auto *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);
+    const auto *ILE = cast<InitListExpr>(this);
     if (ILE->getType()->isArrayType()) {
       unsigned numInits = ILE->getNumInits();
       for (unsigned i = 0; i < numInits; i++) {
@@ -2851,7 +2828,7 @@
     return cast<ChooseExpr>(this)->getChosenSubExpr()
       ->isConstantInitializer(Ctx, IsForRef, Culprit);
   case UnaryOperatorClass: {
-    const UnaryOperator* Exp = cast<UnaryOperator>(this);
+    const auto* Exp = cast<UnaryOperator>(this);
     if (Exp->getOpcode() == UO_Extension)
       return Exp->getSubExpr()->isConstantInitializer(Ctx, false, Culprit);
     break;
@@ -2864,7 +2841,7 @@
   case CXXDynamicCastExprClass:
   case CXXReinterpretCastExprClass:
   case CXXConstCastExprClass: {
-    const CastExpr *CE = cast<CastExpr>(this);
+    const auto *CE = cast<CastExpr>(this);
 
     // Handle misc casts we want to ignore.
     if (CE->getCastKind() == CK_NoOp ||
@@ -2918,7 +2895,7 @@
         HasSideEffects = true;
     }
   };
-}
+} // anonymous namespace
 
 bool Expr::HasSideEffects(const ASTContext &Ctx,
                           bool IncludePossibleEffects) const {
@@ -3084,7 +3061,7 @@
 
   case CXXDynamicCastExprClass: {
     // A dynamic_cast expression has side-effects if it can throw.
-    const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(this);
+    const auto *DCE = cast<CXXDynamicCastExpr>(this);
     if (DCE->getTypeAsWritten()->isReferenceType() &&
         DCE->getCastKind() == CK_Dynamic)
       return true;
@@ -3102,7 +3079,7 @@
     if (!IncludePossibleEffects)
       break;
 
-    const CastExpr *CE = cast<CastExpr>(this);
+    const auto *CE = cast<CastExpr>(this);
     if (CE->getCastKind() == CK_LValueToRValue &&
         CE->getSubExpr()->getType().isVolatileQualified())
       return true;
@@ -3116,7 +3093,7 @@
 
   case CXXConstructExprClass:
   case CXXTemporaryObjectExprClass: {
-    const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
+    const auto *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
@@ -3125,7 +3102,7 @@
   }
 
   case LambdaExprClass: {
-    const LambdaExpr *LE = cast<LambdaExpr>(this);
+    const auto *LE = cast<LambdaExpr>(this);
     for (LambdaExpr::capture_iterator I = LE->capture_begin(),
                                       E = LE->capture_end(); I != E; ++I)
       if (I->getCaptureKind() == LCK_ByCopy)
@@ -3138,12 +3115,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);
+    const auto *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))
+      if (const auto *OVE = dyn_cast<OpaqueValueExpr>(Subexpr))
         Subexpr = OVE->getSourceExpr();
       if (Subexpr->HasSideEffects(Ctx, IncludePossibleEffects))
         return true;
@@ -3192,8 +3169,8 @@
     bool hasNonTrivialCall() const { return NonTrivial; }
 
     void VisitCallExpr(const CallExpr *E) {
-      if (const CXXMethodDecl *Method
-          = dyn_cast_or_null<const CXXMethodDecl>(E->getCalleeDecl())) {
+      if (const auto *Method
+          = dyn_cast_or_null<CXXMethodDecl>(E->getCalleeDecl())) {
         if (Method->isTrivial()) {
           // Recurse to children of the call.
           Inherited::VisitStmt(E);
@@ -3223,7 +3200,7 @@
       NonTrivial = true;
     }
   };
-}
+} // anonymous namespace
 
 bool Expr::hasNonTrivialCall(const ASTContext &Ctx) const {
   NonTrivialCallFinder Finder(Ctx);
@@ -3256,7 +3233,7 @@
   }
 
   // Strip off a cast to void*, if it exists. Except in C++.
-  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
+  if (const auto *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>()) {
@@ -3267,37 +3244,33 @@
           return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
       }
     }
-  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
+  } else if (const auto *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 (const auto *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 (const auto *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 (const auto *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 (const auto *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 (const auto *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 (const auto *M = dyn_cast<MaterializeTemporaryExpr>(this)) {
     return M->GetTemporaryExpr()->isNullPointerConstant(Ctx, NPC);
-  } else if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(this)) {
+  } else if (const auto *OVE = dyn_cast<OpaqueValueExpr>(this)) {
     if (const Expr *Source = OVE->getSourceExpr())
       return Source->isNullPointerConstant(Ctx, NPC);
   }
@@ -3309,9 +3282,9 @@
   if (const RecordType *UT = getType()->getAsUnionType())
     if (!Ctx.getLangOpts().CPlusPlus11 &&
         UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
-      if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){
+      if (const auto *CLE = dyn_cast<CompoundLiteralExpr>(this)){
         const Expr *InitExpr = CLE->getInitializer();
-        if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
+        if (const auto *ILE = dyn_cast<InitListExpr>(InitExpr))
           return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC);
       }
   // This expression must be an integer type.
@@ -3323,7 +3296,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);
+    const auto *Lit = dyn_cast<IntegerLiteral>(this);
     if (Lit && !Lit->getValue())
       return NPCK_ZeroLiteral;
     else if (!Ctx.getLangOpts().MSVCCompat || !isCXX98IntegralConstantExpr(Ctx))
@@ -3352,7 +3325,7 @@
             E->getObjectKind() == OK_ObjCProperty) &&
            "expression is not a property reference");
     E = E->IgnoreParenCasts();
-    if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
+    if (const auto *BO = dyn_cast<BinaryOperator>(E)) {
       if (BO->getOpcode() == BO_Comma) {
         E = BO->getRHS();
         continue;
@@ -3368,15 +3341,15 @@
 bool Expr::isObjCSelfExpr() const {
   const Expr *E = IgnoreParenImpCasts();
 
-  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
+  const auto *DRE = dyn_cast<DeclRefExpr>(E);
   if (!DRE)
     return false;
 
-  const ImplicitParamDecl *Param = dyn_cast<ImplicitParamDecl>(DRE->getDecl());
+  const auto *Param = dyn_cast<ImplicitParamDecl>(DRE->getDecl());
   if (!Param)
     return false;
 
-  const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(Param->getDeclContext());
+  const auto *M = dyn_cast<ObjCMethodDecl>(Param->getDeclContext());
   if (!M)
     return false;
 
@@ -3386,7 +3359,7 @@
 FieldDecl *Expr::getSourceBitField() {
   Expr *E = this->IgnoreParens();
 
-  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+  while (auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
     if (ICE->getCastKind() == CK_LValueToRValue ||
         (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp))
       E = ICE->getSubExpr()->IgnoreParens();
@@ -3394,22 +3367,22 @@
       break;
   }
 
-  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
-    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
+  if (auto *MemRef = dyn_cast<MemberExpr>(E))
+    if (auto *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
       if (Field->isBitField())
         return Field;
 
-  if (ObjCIvarRefExpr *IvarRef = dyn_cast<ObjCIvarRefExpr>(E))
-    if (FieldDecl *Ivar = dyn_cast<FieldDecl>(IvarRef->getDecl()))
+  if (auto *IvarRef = dyn_cast<ObjCIvarRefExpr>(E))
+    if (auto *Ivar = dyn_cast<FieldDecl>(IvarRef->getDecl()))
       if (Ivar->isBitField())
         return Ivar;
 
-  if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E))
-    if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
+  if (auto *DeclRef = dyn_cast<DeclRefExpr>(E))
+    if (auto *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
       if (Field->isBitField())
         return Field;
 
-  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) {
+  if (auto *BinOp = dyn_cast<BinaryOperator>(E)) {
     if (BinOp->isAssignmentOp() && BinOp->getLHS())
       return BinOp->getLHS()->getSourceBitField();
 
@@ -3417,7 +3390,7 @@
       return BinOp->getRHS()->getSourceBitField();
   }
 
-  if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E))
+  if (auto *UnOp = dyn_cast<UnaryOperator>(E))
     if (UnOp->isPrefix() && UnOp->isIncrementDecrementOp())
       return UnOp->getSubExpr()->getSourceBitField();
 
@@ -3427,7 +3400,7 @@
 bool Expr::refersToVectorElement() const {
   const Expr *E = this->IgnoreParens();
   
-  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+  while (const auto *ICE = dyn_cast<ImplicitCastExpr>(E)) {
     if (ICE->getValueKind() != VK_RValue &&
         ICE->getCastKind() == CK_NoOp)
       E = ICE->getSubExpr()->IgnoreParens();
@@ -3435,7 +3408,7 @@
       break;
   }
   
-  if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
+  if (const auto *ASE = dyn_cast<ArraySubscriptExpr>(E))
     return ASE->getBase()->getType()->isVectorType();
 
   if (isa<ExtVectorElementExpr>(E))
@@ -3447,7 +3420,7 @@
 bool Expr::refersToGlobalRegisterVar() const {
   const Expr *E = this->IgnoreParenImpCasts();
 
-  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
+  if (const auto *DRE = dyn_cast<DeclRefExpr>(E))
     if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
       if (VD->getStorageClass() == SC_Register &&
           VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
@@ -3711,7 +3684,7 @@
 }
 
 SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const {
-  DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);
+  auto *DIE = const_cast<DesignatedInitExpr*>(this);
   if (size() == 1)
     return DIE->getDesignator(0)->getSourceRange();
   return SourceRange(DIE->getDesignator(0)->getLocStart(),
@@ -3739,21 +3712,21 @@
 
 Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) const {
   assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
-  Stmt *const *SubExprs = reinterpret_cast<Stmt *const *>(this + 1);
+  auto SubExprs = reinterpret_cast<Stmt *const *>(this + 1);
   return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
 }
 
 Expr *DesignatedInitExpr::getArrayRangeStart(const Designator &D) const {
   assert(D.Kind == Designator::ArrayRangeDesignator &&
          "Requires array range designator");
-  Stmt *const *SubExprs = reinterpret_cast<Stmt *const *>(this + 1);
+  auto SubExprs = reinterpret_cast<Stmt *const *>(this + 1);
   return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
 }
 
 Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator &D) const {
   assert(D.Kind == Designator::ArrayRangeDesignator &&
          "Requires array range designator");
-  Stmt *const *SubExprs = reinterpret_cast<Stmt *const *>(this + 1);
+  auto SubExprs = reinterpret_cast<Stmt *const *>(this + 1);
   return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
 }
 
@@ -3774,7 +3747,7 @@
     return;
   }
 
-  Designator *NewDesignators
+  auto *NewDesignators
     = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
   std::copy(Designators, Designators + Idx, NewDesignators);
   std::copy(First, Last, NewDesignators + Idx);
@@ -3790,7 +3763,7 @@
          OK_Ordinary, false, false, false, false) {
   BaseAndUpdaterExprs[0] = baseExpr;
 
-  InitListExpr *ILE = new (C) InitListExpr(C, lBraceLoc, None, rBraceLoc);
+  auto *ILE = new (C) InitListExpr(C, lBraceLoc, None, rBraceLoc);
   ILE->setType(baseExpr->getType());
   BaseAndUpdaterExprs[1] = ILE;
 }
@@ -3825,12 +3798,12 @@
 }
 
 const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) {
-  if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e))
+  if (const auto *ewc = dyn_cast<ExprWithCleanups>(e))
     e = ewc->getSubExpr();
-  if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e))
+  if (const auto *m = dyn_cast<MaterializeTemporaryExpr>(e))
     e = m->GetTemporaryExpr();
   e = cast<CXXConstructExpr>(e)->getArg(0);
-  while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
+  while (const auto *ice = dyn_cast<ImplicitCastExpr>(e))
     e = ice->getSubExpr();
   return cast<OpaqueValueExpr>(e);
 }
@@ -3912,7 +3885,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 = dyn_cast<VariableArrayType>(
+    if (const auto *T = dyn_cast<VariableArrayType>(
                                    getArgumentType().getTypePtr()))
       return child_range(child_iterator(T), child_iterator());
     return child_range(child_iterator(), child_iterator());
@@ -3998,8 +3971,8 @@
     ++ArraySectionCount;
   }
   auto OriginalTy = Base->getType();
-  if (auto *DRE = dyn_cast<DeclRefExpr>(Base))
-    if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
+  if (const auto *DRE = dyn_cast<DeclRefExpr>(Base))
+    if (const auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
       OriginalTy = PVD->getOriginalType().getNonReferenceType();
 
   for (unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {
@@ -4012,4 +3985,3 @@
   }
   return OriginalTy;
 }
-