[Clang] Fix Clang-tidy modernize-use-auto in some files in lib/AST; other minor cleanups.

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[hans]

Like the other patch, I'm not sure that using auto in all these places help readability.

[aaron.ballman]

In D14560#286819, @hans wrote:

Like the other patch, I'm not sure that using auto in all these places help readability.

I share these concerns.

[aaron.ballman]

lib/AST/ASTContext.cpp

3857

This one may be an improvement.

4366

Same with this one.

7930

This is... interesting. Explicitly defaulting an out-of-line function definition is not something I've ever encountered before. What benefit does this provide?

8519

Same question applies here.

lib/AST/ASTImporter.cpp

5326

This may be an improvement.

5348

Similar out-of-line question here.

lib/AST/CommentSema.cpp

268

This is an improvement.

304

As is this one.

357

Good catch on removing this one!

[Eugene.Zelenko]

I'm adept of consistency :-) It's also easier to fix all similar patterns in code then do such cleanups selectively. Actually, similar fixes were made recently in Decl.cpp when casts were involved, but not new.

lib/AST/ASTContext.cpp

7930

It's explicitly tells that destructor has default implementation.

[aaron.ballman]

lib/AST/ASTContext.cpp

7930

I'm not certain this is an improvement. Using =default in the declaration is an improvement because it tells the compiler up front "this has the default implementation" and the compiler can benefit from that information in other ways. When it's on an out-of-line definition, it does say "this has the default implementation", but it doesn't give the compiler any benefit over {}, so the only benefit is up to the reader of the code. I think someone can read {} to easily tell it is the default behavior, it is considerably shorter, and it doesn't cause anyone's eyes to trip over it wondering about the construct.

lib/AST/ASTContext.cpp

 
 comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC,
                                                     const Decl *D) const {
-  comments::DeclInfo *ThisDeclInfo = new (*this) comments::DeclInfo;
+  auto *ThisDeclInfo = new (*this) comments::DeclInfo;
   ThisDeclInfo->CommentDecl = D;
   ThisDeclInfo->IsFilled = false;
   ThisDeclInfo->fill();
   ThisDeclInfo->CommentDecl = FC->getDecl();
   if (!ThisDeclInfo->TemplateParameters)
     ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;
-  comments::FullComment *CFC =
+  auto *CFC =
     new (*this) comments::FullComment(FC->getBlocks(),
                                       ThisDeclInfo);
   return CFC;

 }
 
 void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
-  BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K);
+  auto *Ty = new (*this, TypeAlignment) BuiltinType(K);
   R = CanQualType::CreateUnsafe(QualType(Ty, 0));
   Types.push_back(Ty);
 }

     (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
   }
 
-  ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
+  auto *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
   ExtQualNodes.InsertNode(eq, insertPos);
   return QualType(eq, fastQuals);
 }

     ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
-  ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
+  auto *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
   Types.push_back(New);
   ComplexTypes.InsertNode(New, InsertPos);
   return QualType(New, 0);

     PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
-  PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical);
+  auto *New = new (*this, TypeAlignment) PointerType(T, Canonical);
   Types.push_back(New);
   PointerTypes.InsertNode(New, InsertPos);
   return QualType(New, 0);

       BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
-  BlockPointerType *New
+  auto *New
     = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
   Types.push_back(New);
   BlockPointerTypes.InsertNode(New, InsertPos);

     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
 
-  LValueReferenceType *New
+  auto *New
     = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
                                                      SpelledAsLValue);
   Types.push_back(New);

     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
 
-  RValueReferenceType *New
+  auto *New
     = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
   Types.push_back(New);
   RValueReferenceTypes.InsertNode(New, InsertPos);

       MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
-  MemberPointerType *New
+  auto *New
     = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
   Types.push_back(New);
   MemberPointerTypes.InsertNode(New, InsertPos);

     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
 
-  ConstantArrayType *New = new(*this,TypeAlignment)
+  auto *New = new(*this,TypeAlignment)
     ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals);
   ConstantArrayTypes.InsertNode(New, InsertPos);
   Types.push_back(New);

     Canon = getQualifiedType(Canon, canonSplit.Quals);
   }
   
