[Clang] Use range loops and autos in lib/Serialization/ASTReader.cpp

[Eugene.Zelenko]

Summary

I fixed Clang-tidy modernize-loop-convert. Autos are used for pointer variables assigned via casts. Patch includes other minor cleanups.

Build and regressions were finr on RHEL 6.

[hans]

lib/Serialization/ASTReader.cpp

3390

for (Module *Exported : Exports)

would be much easier to read. (And having Exported by a reference to a pointer seems odd.)

3512

Using a range-based for loop here is very nice, but again I'm not sure the "auto" is helping.

for (const auto &ImportedModule : ...

would be easier to read, I think.

3570

Same thing.

4306

I'd say "bool" is a better choice here.

5104

I'd spell out ModuleIterator instead of auto here.

6860

Maybe:

for (const ModuleFile &MF : ModuleMgr)

6867

Same here.

7220

Does this fit on one line now?

7854

bool seems better than auto for these (well, not AS I suppose).

[aaron.ballman]

lib/Serialization/ASTReader.cpp

3390

for (Module *Exported : Exports)
would be much easier to read. (And having Exported by a reference to a pointer seems odd.)

I would also find: for (const auto *Exported : Exports) to be fine, but definitely agree with Hans that const auto & isn't what we want here.

3512

Using a range-based for loop here is very nice, but again I'm not sure the "auto" is helping.

for (const auto &ImportedModule : ...
would be easier to read, I think.

I think const auto &M is reasonable (it fits with our usual naming conventions), but wouldn't complain if there were a more descriptive name used.

4306

I'd say "bool" is a better choice here.

Agreed.

5074

If auto doesn't shorten this sufficiently to fit on a single line, I think I slightly prefer HeaderFileInfoLookupTable. It's easier to figure out what Table is without having to go to another line in the source file to find out.

5104

I'd spell out ModuleIterator instead of auto here.

I don't see a reason to do that, but I also don't like that this appears to be doing a copy. Is ModuleIterator a pointer? If so, this should be const auto *I instead. If not, const auto &.

6860

Maybe:

for (const ModuleFile &MF : ModuleMgr)

I don't think that naming the type adds benefit for range-based for loop iteration variables unless the type is really obscure. We don't name the types in the vast majority of places in the code base from what I can tell.

7220

Does this fit on one line now?

If it does not, I don't think auto is the correct type specifier to use here.

[Eugene.Zelenko]

I fixed two loops and don't use auto instead of bool.

Auto is also used for results of new.

[Eugene.Zelenko]

lib/Serialization/ASTReader.cpp

5074

I don't think it's good idea to make coding practices depending on formatting.

[aaron.ballman]

lib/Serialization/ASTReader.cpp

5074

I don't think it's good idea to make coding practices depending on formatting.

I disagree. The use of auto is only when it adds to readability of the code. We've distilled this down to cases where the type is obvious due to already being stated in the initialization of the variable. If that initialization means I have to look somewhere else to see the actual type, then the benefit of auto is reduced.

lib/Serialization/ASTReader.cpp

-//===-- ASTReader.cpp - AST File Reader ----------------------------------===//
+//===-- ASTReader.cpp - AST File Reader -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 using namespace clang::serialization::reader;
 using llvm::BitstreamCursor;
 
-
 //===----------------------------------------------------------------------===//
 // ChainedASTReaderListener implementation
 //===----------------------------------------------------------------------===//

     MacroDefinitionsMap;
   typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> >
     DeclsMap;
-}
+} // anonymous namespace
 
 static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
                                          DiagnosticsEngine &Diags,

   OwnsDeserializationListener = TakeOwnership;
 }
 
-
-
 unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
   return serialization::ComputeHash(Sel);
 }
 
-
 std::pair<unsigned, unsigned>
 ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
   using namespace llvm::support;

       FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
     FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
                                         ID, BaseOffset + Record[0]);
