[Clang] Use autos in lib/AST/Expr.cpp

[Eugene.Zelenko]

Summary

Autos are also used for pointer variables assigned via casts or memory allocation. Patch includes other minor cleanups.

Build and regressions were fine on RHEL 6.

[aaron.ballman]

lib/AST/Expr.cpp

67

Again, I don't think it is an improvement when the deduced type is on a different line (here and elsewhere).

1956

Is this line still required? I thought InitExprs was already a vector of Stmt objects. I think it should be a const auto * instead of const auto & as well.

3715

Hmmm, I'm not certain this is an improvement. It lacks the information that SubExprs is a pointer to a pointer, and it lacks the constness information. I would revert this one (and the next two).

[Eugene.Zelenko]

lib/AST/Expr.cpp

1956

Will fix in commit.

3715

But all of this is mentioned in reinterpret_cast.

[aaron.ballman]

lib/AST/Expr.cpp

3715

It is, but our usual rule is to put the cv-qualifiers and &/* as part of the auto signature so that the type properties are easier to identify, which is what makes this one kind of challenging. Since Stmt is the same length as auto, I think leaving it as-is may be less confusing.

lib/AST/Expr.cpp

-//===--- Expr.cpp - Expression AST Node Implementation --------------------===//
+//===--- Expr.cpp - Expression AST Node Implementation ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
+
 using namespace clang;
 
 const CXXRecordDecl *Expr::getBestDynamicClassType() const {

   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);
 }

   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;

         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())) {

           }
         }
       }
-    } 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();

   // 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();

   
   // 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.

     }
   }
   
-  if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
+  if (const auto *CO = dyn_cast<ConditionalOperator>(E))
     return CO->getTrueExpr()->isKnownToHaveBooleanValue() &&
            CO->getFalseExpr()->isKnownToHaveBooleanValue();
   

                                 SourceLocation (Expr::*v)() const) {
     return static_cast<const E*>(expr)->getLocStart();
   }
-}
+} // anonymous namespace
 
 SourceLocation Expr::getExprLoc() const {
   switch (getStmtClass()) {

   //  (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()) &&

   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);

       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())

     }
     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())

     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();

 
     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.

       }
     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() ? '-' : '+');

     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 <<  ' ';

   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);

   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;

 
   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;

   }
 }
 
-
-
 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
 /// corresponds to, e.g. "sizeof" or "[pre]++".
 StringRef UnaryOperator::getOpcodeStr(Opcode Op) {

   }
 }
 
-
 //===----------------------------------------------------------------------===//
 // Postfix Operators.
 //===----------------------------------------------------------------------===//

 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;

 
   // 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];

   // 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;
 

     CalleeType = Expr::findBoundMemberType(Callee);
   }
 
-  const FunctionType *FnType = CalleeType->castAs<FunctionType>();
+  const auto *FnType = CalleeType->castAs<FunctionType>();
   return FnType->getReturnType();
 }
 

     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) {

     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

   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;
 }

   return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize);
 }
 
-
 CStyleCastExpr *CStyleCastExpr::Create(const ASTContext &C, QualType T,
                                        ExprValueKind VK, CastKind K, Expr *Op,
                                        const CXXCastPath *BasePath,

   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;

     return nullptr;
   }
 
-  Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
+  auto *Result = cast_or_null<Expr>(InitExprs[Init]);
   setInit(Init, expr);
   return Result;
 }

   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;
       }  

   return TheBlock->getBody();
 }
 
-
 //===----------------------------------------------------------------------===//
 // Generic Expression Routines
 //===----------------------------------------------------------------------===//

     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:

     return true;
   }
   case BinaryOperatorClass: {
-    const BinaryOperator *BO = cast<BinaryOperator>(this);
+    const auto *BO = cast<BinaryOperator>(this);
     switch (BO->getOpcode()) {
       default:
         break;

       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);

     // 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())

     // 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;

   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>();
 

   }
 
   case ObjCMessageExprClass: {
-    const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
+    const auto *ME = cast<ObjCMessageExpr>(this);
     if (Ctx.getLangOpts().ObjCAutoRefCount &&
         ME->isInstanceMessage() &&
         !ME->getType()->isVoidType() &&

     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()) ||

     // 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);
     }
 

   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 =
         if (!(DRE && isa<VarDecl>(DRE->getDecl()) &&
               cast<VarDecl>(DRE->getDecl())->hasLocalStorage())) {
           return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc,

       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 &&

   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();

     return false;
   }
   case MemberExprClass: {
-    const MemberExpr *M = cast<MemberExpr>(E);
+    const auto *M = cast<MemberExpr>(E);
     return M->getBase()->isOBJCGCCandidate(Ctx);
   }
   case ArraySubscriptExprClass:

   // (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());

 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;

   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;
     }      

 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;
     }

   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;
     }

   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) {

   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;
     }

 }
 
 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();
   }

   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();

       }
     }
 
-    if (SubstNonTypeTemplateParmExpr *NTTP
-                                  = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
+    if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
       E = NTTP->getReplacement();
       continue;
     }

 
 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);

 /// \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

   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;
 

   
   // 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 || 

       }
     }
     
-    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;
     }

     break;
   }
   
-  if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
+  if (const auto *This = dyn_cast<CXXThisExpr>(E))
     return This->isImplicit();
   
   return false;

 /// 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;

     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()) {

     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++) {

     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;

   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 ||

         HasSideEffects = true;
     }
   };
-}
+} // anonymous namespace
 
 bool Expr::HasSideEffects(const ASTContext &Ctx,
                           bool IncludePossibleEffects) const {

 
   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;

     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;

 
   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

   }
 
   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)

   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;

     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);

       NonTrivial = true;
     }
   };
-}
+} // anonymous namespace
 
 bool Expr::hasNonTrivialCall(const ASTContext &Ctx) const {
   NonTrivialCallFinder Finder(Ctx);

   }
 
   // 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>()) {

           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);
   }

   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.

     // 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))

             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;

 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;
 

 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();

       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();
 

       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();
 

 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();

       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))

 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())

 }
 
 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(),

 
 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));
 }
 

     return;
   }
 
-  Designator *NewDesignators
+  auto *NewDesignators
     = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
   std::copy(Designators, Designators + Idx, NewDesignators);
   std::copy(First, Last, NewDesignators + Idx);

          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;
 }

 }
 
 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);
 }

   // 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());

     ++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) {

   }
   return OriginalTy;
 }
-