-  VariableArrayType *New = new(*this, TypeAlignment)
+  auto *New = new(*this, TypeAlignment)
     VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);
 
   VariableArrayTypes.push_back(New);

   // initializer.  We do no canonicalization here at all, which is okay
   // because they can't be used in most locations.
   if (!numElements) {
-    DependentSizedArrayType *newType
+    auto *newType
       = new (*this, TypeAlignment)
           DependentSizedArrayType(*this, elementType, QualType(),
                                   numElements, ASM, elementTypeQuals,

 
   // Otherwise, we need to build a type which follows the spelling
   // of the element type.
-  DependentSizedArrayType *sugaredType
+  auto *sugaredType
     = new (*this, TypeAlignment)
         DependentSizedArrayType(*this, elementType, canon, numElements,
                                 ASM, elementTypeQuals, brackets);

     assert(!existing && "Shouldn't be in the map!"); (void) existing;
   }
 
-  IncompleteArrayType *newType = new (*this, TypeAlignment)
+  auto *newType = new (*this, TypeAlignment)
     IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);
 
   IncompleteArrayTypes.InsertNode(newType, insertPos);

     VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
-  VectorType *New = new (*this, TypeAlignment)
+  auto *New = new (*this, TypeAlignment)
     VectorType(vecType, NumElts, Canonical, VecKind);
   VectorTypes.InsertNode(New, InsertPos);
   Types.push_back(New);

     VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
-  ExtVectorType *New = new (*this, TypeAlignment)
+  auto *New = new (*this, TypeAlignment)
     ExtVectorType(vecType, NumElts, Canonical);
   VectorTypes.InsertNode(New, InsertPos);
   Types.push_back(New);

   }
 
   FunctionProtoType::ExtInfo newInfo = Info.withCallingConv(CallConv);
-  FunctionNoProtoType *New = new (*this, TypeAlignment)
+  auto *New = new (*this, TypeAlignment)
     FunctionNoProtoType(ResultTy, Canonical, newInfo);
   Types.push_back(New);
   FunctionNoProtoTypes.InsertNode(New, InsertPos);

 
   if (Canonical.isNull())
     Canonical = getCanonicalType(Decl->getUnderlyingType());
-  TypedefType *newType = new(*this, TypeAlignment)
+  auto *newType = new(*this, TypeAlignment)
     TypedefType(Type::Typedef, Decl, Canonical);
   Decl->TypeForDecl = newType;
   Types.push_back(newType);

     if (PrevDecl->TypeForDecl)
       return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 
 
-  RecordType *newType = new (*this, TypeAlignment) RecordType(Decl);
+  auto *newType = new (*this, TypeAlignment) RecordType(Decl);
   Decl->TypeForDecl = newType;
   Types.push_back(newType);
   return QualType(newType, 0);

     if (PrevDecl->TypeForDecl)
       return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 
 
-  EnumType *newType = new (*this, TypeAlignment) EnumType(Decl);
+  auto *newType = new (*this, TypeAlignment) EnumType(Decl);
   Decl->TypeForDecl = newType;
   Types.push_back(newType);
   return QualType(newType, 0);

     SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
   }
 
-  SubstTemplateTypeParmPackType *SubstParm
+  auto *SubstParm
     = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon,
                                                                ArgPack);
   Types.push_back(SubstParm);

                        sizeof(TemplateArgument) * NumArgs +
                        (IsTypeAlias? sizeof(QualType) : 0),
                        TypeAlignment);
-  TemplateSpecializationType *Spec
+  auto *Spec
     = new (Mem) TemplateSpecializationType(Template, Args, NumArgs, CanonType,
                                          IsTypeAlias ? Underlying : QualType());
 

   size += typeArgs.size() * sizeof(QualType);
   size += protocols.size() * sizeof(ObjCProtocolDecl *);
   void *mem = Allocate(size, TypeAlignment);