-    SrcMgr::FileInfo &FileInfo =
+    auto &FileInfo =
           const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
     FileInfo.NumCreatedFIDs = Record[5];
     if (Record[3])

         PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
         PreprocessingRecord::PPEntityID PPID =
             PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
-        MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
+        auto *PPDef = cast_or_null<MacroDefinitionRecord>(
             PPRec.getPreprocessedEntity(PPID));
         if (PPDef)
           PPRec.RegisterMacroDefinition(Macro, PPDef);

     // files.
     IdentifierInfo *getIdentifierInfo() const { return Found; }
   };
-}
+} // anonymous namespace
 
 void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
   // Note that we are loading an identifier.

     D->Hidden = false;
 
     if (wasHidden && SemaObj) {
-      if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
+      if (auto *Method = dyn_cast<ObjCMethodDecl>(D)) {
         moveMethodToBackOfGlobalList(*SemaObj, Method);
       }
     }

     // Push any exported modules onto the stack to be marked as visible.
     SmallVector<Module *, 16> Exports;
     Mod->getExportedModules(Exports);
-    for (SmallVectorImpl<Module *>::iterator
-           I = Exports.begin(), E = Exports.end(); I != E; ++I) {
-      Module *Exported = *I;
+    for (auto *Exported : Exports) {
       if (Visited.insert(Exported).second)
         Stack.push_back(Exported);
     }

   // Here comes stuff that we only do once the entire chain is loaded.
 
   // Load the AST blocks of all of the modules that we loaded.
-  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
-                                              MEnd = Loaded.end();
-       M != MEnd; ++M) {
-    ModuleFile &F = *M->Mod;
+  for (const auto &ImportedModule : Loaded) {
+    ModuleFile &F = *ImportedModule.Mod;
 
     // Read the AST block.
     if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))

     // Preload all the pending interesting identifiers by marking them out of
     // date.
     for (auto Offset : F.PreloadIdentifierOffsets) {
-      const unsigned char *Data = reinterpret_cast<const unsigned char *>(
+      auto *Data = reinterpret_cast<const unsigned char *>(
           F.IdentifierTableData + Offset);
 
       ASTIdentifierLookupTrait Trait(*this, F);

 
   // Setup the import locations and notify the module manager that we've
   // committed to these module files.
-  for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
-                                              MEnd = Loaded.end();
-       M != MEnd; ++M) {
-    ModuleFile &F = *M->Mod;
+  for (const auto &M : Loaded) {
+    ModuleFile &F = *M.Mod;
 
     ModuleMgr.moduleFileAccepted(&F);
 
     // Set the import location.
     F.DirectImportLoc = ImportLoc;
-    if (!M->ImportedBy)
-      F.ImportLoc = M->ImportLoc;
+    if (!M.ImportedBy)
+      F.ImportLoc = M.ImportLoc;
     else
-      F.ImportLoc = ReadSourceLocation(*M->ImportedBy,
-                                       M->ImportLoc.getRawEncoding());
+      F.ImportLoc = ReadSourceLocation(*M.ImportedBy,
+                                       M.ImportLoc.getRawEncoding());
   }
 
   if (!Context.getLangOpts().CPlusPlus ||

     // For C++ modules, we don't need information on many identifiers (just
     // those that provide macros or are poisoned), so we mark all of
     // the interesting ones via PreloadIdentifierOffsets.
-    for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
-                                IdEnd = PP.getIdentifierTable().end();
-         Id != IdEnd; ++Id)
-      Id->second->setOutOfDate(true);
+    for (auto &Id : PP.getIdentifierTable())
+      Id.second->setOutOfDate(true);
   }
   
   // Resolve any unresolved module exports.

                                       SuggestedPredefines, ExistingLangOpts);
     }
   };
