Modernize the TableGen code by using C++11 range-based for loops

[• ehsan]

Addressed the review comment.

[• ehsan]

Thanks for the review, Justin. Let's can this...

utils/TableGen/ClangASTNodesEmitter.cpp

void ClangASTNodesEmitter::run(raw_ostream &OS) {
   OS << "#endif\n\n";
  
   // Emit statements
   const std::vector<Record*> Stmts
     = Records.getAllDerivedDefinitions(Root.getName());
 
   ChildMap Tree;
 
-  for (unsigned i = 0, e = Stmts.size(); i != e; ++i) {
-    Record *R = Stmts[i];
-
+  for (const auto &R : Stmts) {
     if (R->getValue("Base"))
       Tree.insert(std::make_pair(R->getValueAsDef("Base"), R));
     else
       Tree.insert(std::make_pair(&Root, R));
   }
 
   EmitNode(Tree, OS, &Root);
 
void EmitClangDeclContext(RecordKeeper &Records, raw_ostream &OS) {
   
   typedef std::set<Record*> RecordSet;
   typedef std::vector<Record*> RecordVector;
   
   RecordVector DeclContextsVector
     = Records.getAllDerivedDefinitions("DeclContext");
   RecordVector Decls = Records.getAllDerivedDefinitions("Decl");
   RecordSet DeclContexts (DeclContextsVector.begin(), DeclContextsVector.end());
-   
-  for (RecordVector::iterator i = Decls.begin(), e = Decls.end(); i != e; ++i) {
-    Record *R = *i;
-
+  for (const auto *R : Decls) {
     if (R->getValue("Base")) {
       Record *B = R->getValueAsDef("Base");
       if (DeclContexts.find(B) != DeclContexts.end()) {
         OS << "DECL_CONTEXT_BASE(" << B->getName() << ")\n";
         DeclContexts.erase(B);
       }
     }
   }
 
   // To keep identical order, RecordVector may be used
   // instead of RecordSet.
-  for (RecordVector::iterator
-         i = DeclContextsVector.begin(), e = DeclContextsVector.end();
-       i != e; ++i)
-    if (DeclContexts.find(*i) != DeclContexts.end())
-      OS << "DECL_CONTEXT(" << (*i)->getName() << ")\n";
+  for (const auto &DC : DeclContextsVector)
+    if (DeclContexts.find(DC) != DeclContexts.end())
+      OS << "DECL_CONTEXT(" << DC->getName() << ")\n";
 
   OS << "#undef DECL_CONTEXT\n";
   OS << "#undef DECL_CONTEXT_BASE\n";
 }
 } // end namespace clang

utils/TableGen/ClangAttrEmitter.cpp

void writeConversion(raw_ostream &OS) const {
       // type_visibility(hidden) both mapping to TypeVisibilityAttr::Hidden.
       OS << "  static const char *Convert" << type << "ToStr("
          << type << " Val) {\n"
          << "    switch(Val) {\n";
       std::set<std::string> Uniques;
       for (size_t I = 0; I < enums.size(); ++I) {
         if (Uniques.insert(enums[I]).second)
           OS << "    case " << getAttrName() << "Attr::" << enums[I]
-             << ": return \"" << values[I] << "\";\n";       
+             << ": return \"" << values[I] << "\";\n";
       }
       OS << "    }\n"
          << "    llvm_unreachable(\"No enumerator with that value\");\n"
          << "  }\n";
     }
   };
   
   class VariadicEnumArgument: public VariadicArgument {
void EmitClangAttrHasAttrImpl(RecordKeeper &Records, raw_ostream &OS) {
   OS << "case AttrSyntax::Declspec:\n";
   OS << "  return llvm::StringSwitch<bool>(Name)\n";
   GenerateHasAttrSpellingStringSwitch(Declspec, OS, "Declspec");
   OS << "case AttrSyntax::Pragma:\n";
   OS << "  return llvm::StringSwitch<bool>(Name)\n";
   GenerateHasAttrSpellingStringSwitch(Pragma, OS, "Pragma");
   OS << "case AttrSyntax::CXX: {\n";
   // C++11-style attributes are further split out based on the Scope.
-  for (std::map<std::string, std::vector<Record *>>::iterator I = CXX.begin(),
-                                                              E = CXX.end();
-       I != E; ++I) {
-    if (I != CXX.begin())
+  for (const auto &I : CXX) {
+    if (I != *CXX.begin())
       OS << " else ";
-    if (I->first.empty())
+    if (I.first.empty())
       OS << "if (!Scope || Scope->getName() == \"\") {\n";
     else
-      OS << "if (Scope->getName() == \"" << I->first << "\") {\n";
+      OS << "if (Scope->getName() == \"" << I.first << "\") {\n";
     OS << "  return llvm::StringSwitch<bool>(Name)\n";
-    GenerateHasAttrSpellingStringSwitch(I->second, OS, "CXX11", I->first);
+    GenerateHasAttrSpellingStringSwitch(I.second, OS, "CXX11", I.first);
     OS << "}";
   }
   OS << "\n}\n";
   OS << "}\n";
 }
 
 void EmitClangAttrSpellingListIndex(RecordKeeper &Records, raw_ostream &OS) {
   emitSourceFileHeader("Code to translate different attribute spellings "

utils/TableGen/ClangCommentHTMLNamedCharacterReferenceEmitter.cpp

 }
 
 namespace clang {
 void EmitClangCommentHTMLNamedCharacterReferences(RecordKeeper &Records,
                                                   raw_ostream &OS) {
   std::vector<Record *> Tags = Records.getAllDerivedDefinitions("NCR");
   std::vector<StringMatcher::StringPair> NameToUTF8;
   SmallString<32> CLiteral;
-  for (std::vector<Record *>::iterator I = Tags.begin(), E = Tags.end();
-       I != E; ++I) {
-    Record &Tag = **I;
-    std::string Spelling = Tag.getValueAsString("Spelling");
-    uint64_t CodePoint = Tag.getValueAsInt("CodePoint");
+  for (const auto *Tag : Tags) {
+    std::string Spelling = Tag->getValueAsString("Spelling");
+    uint64_t CodePoint = Tag->getValueAsInt("CodePoint");
     CLiteral.clear();
     CLiteral.append("return ");
     if (!translateCodePointToUTF8(CodePoint, CLiteral)) {
-      SrcMgr.PrintMessage(Tag.getLoc().front(),
+      SrcMgr.PrintMessage(Tag->getLoc().front(),
                           SourceMgr::DK_Error,
                           Twine("invalid code point"));
       continue;
     }
     CLiteral.append(";");
 
     StringMatcher::StringPair Match(Spelling, CLiteral.str());
     NameToUTF8.push_back(Match);

utils/TableGen/ClangDiagnosticsEmitter.cpp

 namespace {
 class DiagGroupParentMap {
   RecordKeeper &Records;
   std::map<const Record*, std::vector<Record*> > Mapping;
 public:
   DiagGroupParentMap(RecordKeeper &records) : Records(records) {
     std::vector<Record*> DiagGroups
       = Records.getAllDerivedDefinitions("DiagGroup");
-    for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
+    for (const auto &DG : DiagGroups) {
       std::vector<Record*> SubGroups =
-        DiagGroups[i]->getValueAsListOfDefs("SubGroups");
-      for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
-        Mapping[SubGroups[j]].push_back(DiagGroups[i]);
+        DG->getValueAsListOfDefs("SubGroups");
+      for (const auto &SG : SubGroups)
+        Mapping[SG].push_back(DG);
     }
   }
 
   const std::vector<Record*> &getParents(const Record *Group) {
     return Mapping[Group];
   }
 };
 } // end anonymous namespace.
 
 static std::string
 getCategoryFromDiagGroup(const Record *Group,
                          DiagGroupParentMap &DiagGroupParents) {
   // If the DiagGroup has a category, return it.
   std::string CatName = Group->getValueAsString("CategoryName");
   if (!CatName.empty()) return CatName;
 
   // The diag group may the subgroup of one or more other diagnostic groups,
   // check these for a category as well.
   const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
-  for (unsigned i = 0, e = Parents.size(); i != e; ++i) {
-    CatName = getCategoryFromDiagGroup(Parents[i], DiagGroupParents);
+  for (const auto &Parent : Parents) {
+    CatName = getCategoryFromDiagGroup(Parent, DiagGroupParents);
     if (!CatName.empty()) return CatName;
   }
   return "";
 }
 
 /// getDiagnosticCategory - Return the category that the specified diagnostic
 /// lives in.
 static std::string getDiagnosticCategory(const Record *R,
DiagCategoryIDMap(RecordKeeper &records) : Records(records) {
       DiagGroupParentMap ParentInfo(Records);
 
       // The zero'th category is "".
       CategoryStrings.push_back("");
       CategoryIDs[""] = 0;
 
       std::vector<Record*> Diags =
       Records.getAllDerivedDefinitions("Diagnostic");
-      for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
-        std::string Category = getDiagnosticCategory(Diags[i], ParentInfo);
+      for (const auto &D : Diags) {
+        std::string Category = getDiagnosticCategory(D, ParentInfo);
         if (Category.empty()) continue;  // Skip diags with no category.
 
         unsigned &ID = CategoryIDs[Category];
         if (ID != 0) continue;  // Already seen.
 
         ID = CategoryStrings.size();
         CategoryStrings.push_back(Category);
       }

 }
 
 /// \brief Invert the 1-[0/1] mapping of diags to group into a one to many
 /// mapping of groups to diags in the group.
 static void groupDiagnostics(const std::vector<Record*> &Diags,
                              const std::vector<Record*> &DiagGroups,
                              std::map<std::string, GroupInfo> &DiagsInGroup) {
 
-  for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
-    const Record *R = Diags[i];
+  for (const auto &R : Diags) {
     DefInit *DI = dyn_cast<DefInit>(R->getValueInit("Group"));
     if (!DI)
       continue;
     assert(R->getValueAsDef("Class")->getName() != "CLASS_NOTE" &&
            "Note can't be in a DiagGroup");
     std::string GroupName = DI->getDef()->getValueAsString("GroupName");
     DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
   }
 
   typedef SmallPtrSet<GroupInfo *, 16> GroupSetTy;
   GroupSetTy ImplicitGroups;
 
   // Add all DiagGroup's to the DiagsInGroup list to make sure we pick up empty
   // groups (these are warnings that GCC supports that clang never produces).
-  for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
-    Record *Group = DiagGroups[i];
+  for (const auto &Group : DiagGroups) {
     GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];
     if (Group->isAnonymous()) {
       if (GI.DiagsInGroup.size() > 1)
         ImplicitGroups.insert(&GI);
     } else {
       if (GI.ExplicitDef)
         assert(GI.ExplicitDef == Group);
       else
         GI.ExplicitDef = Group;
     }
 
     std::vector<Record*> SubGroups = Group->getValueAsListOfDefs("SubGroups");
-    for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
-      GI.SubGroups.push_back(SubGroups[j]->getValueAsString("GroupName"));
+    for (const auto &SG : SubGroups)
+      GI.SubGroups.push_back(SG->getValueAsString("GroupName"));
   }
 
   // Assign unique ID numbers to the groups.
   unsigned IDNo = 0;
-  for (std::map<std::string, GroupInfo>::iterator
-       I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I, ++IDNo)
-    I->second.IDNo = IDNo;
+  for (auto &I : DiagsInGroup)
+    I.second.IDNo = IDNo++;
 
   // Sort the implicit groups, so we can warn about them deterministically.
   SmallVector<GroupInfo *, 16> SortedGroups(ImplicitGroups.begin(),
                                             ImplicitGroups.end());
-  for (SmallVectorImpl<GroupInfo *>::iterator I = SortedGroups.begin(),
-                                              E = SortedGroups.end();
-       I != E; ++I) {
-    MutableArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
+  for (const auto &I : SortedGroups) {
+    MutableArrayRef<const Record *> GroupDiags = I->DiagsInGroup;
     std::sort(GroupDiags.begin(), GroupDiags.end(), beforeThanCompare);
   }
   std::sort(SortedGroups.begin(), SortedGroups.end(), beforeThanCompareGroups);
 
   // Warn about the same group being used anonymously in multiple places.
-  for (SmallVectorImpl<GroupInfo *>::const_iterator I = SortedGroups.begin(),
-                                                    E = SortedGroups.end();
-       I != E; ++I) {
-    ArrayRef<const Record *> GroupDiags = (*I)->DiagsInGroup;
-
-    if ((*I)->ExplicitDef) {
-      std::string Name = (*I)->ExplicitDef->getValueAsString("GroupName");
-      for (ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
-                                                    DE = GroupDiags.end();
-           DI != DE; ++DI) {
-        const DefInit *GroupInit = cast<DefInit>((*DI)->getValueInit("Group"));
+  for (const auto &I : SortedGroups) {
+    ArrayRef<const Record *> GroupDiags = I->DiagsInGroup;
+
+    if (I->ExplicitDef) {
+      std::string Name = I->ExplicitDef->getValueAsString("GroupName");
+      for (const auto &DI : GroupDiags) {
+        const DefInit *GroupInit = cast<DefInit>(DI->getValueInit("Group"));
         const Record *NextDiagGroup = GroupInit->getDef();
-        if (NextDiagGroup == (*I)->ExplicitDef)
+        if (NextDiagGroup == I->ExplicitDef)
           continue;
 
-        SMRange InGroupRange = findSuperClassRange(*DI, "InGroup");
+        SMRange InGroupRange = findSuperClassRange(DI, "InGroup");
         SmallString<64> Replacement;
         if (InGroupRange.isValid()) {
           Replacement += "InGroup<";
-          Replacement += (*I)->ExplicitDef->getName();
+          Replacement += I->ExplicitDef->getName();
           Replacement += ">";
         }
         SMFixIt FixIt(InGroupRange, Replacement.str());
 
         SrcMgr.PrintMessage(NextDiagGroup->getLoc().front(),
                             SourceMgr::DK_Error,
                             Twine("group '") + Name +
                               "' is referred to anonymously",
                             None,
                             InGroupRange.isValid() ? FixIt
                                                    : ArrayRef<SMFixIt>());
-        SrcMgr.PrintMessage((*I)->ExplicitDef->getLoc().front(),
+        SrcMgr.PrintMessage(I->ExplicitDef->getLoc().front(),
                             SourceMgr::DK_Note, "group defined here");
       }
     } else {
       // If there's no existing named group, we should just warn once and use
       // notes to list all the other cases.
       ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
                                                DE = GroupDiags.end();
       assert(DI != DE && "We only care about groups with multiple uses!");

 bool InferPedantic::isSubGroupOfGroup(const Record *Group,
                                       llvm::StringRef GName) {
 
   const std::string &GroupName = Group->getValueAsString("GroupName");
   if (GName == GroupName)
     return true;
 
   const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
-  for (unsigned i = 0, e = Parents.size(); i != e; ++i)
-    if (isSubGroupOfGroup(Parents[i], GName))
+  for (const auto &Parent : Parents)
+    if (isSubGroupOfGroup(Parent, GName))
       return true;
 
   return false;
 }
 
 /// Determine if the diagnostic is an extension.
 bool InferPedantic::isExtension(const Record *Diag) {
   const std::string &ClsName = Diag->getValueAsDef("Class")->getName();

 
 void InferPedantic::markGroup(const Record *Group) {
   // If all the diagnostics and subgroups have been marked as being
   // covered by -Wpedantic, increment the count of parent groups.  Once the
   // group's count is equal to the number of subgroups and diagnostics in
   // that group, we can safely add this group to -Wpedantic.
   if (groupInPedantic(Group, /* increment */ true)) {
     const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
-    for (unsigned i = 0, e = Parents.size(); i != e; ++i)
-      markGroup(Parents[i]);
+    for (const auto &Parent : Parents)
+      markGroup(Parent);
   }
 }
 
 void InferPedantic::compute(VecOrSet DiagsInPedantic,
                             VecOrSet GroupsInPedantic) {
   // All extensions that are not on by default are implicitly in the
   // "pedantic" group.  For those that aren't explicitly included in -Wpedantic,
   // mark them for consideration to be included in -Wpedantic directly.
-  for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
-    Record *R = Diags[i];
+  for (const auto &R : Diags) {
     if (isExtension(R) && isOffByDefault(R)) {
       DiagsSet.insert(R);
       if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group"))) {
         const Record *GroupRec = Group->getDef();
         if (!isSubGroupOfGroup(GroupRec, "pedantic")) {
           markGroup(GroupRec);
         }
       }
     }
   }
 
   // Compute the set of diagnostics that are directly in -Wpedantic.  We
   // march through Diags a second time to ensure the results are emitted
   // in deterministic order.
-  for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
-    Record *R = Diags[i];
+  for (const auto &R : Diags) {
     if (!DiagsSet.count(R))
       continue;
     // Check if the group is implicitly in -Wpedantic.  If so,
     // the diagnostic should not be directly included in the -Wpedantic
     // diagnostic group.
     if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group")))
       if (groupInPedantic(Group->getDef()))
         continue;
 
     // The diagnostic is not included in a group that is (transitively) in
     // -Wpedantic.  Include it in -Wpedantic directly.
     if (RecordVec *V = DiagsInPedantic.dyn_cast<RecordVec*>())
       V->push_back(R);
     else {
       DiagsInPedantic.get<RecordSet*>()->insert(R);
     }
   }
 
   if (!GroupsInPedantic)
     return;
 
   // Compute the set of groups that are directly in -Wpedantic.  We
   // march through the groups to ensure the results are emitted
   /// in a deterministc order.
-  for (unsigned i = 0, ei = DiagGroups.size(); i != ei; ++i) {
-    Record *Group = DiagGroups[i];
+  for (const auto &Group : DiagGroups) {
     if (!groupInPedantic(Group))
       continue;
 
     unsigned ParentsInPedantic = 0;
     const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
-    for (unsigned j = 0, ej = Parents.size(); j != ej; ++j) {
-      if (groupInPedantic(Parents[j]))
+    for (const auto &Parent : Parents) {
+      if (groupInPedantic(Parent))
         ++ParentsInPedantic;
     }
     // If all the parents are in -Wpedantic, this means that this diagnostic
     // group will be indirectly included by -Wpedantic already.  In that
     // case, do not add it directly to -Wpedantic.  If the group has no
     // parents, obviously it should go into -Wpedantic.
     if (Parents.size() > 0 && ParentsInPedantic == Parents.size())
       continue;
void EmitClangDiagsDefs(RecordKeeper &Records, raw_ostream &OS,
   DiagCategoryIDMap CategoryIDs(Records);
   DiagGroupParentMap DGParentMap(Records);
 
   // Compute the set of diagnostics that are in -Wpedantic.
   RecordSet DiagsInPedantic;
   InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
   inferPedantic.compute(&DiagsInPedantic, (RecordVec*)nullptr);
 
-  for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
-    const Record &R = *Diags[i];
-
+  for (const auto &R : Diags) {
     // Check if this is an error that is accidentally in a warning
     // group.
-    if (isError(R)) {
-      if (DefInit *Group = dyn_cast<DefInit>(R.getValueInit("Group"))) {
+    if (isError(*R)) {
+      if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group"))) {
         const Record *GroupRec = Group->getDef();
         const std::string &GroupName = GroupRec->getValueAsString("GroupName");
-        PrintFatalError(R.getLoc(), "Error " + R.getName() +
+        PrintFatalError(R->getLoc(), "Error " + R->getName() +
                       " cannot be in a warning group [" + GroupName + "]");
       }
     }
 
     // Check that all remarks have an associated diagnostic group.
-    if (isRemark(R)) {
-      if (!isa<DefInit>(R.getValueInit("Group"))) {
-        PrintFatalError(R.getLoc(), "Error " + R.getName() +
+    if (isRemark(*R)) {
+      if (!isa<DefInit>(R->getValueInit("Group"))) {
+        PrintFatalError(R->getLoc(), "Error " + R->getName() +
                                         " not in any diagnostic group");
       }
     }
 
     // Filter by component.
-    if (!Component.empty() && Component != R.getValueAsString("Component"))
+    if (!Component.empty() && Component != R->getValueAsString("Component"))
       continue;
 
-    OS << "DIAG(" << R.getName() << ", ";
-    OS << R.getValueAsDef("Class")->getName();
+    OS << "DIAG(" << R->getName() << ", ";
+    OS << R->getValueAsDef("Class")->getName();
     OS << ", (unsigned)diag::Severity::"
-       << R.getValueAsDef("DefaultSeverity")->getValueAsString("Name");
+       << R->getValueAsDef("DefaultSeverity")->getValueAsString("Name");
 
     // Description string.
     OS << ", \"";
-    OS.write_escaped(R.getValueAsString("Text")) << '"';
+    OS.write_escaped(R->getValueAsString("Text")) << '"';
 
     // Warning associated with the diagnostic. This is stored as an index into
     // the alphabetically sorted warning table.
-    if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("Group"))) {
+    if (DefInit *DI = dyn_cast<DefInit>(R->getValueInit("Group"))) {
       std::map<std::string, GroupInfo>::iterator I =
           DiagsInGroup.find(DI->getDef()->getValueAsString("GroupName"));
       assert(I != DiagsInGroup.end());
       OS << ", " << I->second.IDNo;
-    } else if (DiagsInPedantic.count(&R)) {
+    } else if (DiagsInPedantic.count(R)) {
       std::map<std::string, GroupInfo>::iterator I =
         DiagsInGroup.find("pedantic");
       assert(I != DiagsInGroup.end() && "pedantic group not defined");
       OS << ", " << I->second.IDNo;
     } else {
       OS << ", 0";
     }
 
     // SFINAE response.
-    OS << ", " << R.getValueAsDef("SFINAE")->getName();
+    OS << ", " << R->getValueAsDef("SFINAE")->getName();
 
     // Default warning has no Werror bit.
-    if (R.getValueAsBit("WarningNoWerror"))
+    if (R->getValueAsBit("WarningNoWerror"))
       OS << ", true";
     else
       OS << ", false";
 
-    if (R.getValueAsBit("ShowInSystemHeader"))
+    if (R->getValueAsBit("ShowInSystemHeader"))
       OS << ", true";
     else
       OS << ", false";
 
     // Category number.
-    OS << ", " << CategoryIDs.getID(getDiagnosticCategory(&R, DGParentMap));
+    OS << ", " << CategoryIDs.getID(getDiagnosticCategory(R, DGParentMap));
     OS << ")\n";
   }
 }
 } // end namespace clang
 
 //===----------------------------------------------------------------------===//
 // Warning Group Tables generation
 //===----------------------------------------------------------------------===//
 
 static std::string getDiagCategoryEnum(llvm::StringRef name) {
   if (name.empty())
     return "DiagCat_None";
   SmallString<256> enumName = llvm::StringRef("DiagCat_");
-  for (llvm::StringRef::iterator I = name.begin(), E = name.end(); I != E; ++I)
-    enumName += isalnum(*I) ? *I : '_';
+  for (const auto &I : name)
+    enumName += isalnum(I) ? I : '_';
   return enumName.str();
 }
 
 /// \brief Emit the array of diagnostic subgroups.
 ///
 /// The array of diagnostic subgroups contains for each group a list of its
 /// subgroups. The individual lists are separated by '-1'. Groups with no
 /// subgroups are skipped.
void EmitClangDiagGroups(RecordKeeper &Records, raw_ostream &OS) {
   // implicit set of groups in the "pedantic" group, and use this information
   // later when emitting the group information for Pedantic.
   RecordVec DiagsInPedantic;
   RecordVec GroupsInPedantic;
   InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
   inferPedantic.compute(&DiagsInPedantic, &GroupsInPedantic);
 
   StringToOffsetTable GroupNames;
-  for (std::map<std::string, GroupInfo>::const_iterator
-           I = DiagsInGroup.begin(),
-           E = DiagsInGroup.end();
-       I != E; ++I) {
+  for (const auto &I : DiagsInGroup) {
     // Store a pascal-style length byte at the beginning of the string.
-    std::string Name = char(I->first.size()) + I->first;
+    std::string Name = char(I.first.size()) + I.first;
     GroupNames.GetOrAddStringOffset(Name, false);
   }
 
   emitAllDiagArrays(DiagsInGroup, DiagsInPedantic, GroupsInPedantic, GroupNames,
                     OS);
   emitDiagTable(DiagsInGroup, DiagsInPedantic, GroupsInPedantic, GroupNames,
                 OS);
   emitCategoryTable(Records, OS);

 
 namespace clang {
 void EmitClangDiagsIndexName(RecordKeeper &Records, raw_ostream &OS) {
   const std::vector<Record*> &Diags =
     Records.getAllDerivedDefinitions("Diagnostic");
 
   std::vector<RecordIndexElement> Index;
   Index.reserve(Diags.size());
-  for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
-    const Record &R = *(Diags[i]);
-    Index.push_back(RecordIndexElement(R));
+  for (const auto &R : Diags) {
+    Index.push_back(RecordIndexElement(*R));
   }
 
   std::sort(Index.begin(), Index.end(),
             [](const RecordIndexElement &Lhs,
                const RecordIndexElement &Rhs) { return Lhs.Name < Rhs.Name; });
 
-  for (unsigned i = 0, e = Index.size(); i != e; ++i) {
-    const RecordIndexElement &R = Index[i];
-
+  for (const auto &R : Index) {
     OS << "DIAG_NAME_INDEX(" << R.Name << ")\n";
   }
 }
 } // end namespace clang

utils/TableGen/ClangSACheckersEmitter.cpp

struct GroupInfo {
 
   GroupInfo() : Hidden(false) { }
 };
 }
 
 static void addPackageToCheckerGroup(const Record *package, const Record *group,
                   llvm::DenseMap<const Record *, GroupInfo *> &recordGroupMap) {
   llvm::DenseSet<const Record *> &checkers = recordGroupMap[package]->Checkers;
-  for (llvm::DenseSet<const Record *>::iterator
-         I = checkers.begin(), E = checkers.end(); I != E; ++I)
-    recordGroupMap[group]->Checkers.insert(*I);
+  for (const auto &I : checkers)
+    recordGroupMap[group]->Checkers.insert(I);
 
   llvm::DenseSet<const Record *> &subGroups = recordGroupMap[package]->SubGroups;
-  for (llvm::DenseSet<const Record *>::iterator
-         I = subGroups.begin(), E = subGroups.end(); I != E; ++I)
-    addPackageToCheckerGroup(*I, group, recordGroupMap);
+  for (const auto &I : subGroups)
+    addPackageToCheckerGroup(I, group, recordGroupMap);
 }
 
 namespace clang {
 void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS) {
   std::vector<Record*> checkers = Records.getAllDerivedDefinitions("Checker");
   llvm::DenseMap<const Record *, unsigned> checkerRecIndexMap;
   for (unsigned i = 0, e = checkers.size(); i != e; ++i)
     checkerRecIndexMap[checkers[i]] = i;
 
   // Invert the mapping of checkers to package/group into a one to many
   // mapping of packages/groups to checkers.
   std::map<std::string, GroupInfo> groupInfoByName;
   llvm::DenseMap<const Record *, GroupInfo *> recordGroupMap;
 
   std::vector<Record*> packages = Records.getAllDerivedDefinitions("Package");
-  for (unsigned i = 0, e = packages.size(); i != e; ++i) {
-    Record *R = packages[i];
+  for (const auto &R : packages) {
     std::string fullName = getPackageFullName(R);
     if (!fullName.empty()) {
       GroupInfo &info = groupInfoByName[fullName];
       info.Hidden = isHidden(*R);
       recordGroupMap[R] = &info;
     }
   }
 
   std::vector<Record*>
       checkerGroups = Records.getAllDerivedDefinitions("CheckerGroup");
-  for (unsigned i = 0, e = checkerGroups.size(); i != e; ++i) {
-    Record *R = checkerGroups[i];
+  for (const auto &R : checkerGroups) {
     std::string name = R->getValueAsString("GroupName");
     if (!name.empty()) {
       GroupInfo &info = groupInfoByName[name];
       recordGroupMap[R] = &info;
     }
   }
 
-  for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
-    Record *R = checkers[i];
+  for (const auto &R : checkers) {
     Record *package = nullptr;
     if (DefInit *
           DI = dyn_cast<DefInit>(R->getValueInit("ParentPackage")))
       package = DI->getDef();
     if (!isCheckerNamed(R) && !package)
       PrintFatalError(R->getLoc(), "Checker '" + R->getName() +
                       "' is neither named, nor in a package!");
 
for (const auto &R : checkers) {
     }
     // Insert the checker into the set of its group.
     if (DefInit *DI = dyn_cast<DefInit>(R->getValueInit("Group")))
       recordGroupMap[DI->getDef()]->Checkers.insert(R);
   }
 
   // If a package is in group, add all its checkers and its sub-packages
   // checkers into the group.
-  for (unsigned i = 0, e = packages.size(); i != e; ++i)
-    if (DefInit *DI = dyn_cast<DefInit>(packages[i]->getValueInit("Group")))
-      addPackageToCheckerGroup(packages[i], DI->getDef(), recordGroupMap);
+  for (const auto &package : packages)
+    if (DefInit *DI = dyn_cast<DefInit>(package->getValueInit("Group")))
+      addPackageToCheckerGroup(package, DI->getDef(), recordGroupMap);
 
   typedef std::map<std::string, const Record *> SortedRecords;
   typedef llvm::DenseMap<const Record *, unsigned> RecToSortIndex;
 
   SortedRecords sortedGroups;
   RecToSortIndex groupToSortIndex;
   OS << "\n#ifdef GET_GROUPS\n";
   {
-    for (unsigned i = 0, e = checkerGroups.size(); i != e; ++i)
-      sortedGroups[checkerGroups[i]->getValueAsString("GroupName")]
-                   = checkerGroups[i];
+    for (const auto &checkerGroup : checkerGroups)
+      sortedGroups[checkerGroup->getValueAsString("GroupName")]
+                   = checkerGroup;
 
     unsigned sortIndex = 0;
-    for (SortedRecords::iterator
-           I = sortedGroups.begin(), E = sortedGroups.end(); I != E; ++I) {
-      const Record *R = I->second;
+    for (const auto &I : sortedGroups) {
+      const Record *R = I.second;
   
       OS << "GROUP(" << "\"";
       OS.write_escaped(R->getValueAsString("GroupName")) << "\"";
       OS << ")\n";
 
       groupToSortIndex[R] = sortIndex++;
     }
   }
   OS << "#endif // GET_GROUPS\n\n";
 
   OS << "\n#ifdef GET_PACKAGES\n";
   {
     SortedRecords sortedPackages;
-    for (unsigned i = 0, e = packages.size(); i != e; ++i)
-      sortedPackages[getPackageFullName(packages[i])] = packages[i];
+    for (const auto &package : packages)
+      sortedPackages[getPackageFullName(package)] = package;
   
-    for (SortedRecords::iterator
-           I = sortedPackages.begin(), E = sortedPackages.end(); I != E; ++I) {
-      const Record &R = *I->second;
+    for (const auto &I : sortedPackages) {
+      const Record &R = *I.second;
   
       OS << "PACKAGE(" << "\"";
       OS.write_escaped(getPackageFullName(&R)) << "\", ";
       // Group index
       if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("Group")))
         OS << groupToSortIndex[DI->getDef()] << ", ";
       else
         OS << "-1, ";
       // Hidden bit
       if (isHidden(R))
         OS << "true";
       else
         OS << "false";
       OS << ")\n";
     }
   }
   OS << "#endif // GET_PACKAGES\n\n";
   
   OS << "\n#ifdef GET_CHECKERS\n";
-  for (unsigned i = 0, e = checkers.size(); i != e; ++i) {
-    const Record &R = *checkers[i];
-
+  for (const auto &R : checkers) {
     OS << "CHECKER(" << "\"";
     std::string name;
-    if (isCheckerNamed(&R))
-      name = getCheckerFullName(&R);
+    if (isCheckerNamed(R))
+      name = getCheckerFullName(R);
     OS.write_escaped(name) << "\", ";
-    OS << R.getName() << ", ";
-    OS << getStringValue(R, "DescFile") << ", ";
+    OS << R->getName() << ", ";
+    OS << getStringValue(*R, "DescFile") << ", ";
     OS << "\"";
-    OS.write_escaped(getStringValue(R, "HelpText")) << "\", ";
+    OS.write_escaped(getStringValue(*R, "HelpText")) << "\", ";
     // Group index
-    if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("Group")))
+    if (DefInit *DI = dyn_cast<DefInit>(R->getValueInit("Group")))
       OS << groupToSortIndex[DI->getDef()] << ", ";
     else
       OS << "-1, ";
     // Hidden bit
-    if (isHidden(R))
+    if (isHidden(*R))
       OS << "true";
     else
       OS << "false";
     OS << ")\n";
   }
   OS << "#endif // GET_CHECKERS\n\n";
 
   unsigned index = 0;
-  for (std::map<std::string, GroupInfo>::iterator
-         I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I)
-    I->second.Index = index++;
+  for (auto &I : groupInfoByName)
+    I.second.Index = index++;
 
   // Walk through the packages/groups/checkers emitting an array for each
   // set of checkers and an array for each set of subpackages.
 
   OS << "\n#ifdef GET_MEMBER_ARRAYS\n";
   unsigned maxLen = 0;
-  for (std::map<std::string, GroupInfo>::iterator
-         I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I) {
-    maxLen = std::max(maxLen, (unsigned)I->first.size());
+  for (auto &I : groupInfoByName) {
+    maxLen = std::max(maxLen, (unsigned)I.first.size());
 
-    llvm::DenseSet<const Record *> &checkers = I->second.Checkers;
+    llvm::DenseSet<const Record *> &checkers = I.second.Checkers;
     if (!checkers.empty()) {
-      OS << "static const short CheckerArray" << I->second.Index << "[] = { ";
+      OS << "static const short CheckerArray" << I.second.Index << "[] = { ";
       // Make the output order deterministic.
       std::map<int, const Record *> sorted;
-      for (llvm::DenseSet<const Record *>::iterator
-             I = checkers.begin(), E = checkers.end(); I != E; ++I)
-        sorted[(*I)->getID()] = *I;
-
-      for (std::map<int, const Record *>::iterator
-             I = sorted.begin(), E = sorted.end(); I != E; ++I)
-        OS << checkerRecIndexMap[I->second] << ", ";
+      for (const auto &I : checkers)
+        sorted[I->getID()] = I;
+
+      for (const auto &I : sorted)
+        OS << checkerRecIndexMap[I.second] << ", ";
       OS << "-1 };\n";
     }
     
-    llvm::DenseSet<const Record *> &subGroups = I->second.SubGroups;
+    llvm::DenseSet<const Record *> &subGroups = I.second.SubGroups;
     if (!subGroups.empty()) {
-      OS << "static const short SubPackageArray" << I->second.Index << "[] = { ";
+      OS << "static const short SubPackageArray" << I.second.Index << "[] = { ";
       // Make the output order deterministic.
       std::map<int, const Record *> sorted;
-      for (llvm::DenseSet<const Record *>::iterator
-             I = subGroups.begin(), E = subGroups.end(); I != E; ++I)
-        sorted[(*I)->getID()] = *I;
-
-      for (std::map<int, const Record *>::iterator
-             I = sorted.begin(), E = sorted.end(); I != E; ++I) {
-        OS << recordGroupMap[I->second]->Index << ", ";
+      for (const auto &I : subGroups)
+        sorted[I->getID()] = I;
+
+      for (const auto &I : sorted) {
+        OS << recordGroupMap[I.second]->Index << ", ";
       }
       OS << "-1 };\n";
     }
   }
   OS << "#endif // GET_MEMBER_ARRAYS\n\n";
 
   OS << "\n#ifdef GET_CHECKNAME_TABLE\n";
-  for (std::map<std::string, GroupInfo>::iterator
-         I = groupInfoByName.begin(), E = groupInfoByName.end(); I != E; ++I) {
+  for (const auto &I : groupInfoByName) {
     // Group option string.
     OS << "  { \"";
-    OS.write_escaped(I->first) << "\","
-                               << std::string(maxLen-I->first.size()+1, ' ');
+    OS.write_escaped(I.first) << "\","
+                              << std::string(maxLen-I.first.size()+1, ' ');
     
-    if (I->second.Checkers.empty())
+    if (I.second.Checkers.empty())
       OS << "0, ";
     else
-      OS << "CheckerArray" << I->second.Index << ", ";
+      OS << "CheckerArray" << I.second.Index << ", ";
     
     // Subgroups.
-    if (I->second.SubGroups.empty())
+    if (I.second.SubGroups.empty())
       OS << "0, ";
     else
-      OS << "SubPackageArray" << I->second.Index << ", ";
+      OS << "SubPackageArray" << I.second.Index << ", ";
 
-    OS << (I->second.Hidden ? "true" : "false");
+    OS << (I.second.Hidden ? "true" : "false");
 
     OS << " },\n";
   }
   OS << "#endif // GET_CHECKNAME_TABLE\n\n";
 }
 } // end namespace clang