-  ObjCObjectTypeImpl *T =
+  auto *T =
     new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
                                  isKindOf);
 

 
   // No match.
   void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
-  ObjCObjectPointerType *QType =
-    new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
+  auto *QType = new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
 
   Types.push_back(QType);
   ObjCObjectPointerTypes.InsertNode(QType, InsertPos);

     Decl = Def;
   
   void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
-  ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl);
+  auto *T = new (Mem) ObjCInterfaceType(Decl);
   Decl->TypeForDecl = T;
   Types.push_back(T);
   return QualType(T, 0);

 /// on canonical types (which are always unique).
 QualType ASTContext::getTypeOfType(QualType tofType) const {
   QualType Canonical = getCanonicalType(tofType);
-  TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
+  auto *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
   Types.push_back(tot);
   return QualType(tot, 0);
 }

                                            QualType UnderlyingType,
                                            UnaryTransformType::UTTKind Kind)
     const {
-  UnaryTransformType *Ty =
+  auto *Ty =
     new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType, 
                                                    Kind,
                                  UnderlyingType->isDependentType() ?

   if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(AT, 0);
 
-  AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType,
-                                                     IsDecltypeAuto,
-                                                     IsDependent);
+  auto *AT = new (*this, TypeAlignment) AutoType(DeducedType,
   Types.push_back(AT);
   if (InsertPos)
     AutoTypes.InsertNode(AT, InsertPos);

     AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
     assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
   }
-  AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
+  auto *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
   Types.push_back(New);
   AtomicTypes.InsertNode(New, InsertPos);
   return QualType(New, 0);

       if (Arg.pack_size() == 0)
         return Arg;
       
-      TemplateArgument *CanonArgs
-        = new (*this) TemplateArgument[Arg.pack_size()];
+      auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
       unsigned Idx = 0;
       for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
                                         AEnd = Arg.pack_end();

 
   void *memory = Allocate(sizeof(OverloadedTemplateStorage) +
                           size * sizeof(FunctionTemplateDecl*));
-  OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size);
+  auto *OT = new(memory) OverloadedTemplateStorage(size);
 
   NamedDecl **Storage = OT->getStorage();
   for (UnresolvedSetIterator I = Begin; I != End; ++I) {

   }
 }
 
-ASTMutationListener::~ASTMutationListener() { }
+ASTMutationListener::~ASTMutationListener() = default;
 
 void ASTMutationListener::DeducedReturnType(const FunctionDecl *FD,
                                             QualType ReturnType) {}

   llvm_unreachable("Unsupported ABI");
 }
 
-CXXABI::~CXXABI() {}
+CXXABI::~CXXABI() = default;
 
 size_t ASTContext::getSideTableAllocatedMemory() const {
   return ASTRecordLayouts.getMemorySize() +

lib/AST/ASTImporter.cpp

 //  context into another context.
 //
 //===----------------------------------------------------------------------===//
+
 #include "clang/AST/ASTImporter.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"

     Expr *VisitMemberExpr(MemberExpr *E);
     Expr *VisitCallExpr(CallExpr *E);
   };
-}
+} // namespace clang
+
 using namespace clang;
 
 //----------------------------------------------------------------------------

       return C2.getDiagnostics().Report(Loc, DiagID);
     }
   };
-}
+} // anonymous namespace
 
 static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
                                      QualType T1, QualType T2);

                                   cast<UnresolvedUsingType>(T1)->getDecl(),
                                   cast<UnresolvedUsingType>(T2)->getDecl()))
       return false;
-      
     break;
 
   case Type::Attributed:

   if (T.isNull())
     return nullptr;
 
-  NamedDecl **NamedChain =
+  auto **NamedChain =
     new (Importer.getToContext())NamedDecl*[D->getChainingSize()];
 
   unsigned i = 0;

   Expr *ToCondition = Importer.Import(S->getCond());
   if (!ToCondition && S->getCond())
     return nullptr;