-}
+} // anonymous namespace
 
 bool ASTReader::readASTFileControlBlock(
     StringRef Filename, FileManager &FileMgr,

   // Include entries.
   for (unsigned N = Record[Idx++]; N; --N) {
     std::string Path = ReadString(Record, Idx);
-    frontend::IncludeDirGroup Group
-      = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
+    auto Group = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
     bool IsFramework = Record[Idx++];
     bool IgnoreSysRoot = Record[Idx++];
     HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,

     // Decode the identifier info and then check again; if the macro is
     // still defined and associated with the identifier,
     IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
-    MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
+    auto *MD = new (PPRec) MacroDefinitionRecord(II, Range);
 
     if (DeserializationListener)
       DeserializationListener->MacroDefinitionRead(PPID, MD);

       File = PP.getFileManager().getFile(FullFileName);
     
     // FIXME: Stable encoding
-    InclusionDirective::InclusionKind Kind
-      = static_cast<InclusionDirective::InclusionKind>(Record[2]);
-    InclusionDirective *ID
+    auto Kind = static_cast<InclusionDirective::InclusionKind>(Record[2]);
+    auto *ID
       = new (PPRec) InclusionDirective(PPRec, Kind,
                                        StringRef(Blob.data(), Record[0]),
                                        Record[1], Record[3],

   }
 };
 
-}
+} // anonymous namespace
 
 PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
                                                        bool EndsAfter) const {

       : FE(FE) { }
 
     bool operator()(ModuleFile &M) {
-      HeaderFileInfoLookupTable *Table
+      auto *Table
         = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
       if (!Table)
         return false;

     
     Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
   };
-}
+} // anonymous namespace
 
 HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
   HeaderFileInfoVisitor Visitor(FE);

 void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
   // FIXME: Make it work properly with modules.
   SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates;
-  for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
-    ModuleFile &F = *(*I);
+  for (const auto &I : ModuleMgr) {
+    ModuleFile &F = *I;
     unsigned Idx = 0;
     DiagStates.clear();
     assert(!Diag.DiagStates.empty());

     }
     QualType modifiedType = readType(*Loc.F, Record, Idx);
     QualType equivalentType = readType(*Loc.F, Record, Idx);
-    AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
+    auto kind = static_cast<AttributedType::Kind>(Record[2]);
     return Context.getAttributedType(kind, modifiedType, equivalentType);
   }
 

                                   SmallVectorImpl<QualType> &Exceptions,
                                   FunctionProtoType::ExceptionSpecInfo &ESI,
                                   const RecordData &Record, unsigned &Idx) {
-  ExceptionSpecificationType EST =
-      static_cast<ExceptionSpecificationType>(Record[Idx++]);
+  auto EST = static_cast<ExceptionSpecificationType>(Record[Idx++]);
   ESI.Type = EST;
   if (EST == EST_Dynamic) {
     for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)

     case PREDEF_TYPE_AUTO_DEDUCT:
       T = Context.getAutoDeductType();
       break;
-
     case PREDEF_TYPE_AUTO_RREF_DEDUCT:
       T = Context.getAutoRRefDeductType();
       break;
-
     case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
       T = Context.ARCUnbridgedCastTy;
       break;
-
     case PREDEF_TYPE_BUILTIN_FN:
       T = Context.BuiltinFnTy;
       break;
-
     case PREDEF_TYPE_OMP_ARRAY_SECTION:
       T = Context.OMPArraySectionTy;
       break;

   unsigned Idx = 0;
   unsigned NumBases = Record[Idx++];
   void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
-  CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
+  auto *Bases = new (Mem) CXXBaseSpecifier [NumBases];
   for (unsigned I = 0; I != NumBases; ++I)
     Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
   return Bases;

   }
 };
 
-}
+} // anonymous namespace
 
 void ASTReader::FindFileRegionDecls(FileID File,
                                     unsigned Offset, unsigned Length,

   // Load the list of declarations.
   SmallVector<NamedDecl *, 64> Decls;
   for (DeclID ID : It->second.Table.find(Name)) {
-    NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
+    auto *ND = cast<NamedDecl>(GetDecl(ID));
     if (ND->getDeclName() == Name)
       Decls.push_back(ND);
   }

   DeclsMap Decls;
 
   for (DeclID ID : It->second.Table.findAll()) {
-    NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
+    auto *ND = cast<NamedDecl>(GetDecl(ID));
     Decls[ND->getDeclName()].push_back(ND);
   }
 

 }
 
 void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