-  SwitchStmt *ToStmt = new (Importer.getToContext()) SwitchStmt(
+  auto *ToStmt = new (Importer.getToContext()) SwitchStmt(
                          Importer.getToContext(), ToConditionVariable,
                          ToCondition);
   Stmt *ToBody = Importer.Import(S->getBody());

     ToArgs[ai] = ToArg;
   }
 
-  Expr **ToArgs_Copied = new (Importer.getToContext()) 
-    Expr*[NumArgs];
+  auto **ToArgs_Copied = new (Importer.getToContext()) Expr*[NumArgs];
 
   for (unsigned ai = 0, ae = NumArgs; ai != ae; ++ai)
     ToArgs_Copied[ai] = ToArgs[ai];

     = ToContext.getTranslationUnitDecl();
 }
 
-ASTImporter::~ASTImporter() { }
+ASTImporter::~ASTImporter() = default;
 
 QualType ASTImporter::Import(QualType FromT) {
   if (FromT.isNull())

     ToID = ToSM.createFileID(std::move(ToBuf),
                              FromSLoc.getFile().getFileCharacteristic());
   }
-  
-  
   ImportedFileIDs[FromID] = ToID;
   return ToID;
 }

lib/AST/CommentSema.cpp

-//===--- CommentSema.cpp - Doxygen comment semantic analysis --------------===//
+//===--- CommentSema.cpp - Doxygen comment semantic analysis ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 
 namespace {
 #include "clang/AST/CommentHTMLTagsProperties.inc"
-} // unnamed namespace
+} // anonymous namespace
 
 Sema::Sema(llvm::BumpPtrAllocator &Allocator, const SourceManager &SourceMgr,
            DiagnosticsEngine &Diags, CommandTraits &Traits,

                                       SourceLocation LocEnd,
                                       unsigned CommandID,
                                       CommandMarkerKind CommandMarker) {
-  BlockCommandComment *BC = new (Allocator) BlockCommandComment(LocBegin, LocEnd,
-                                                                CommandID,
-                                                                CommandMarker);
+  auto *BC = new (Allocator) BlockCommandComment(LocBegin, LocEnd, CommandID,
+                                                 CommandMarker);
   checkContainerDecl(BC);
   return BC;
 }

                                       SourceLocation LocEnd,
                                       unsigned CommandID,
                                       CommandMarkerKind CommandMarker) {
-  ParamCommandComment *Command =
+  auto *Command =
       new (Allocator) ParamCommandComment(LocBegin, LocEnd, CommandID,
                                           CommandMarker);
 

     Command->setDirection(ParamCommandComment::In, /* Explicit = */ false);
   }
   typedef BlockCommandComment::Argument Argument;
-  Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
-                                                     ArgLocEnd),
-                                         Arg);
+  auto *A = new (Allocator) Argument(SourceRange(ArgLocBegin, ArgLocEnd), Arg);
   Command->setArgs(llvm::makeArrayRef(A, 1));
 }
 

                                       SourceLocation LocEnd,
                                       unsigned CommandID,
                                       CommandMarkerKind CommandMarker) {
-  TParamCommandComment *Command =
+  auto *Command =
       new (Allocator) TParamCommandComment(LocBegin, LocEnd, CommandID,
                                            CommandMarker);
 

   assert(Command->getNumArgs() == 0);
 
   typedef BlockCommandComment::Argument Argument;
-  Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
-                                                     ArgLocEnd),
-                                         Arg);
+  auto *A = new (Allocator) Argument(SourceRange(ArgLocBegin, ArgLocEnd), Arg);
   Command->setArgs(llvm::makeArrayRef(A, 1));
 
   if (!isTemplateOrSpecialization()) {

       << CorrectedName
       << FixItHint::CreateReplacement(ArgRange, CorrectedName);
   }
-
-  return;
 }
 
 void Sema::actOnTParamCommandFinish(TParamCommandComment *Command,

                                                SourceLocation ArgLocEnd,
                                                StringRef Arg) {
   typedef InlineCommandComment::Argument Argument;
-  Argument *A = new (Allocator) Argument(SourceRange(ArgLocBegin,
-                                                     ArgLocEnd),
-                                         Arg);
+  auto *A = new (Allocator) Argument(SourceRange(ArgLocBegin, ArgLocEnd), Arg);
   StringRef CommandName = Traits.getCommandInfo(CommandID)->Name;
 
   return new (Allocator) InlineCommandComment(

                                              unsigned CommandID,
                                              SourceLocation TextBegin,
                                              StringRef Text) {
-  VerbatimLineComment *VL = new (Allocator) VerbatimLineComment(
+  auto *VL = new (Allocator) VerbatimLineComment(
                               LocBegin,
                               TextBegin.getLocWithOffset(Text.size()),
                               CommandID,

 HTMLEndTagComment *Sema::actOnHTMLEndTag(SourceLocation LocBegin,
                                          SourceLocation LocEnd,
                                          StringRef TagName) {
-  HTMLEndTagComment *HET =
-      new (Allocator) HTMLEndTagComment(LocBegin, LocEnd, TagName);
+  auto *HET = new (Allocator) HTMLEndTagComment(LocBegin, LocEnd, TagName);
   if (isHTMLEndTagForbidden(TagName)) {
     Diag(HET->getLocation(), diag::warn_doc_html_end_forbidden)
       << TagName << HET->getSourceRange();

 
 FullComment *Sema::actOnFullComment(
                               ArrayRef<BlockContentComment *> Blocks) {
-  FullComment *FC = new (Allocator) FullComment(Blocks, ThisDeclInfo);
+  auto *FC = new (Allocator) FullComment(Blocks, ThisDeclInfo);
   resolveParamCommandIndexes(FC);
 
   // Complain about HTML tags that are not closed.

     BestIndex = CurrIndex;
   }
 }
-} // unnamed namespace
+} // anonymous namespace
 
 unsigned Sema::correctTypoInParmVarReference(
                                     StringRef Typo,

   }
   return false;
 }
-} // unnamed namespace
+} // anonymous namespace
 
 bool Sema::resolveTParamReference(
                             StringRef Name,

                                          Corrector);
   }
 }
-} // unnamed namespace
+} // anonymous namespace
 
 StringRef Sema::correctTypoInTParamReference(
                             StringRef Typo,

 
 } // end namespace comments
 } // end namespace clang
-

lib/AST/Decl.cpp

-//===--- Decl.cpp - Declaration AST Node Implementation -------------------===//
+//===--- Decl.cpp - Declaration AST Node Implementation ---------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

   if (!isExternallyVisible(classLV.getLinkage()))
     return LinkageInfo::none();
 
-
   // Otherwise, don't merge in classLV yet, because in certain cases
   // we need to completely ignore the visibility from it.
 

                   OuterMostLambda->getDeclContext()->getRedeclContext(),
                   OuterMostLambda->getLambdaContextDecl(), computation);
       }
-      
       break;
     }
   }

     return LV;
   }
 };
-}
+} // namespace clang
 
 static LinkageInfo getLVForDecl(const NamedDecl *D,
                                 LVComputationKind computation) {

   }
 }
 
-} // namespace
+} // anonymous namespace
 
 SourceRange DeclaratorDecl::getSourceRange() const {
   SourceLocation RangeEnd = getLocation();

 void DestroyAPValue(void* UntypedValue) {
   static_cast<APValue*>(UntypedValue)->~APValue();
 }
-} // namespace
+} // anonymous namespace
 
 APValue *VarDecl::evaluateValue(
     SmallVectorImpl<PartialDiagnosticAt> &Notes) const {

   return BuiltinID;
 }
 