-  if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
+  if (auto *ImplD = dyn_cast<ObjCImplDecl>(D))
     PassObjCImplDeclToConsumer(ImplD, Consumer);
   else
     Consumer->HandleInterestingDecl(DeclGroupRef(D));

                   GlobalPreprocessedEntityMap);
   
   llvm::errs() << "\n*** PCH/Modules Loaded:";
-  for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 
-                                       MEnd = ModuleMgr.end();
-       M != MEnd; ++M)
-    (*M)->dump();
+  for (const auto M : ModuleMgr)
+    M->dump();
 }
 
 /// Return the amount of memory used by memory buffers, breaking down
 /// by heap-backed versus mmap'ed memory.
 void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
-  for (ModuleConstIterator I = ModuleMgr.begin(),
-      E = ModuleMgr.end(); I != E; ++I) {
-    if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
+  for (const auto I : ModuleMgr) {
+    if (llvm::MemoryBuffer *buf = I->Buffer.get()) {
       size_t bytes = buf->getBufferSize();
       switch (buf->getBufferKind()) {
         case llvm::MemoryBuffer::MemoryBuffer_Malloc:

   // Makes sure any declarations that were deserialized "too early"
   // still get added to the identifier's declaration chains.
   for (uint64_t ID : PreloadedDeclIDs) {
-    NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
+    auto *D = cast<NamedDecl>(GetDecl(ID));
     pushExternalDeclIntoScope(D, D->getDeclName());
   }
   PreloadedDeclIDs.clear();

 
     StringRef Next() override;
   };
-}
+} // namespace clang
 
 ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
   : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {

   return new ASTIdentifierIterator(*this);
 }
 
-namespace clang { namespace serialization {
+namespace clang {
+namespace serialization {
   class ReadMethodPoolVisitor {
     ASTReader &Reader;
     Selector Sel;

     }
     bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
   };
-} } // end namespace clang::serialization
+} // end namespace serialization
+} // end namespace clang
 
 /// \brief Add the given set of methods to the method list.
 static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,

   Namespaces.clear();
   
   for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