-
 /// getNumParams - Return the number of parameters this function must have
 /// based on its FunctionType.  This is the length of the ParamInfo array
 /// after it has been created.

   assert(DeclsInPrototypeScope.empty() && "Already has prototype decls!");
 
   if (!NewDecls.empty()) {
-    NamedDecl **A = new (getASTContext()) NamedDecl*[NewDecls.size()];
+    auto **A = new (getASTContext()) NamedDecl*[NewDecls.size()];
     std::copy(NewDecls.begin(), NewDecls.end(), A);
     DeclsInPrototypeScope = llvm::makeArrayRef(A, NewDecls.size());
     // Move declarations introduced in prototype to the function context.

                                                TemplateSpecializationKind TSK) {
   assert(TemplateOrSpecialization.isNull() && 
          "Member function is already a specialization");
-  MemberSpecializationInfo *Info 
-    = new (C) MemberSpecializationInfo(FD, TSK);
+  auto *Info = new (C) MemberSpecializationInfo(FD, TSK);
   TemplateOrSpecialization = Info;
 }
 

   IsBeingDefined = true;
 
   if (auto *D = dyn_cast<CXXRecordDecl>(this)) {
-    struct CXXRecordDecl::DefinitionData *Data =
-      new (getASTContext()) struct CXXRecordDecl::DefinitionData(D);
+    auto *Data = new (getASTContext()) struct CXXRecordDecl::DefinitionData(D);
     for (auto I : redecls())
       cast<CXXRecordDecl>(I)->DefinitionData = Data;
   }

 }
 
 EnumDecl *EnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  EnumDecl *Enum =
+  auto *Enum =
       new (C, ID) EnumDecl(C, nullptr, SourceLocation(), SourceLocation(),
                            nullptr, nullptr, false, false, false);
   Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules;

 RecordDecl *RecordDecl::Create(const ASTContext &C, TagKind TK, DeclContext *DC,
                                SourceLocation StartLoc, SourceLocation IdLoc,
                                IdentifierInfo *Id, RecordDecl* PrevDecl) {
-  RecordDecl *R = new (C, DC) RecordDecl(Record, TK, C, DC,
-                                         StartLoc, IdLoc, Id, PrevDecl);
+  auto *R = new (C, DC) RecordDecl(Record, TK, C, DC, StartLoc, IdLoc, Id,
+                                   PrevDecl);
   R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
 
   C.getTypeDeclType(R, PrevDecl);

 }
 
 RecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
-  RecordDecl *R =
+  auto *R =
       new (C, ID) RecordDecl(Record, TTK_Struct, C, nullptr, SourceLocation(),
                              SourceLocation(), nullptr, nullptr);
   R->MayHaveOutOfDateDef = C.getLangOpts().Modules;

   return nullptr;
 }
 
-
 //===----------------------------------------------------------------------===//
 // BlockDecl Implementation
 //===----------------------------------------------------------------------===//

 }
 
 void LabelDecl::setMSAsmLabel(StringRef Name) {
-  char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
+  auto *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
   memcpy(Buffer, Name.data(), Name.size());
   Buffer[Name.size()] = '\0';
   MSAsmName = Buffer;

                                    bool isInlineSpecified,
                                    bool hasWrittenPrototype,
                                    bool isConstexprSpecified) {
-  FunctionDecl *New =
+  auto *New =
       new (C, DC) FunctionDecl(Function, C, DC, StartLoc, NameInfo, T, TInfo,
                                SC, isInlineSpecified, isConstexprSpecified);
   New->HasWrittenPrototype = hasWrittenPrototype;

                                        SourceLocation StartLoc,
                                        Module *Imported,
                                        SourceLocation EndLoc) {
-  ImportDecl *Import = new (C, DC, additionalSizeToAlloc<SourceLocation>(1))
+  auto *Import = new (C, DC, additionalSizeToAlloc<SourceLocation>(1))
       ImportDecl(DC, StartLoc, Imported, EndLoc);
   Import->setImplicit();
   return Import;

lib/AST/DeclBase.cpp

-//===--- DeclBase.cpp - Declaration AST Node Implementation ---------------===//
+//===--- DeclBase.cpp - Declaration AST Node Implementation -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+
 using namespace clang;
 
 //===----------------------------------------------------------------------===//

   return nullptr;
 }
 
-
 //===----------------------------------------------------------------------===//
 // PrettyStackTraceDecl Implementation
 //===----------------------------------------------------------------------===//

 //===----------------------------------------------------------------------===//
 
 // Out-of-line virtual method providing a home for Decl.
-Decl::~Decl() { }
+Decl::~Decl() = default;
 
 void Decl::setDeclContext(DeclContext *DC) {
   DeclCtx = DC;

   if (SemaDC == LexicalDC) {
     DeclCtx = SemaDC;
   } else {
-    Decl::MultipleDC *MDC = new (Ctx) Decl::MultipleDC();
+    auto *MDC = new (Ctx) Decl::MultipleDC();
     MDC->SemanticDC = SemaDC;
     MDC->LexicalDC = LexicalDC;
     DeclCtx = MDC;

   return Ty->getAs<FunctionType>();
 }
 
-
 /// Starting at a given context (a Decl or DeclContext), look for a
 /// code context that is not a closure (a lambda, block, etc.).
 template <class T> static Decl *getNonClosureContext(T *D) {

   }
 }
 
-DeclContext::~DeclContext() { }
+DeclContext::~DeclContext() = default;
 
 /// \brief Find the parent context of this context that will be
 /// used for unqualified name lookup.

   if (PDiag.hasStorage())
     DiagStorage = new (C) PartialDiagnostic::Storage;
   
-  DependentDiagnostic *DD = new (C) DependentDiagnostic(PDiag, DiagStorage);
+  auto *DD = new (C) DependentDiagnostic(PDiag, DiagStorage);
 
   // TODO: Maybe we shouldn't reverse the order during insertion.
   DD->NextDiagnostic = Map->FirstDiagnostic;

lib/AST/DeclTemplate.cpp

 #include "clang/Basic/IdentifierTable.h"
 #include "llvm/ADT/STLExtras.h"
 #include <memory>
+
 using namespace clang;
 
 //===----------------------------------------------------------------------===//

           NumRequiredArgs += NTTP->getNumExpansionTypes();
           continue;
         }
-      
       break;
     }
   

 void *allocateDefaultArgStorageChain(const ASTContext &C) {
   return new (C) char[sizeof(void*) * 2];
 }