-    if (NamespaceDecl *Namespace 
+    if (auto *Namespace 
                 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
       Namespaces.push_back(Namespace);
   }

 void ASTReader::ReadUndefinedButUsed(
                         llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined) {
   for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
-    NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
+    auto *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
     SourceLocation Loc =
         SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
     Undefined.insert(std::make_pair(D, Loc));

     FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
                                                      Exprs) {
   for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
-    FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
+    auto *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
     uint64_t Count = DelayedDeleteExprs[Idx++];
     for (uint64_t C = 0; C < Count; ++C) {
       SourceLocation DeleteLoc =

 void ASTReader::ReadTentativeDefinitions(
                   SmallVectorImpl<VarDecl *> &TentativeDefs) {
   for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
-    VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
+    auto *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
     if (Var)
       TentativeDefs.push_back(Var);
   }

 void ASTReader::ReadUnusedFileScopedDecls(
                                SmallVectorImpl<const DeclaratorDecl *> &Decls) {
   for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
-    DeclaratorDecl *D
+    auto *D
       = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
     if (D)
       Decls.push_back(D);

 void ASTReader::ReadDelegatingConstructors(
                                  SmallVectorImpl<CXXConstructorDecl *> &Decls) {
   for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
-    CXXConstructorDecl *D
+    auto *D
       = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
     if (D)
       Decls.push_back(D);

 
 void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
   for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
-    TypedefNameDecl *D
+    auto *D
       = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
     if (D)
       Decls.push_back(D);

     llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
   for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
        ++I) {
-    TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
+    auto *D = dyn_cast_or_null<TypedefNameDecl>(
         GetDecl(UnusedLocalTypedefNameCandidates[I]));
     if (D)
       Decls.insert(D);

 void ASTReader::ReadPendingInstantiations(
        SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
   for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
-    ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
+    auto *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
     SourceLocation Loc
       = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
 

     llvm::MapVector<const FunctionDecl *, LateParsedTemplate *> &LPTMap) {
   for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
        /* In loop */) {
-    FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
+    auto *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
 
-    LateParsedTemplate *LT = new LateParsedTemplate;
+    auto *LT = new LateParsedTemplate;
     LT->D = GetDecl(LateParsedTemplates[Idx++]);
 
     ModuleFile *F = getOwningModuleFile(LT->D);

       continue;
     }
 
-    NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
+    auto *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
 
     // If we're simply supposed to record the declarations, do so now.
     if (Decls) {

     return TemplateArgument(ReadExpr(F));
   case TemplateArgument::Pack: {
     unsigned NumArgs = Record[Idx++];
-    TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
+    auto *Args = new (Context) TemplateArgument[NumArgs];
     for (unsigned I = 0; I != NumArgs; ++I)
       Args[I] = ReadTemplateArgument(F, Record, Idx);
     return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));

                                 const RecordData &Record, unsigned &Idx) {
   bool isVirtual = static_cast<bool>(Record[Idx++]);
   bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
-  AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
+  auto AS = static_cast<AccessSpecifier>(Record[Idx++]);
   bool inheritConstructors = static_cast<bool>(Record[Idx++]);
   TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
   SourceRange Range = ReadSourceRange(F, Record, Idx);

 
 void ASTReader::ReadComments() {
   std::vector<RawComment *> Comments;
-  for (SmallVectorImpl<std::pair<BitstreamCursor,
-                                 serialization::ModuleFile *> >::iterator
-       I = CommentsCursors.begin(),
-       E = CommentsCursors.end();
-       I != E; ++I) {
+  for (auto &I : CommentsCursors) {
     Comments.clear();
-    BitstreamCursor &Cursor = I->first;
-    serialization::ModuleFile &F = *I->second;
+    BitstreamCursor &Cursor = I.first;
+    serialization::ModuleFile &F = *I.second;
     SavedStreamPosition SavedPosition(Cursor);
 
     RecordData Record;

     while (!PendingDeclContextInfos.empty()) {
       PendingDeclContextInfo Info = PendingDeclContextInfos.front();
       PendingDeclContextInfos.pop_front();
-      DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
-      DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
+      auto *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
+      auto *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
       Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
     }
 

   // that all redeclarations point to the definitions. Note that this can only 
   // happen now, after the redeclaration chains have been fully wired.
   for (Decl *D : PendingDefinitions) {
-    if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
-      if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
+    if (auto *TD = dyn_cast<TagDecl>(D)) {
+      if (const auto *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
         // Make sure that the TagType points at the definition.
         const_cast<TagType*>(TagT)->decl = TD;
       }

   // this now (delayed) so that we can be sure that the declaration chains
   // have been fully wired up (hasBody relies on this).
   // FIXME: We shouldn't require complete redeclaration chains here.
-  for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
-                               PBEnd = PendingBodies.end();
-       PB != PBEnd; ++PB) {
-    if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
+  for (const auto &PB : PendingBodies) {
+    if (auto *FD = dyn_cast<FunctionDecl>(PB.first)) {
       // FIXME: Check for =delete/=default?
       // FIXME: Complain about ODR violations here?
       if (!getContext().getLangOpts().Modules || !FD->hasBody())
-        FD->setLazyBody(PB->second);
+        FD->setLazyBody(PB.second);
       continue;
     }
 
-    ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
+    auto *MD = cast<ObjCMethodDecl>(PB.first);
     if (!getContext().getLangOpts().Modules || !MD->hasBody())
-      MD->setLazyBody(PB->second);
+      MD->setLazyBody(PB.second);
   }
   PendingBodies.clear();