-}
+} // namespace clang
 
 //===----------------------------------------------------------------------===//
 // RedeclarableTemplateDecl Implementation

 
 RedeclarableTemplateDecl::CommonBase *
 FunctionTemplateDecl::newCommon(ASTContext &C) const {
-  Common *CommonPtr = new (C) Common;
+  auto *CommonPtr = new (C) Common;
   C.AddDeallocation(DeallocateCommon, CommonPtr);
   return CommonPtr;
 }

                                              NamedDecl *Decl,
                                              ClassTemplateDecl *PrevDecl) {
   AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
-  ClassTemplateDecl *New = new (C, DC) ClassTemplateDecl(C, DC, L, Name,
-                                                         Params, Decl);
+  auto *New = new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl);
   New->setPreviousDecl(PrevDecl);
   return New;
 }

 
 RedeclarableTemplateDecl::CommonBase *
 ClassTemplateDecl::newCommon(ASTContext &C) const {
-  Common *CommonPtr = new (C) Common;
+  auto *CommonPtr = new (C) Common;
   C.AddDeallocation(DeallocateCommon, CommonPtr);
   return CommonPtr;
 }

                              SourceLocation KeyLoc, SourceLocation NameLoc,
                              unsigned D, unsigned P, IdentifierInfo *Id,
                              bool Typename, bool ParameterPack) {
-  TemplateTypeParmDecl *TTPDecl =
+  auto *TTPDecl =
     new (C, DC) TemplateTypeParmDecl(DC, KeyLoc, NameLoc, Id, Typename);
   QualType TTPType = C.getTemplateTypeParmType(D, P, ParameterPack, TTPDecl);
   TTPDecl->setTypeForDecl(TTPType.getTypePtr());

                                         const TemplateArgument *Args,
                                         unsigned NumArgs,
                                    ClassTemplateSpecializationDecl *PrevDecl) {
-  ClassTemplateSpecializationDecl *Result =
+  auto *Result =
       new (Context, DC) ClassTemplateSpecializationDecl(
           Context, ClassTemplateSpecialization, TK, DC, StartLoc, IdLoc,
           SpecializedTemplate, Args, NumArgs, PrevDecl);

 ClassTemplateSpecializationDecl *
 ClassTemplateSpecializationDecl::CreateDeserialized(ASTContext &C,
                                                     unsigned ID) {
-  ClassTemplateSpecializationDecl *Result =
+  auto *Result =
     new (C, ID) ClassTemplateSpecializationDecl(C, ClassTemplateSpecialization);
   Result->MayHaveOutOfDateDef = false;
   return Result;

   const ASTTemplateArgumentListInfo *ASTArgInfos =
     ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
 
-  ClassTemplatePartialSpecializationDecl *Result = new (Context, DC)
+  auto *Result = new (Context, DC)
       ClassTemplatePartialSpecializationDecl(Context, TK, DC, StartLoc, IdLoc,
                                              Params, SpecializedTemplate, Args,
                                              NumArgs, ASTArgInfos, PrevDecl);

 ClassTemplatePartialSpecializationDecl *
 ClassTemplatePartialSpecializationDecl::CreateDeserialized(ASTContext &C,
                                                            unsigned ID) {
-  ClassTemplatePartialSpecializationDecl *Result =
-      new (C, ID) ClassTemplatePartialSpecializationDecl(C);
+  auto *Result = new (C, ID) ClassTemplatePartialSpecializationDecl(C);
   Result->MayHaveOutOfDateDef = false;
   return Result;
 }

 }
 RedeclarableTemplateDecl::CommonBase *
 TypeAliasTemplateDecl::newCommon(ASTContext &C) const {
-  Common *CommonPtr = new (C) Common;
+  auto *CommonPtr = new (C) Common;
   C.AddDeallocation(DeallocateCommon, CommonPtr);
   return CommonPtr;
 }

 
 RedeclarableTemplateDecl::CommonBase *
 VarTemplateDecl::newCommon(ASTContext &C) const {
-  Common *CommonPtr = new (C) Common;
+  auto *CommonPtr = new (C) Common;
   C.AddDeallocation(DeallocateCommon, CommonPtr);
   return CommonPtr;
 }

   const ASTTemplateArgumentListInfo *ASTArgInfos
     = ASTTemplateArgumentListInfo::Create(Context, ArgInfos);
 
-  VarTemplatePartialSpecializationDecl *Result =
+  auto *Result =
       new (Context, DC) VarTemplatePartialSpecializationDecl(
           Context, DC, StartLoc, IdLoc, Params, SpecializedTemplate, T, TInfo,
           S, Args, NumArgs, ASTArgInfos);

lib/AST/DeclarationName.cpp

 // classes.
 //
 //===----------------------------------------------------------------------===//
+
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclarationName.h"

 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
+
 using namespace clang;
 
 namespace clang {

   if (CXXSpecialName *Name = SpecialNames->FindNodeOrInsertPos(ID, InsertPos))
     return DeclarationName(Name);
 
-  CXXSpecialName *SpecialName = new (Ctx) CXXSpecialName;
+  auto *SpecialName = new (Ctx) CXXSpecialName;
   SpecialName->ExtraKindOrNumArgs = EKind;
   SpecialName->Type = Ty;
   SpecialName->FETokenInfo = nullptr;

                                LiteralNames->FindNodeOrInsertPos(ID, InsertPos))
     return DeclarationName (Name);
   
-  CXXLiteralOperatorIdName *LiteralName = new (Ctx) CXXLiteralOperatorIdName;
+  auto *LiteralName = new (Ctx) CXXLiteralOperatorIdName;
   LiteralName->ExtraKindOrNumArgs = DeclarationNameExtra::CXXLiteralOperator;
   LiteralName->ID = II;
   LiteralName->FETokenInfo = nullptr;

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 {

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

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

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

   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 TheBlock->getBody();
 }
 
-
 //===----------------------------------------------------------------------===//
 // Generic Expression Routines
 //===----------------------------------------------------------------------===//

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

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

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

   }
   return OriginalTy;
 }
-