[Clang] Fix some Clang-tidy modernize-use-bool-literals and Include What You Use warnings; other minor fixes

[Eugene.Zelenko]

Summary

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

[compnerd]

lib/Basic/SourceManager.cpp

395

Cant this be rewritten as:

for (const auto &I : FileInfos)

1039

Hmm, might be nice to change this to Expansion as the other ones are named that.

1075

Similar.

[Prazek]

Lgtm

[Eugene.Zelenko]

Implement Saleem suggestions.

[shafik]

Is this PR still relevant or should it just be closed?

lib/Analysis/PrintfFormatString.cpp

 //== PrintfFormatString.cpp - Analysis of printf format strings --*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Handling of format string in printf and friends.  The structure of format
 // strings for fprintf() are described in C99 7.19.6.1.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/Analyses/FormatString.h"
-#include "FormatStringParsing.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/Type.h"
+#include "clang/Basic/LLVM.h"
 #include "clang/Basic/TargetInfo.h"
+#include "FormatStringParsing.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cassert>
 
 using clang::analyze_format_string::ArgType;
 using clang::analyze_format_string::FormatStringHandler;
 using clang::analyze_format_string::LengthModifier;
 using clang::analyze_format_string::OptionalAmount;
 using clang::analyze_format_string::ConversionSpecifier;
 using clang::analyze_printf::PrintfSpecifier;
 

 static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
                                                   const char *&Beg,
                                                   const char *E,
                                                   unsigned &argIndex,
                                                   const LangOptions &LO,
                                                   const TargetInfo &Target,
                                                   bool Warn,
                                                   bool isFreeBSDKPrintf) {
-
   using namespace clang::analyze_format_string;
   using namespace clang::analyze_printf;
 
   const char *I = Beg;
   const char *Start = nullptr;
   UpdateOnReturn <const char*> UpdateBeg(Beg, I);
 
   // Look for a '%' character that indicates the start of a format specifier.

 }
 
 bool clang::analyze_format_string::ParsePrintfString(FormatStringHandler &H,
                                                      const char *I,
                                                      const char *E,
                                                      const LangOptions &LO,
                                                      const TargetInfo &Target,
                                                      bool isFreeBSDKPrintf) {
-
   unsigned argIndex = 0;
 
   // Keep looking for a format specifier until we have exhausted the string.
   while (I != E) {
     const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex,
                                                             LO, Target, true,
                                                             isFreeBSDKPrintf);
     // Did a fail-stop error of any kind occur when parsing the specifier?

   assert(I == E && "Format string not exhausted");
   return false;
 }
 
 bool clang::analyze_format_string::ParseFormatStringHasSArg(const char *I,
                                                             const char *E,
                                                             const LangOptions &LO,
                                                             const TargetInfo &Target) {
-  
   unsigned argIndex = 0;
   
   // Keep looking for a %s format specifier until we have exhausted the string.
   FormatStringHandler H;
   while (I != E) {
     const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex,
                                                             LO, Target, false,
                                                             false);

     return true;
   }
 
   // Handle strings next (char *, wchar_t *)
   if (QT->isPointerType() && (QT->getPointeeType()->isAnyCharacterType())) {
     CS.setKind(ConversionSpecifier::sArg);
 
     // Disable irrelevant flags
-    HasAlternativeForm = 0;
-    HasLeadingZeroes = 0;
+    HasAlternativeForm = false;
+    HasLeadingZeroes = false;
 
     // Set the long length modifier for wide characters
     if (QT->getPointeeType()->isWideCharType())
       LM.setKind(LengthModifier::AsWideChar);
     else
       LM.setKind(LengthModifier::None);
 
     return true;

   }
 
   // Set conversion specifier and disable any flags which do not apply to it.
   // Let typedefs to char fall through to int, as %c is silly for uint8_t.
   if (!isa<TypedefType>(QT) && QT->isCharType()) {
     CS.setKind(ConversionSpecifier::cArg);
     LM.setKind(LengthModifier::None);
     Precision.setHowSpecified(OptionalAmount::NotSpecified);
-    HasAlternativeForm = 0;
-    HasLeadingZeroes = 0;
-    HasPlusPrefix = 0;
+    HasAlternativeForm = false;
+    HasLeadingZeroes = false;
+    HasPlusPrefix = false;
   }
   // Test for Floating type first as LongDouble can pass isUnsignedIntegerType
   else if (QT->isRealFloatingType()) {
     CS.setKind(ConversionSpecifier::fArg);
   }
   else if (QT->isSignedIntegerType()) {
     CS.setKind(ConversionSpecifier::dArg);
-    HasAlternativeForm = 0;
+    HasAlternativeForm = false;
   }
   else if (QT->isUnsignedIntegerType()) {
     CS.setKind(ConversionSpecifier::uArg);
-    HasAlternativeForm = 0;
-    HasPlusPrefix = 0;
+    HasAlternativeForm = false;
+    HasPlusPrefix = false;
   } else {
     llvm_unreachable("Unexpected type");
   }
 
   return true;
 }
 
 void PrintfSpecifier::toString(raw_ostream &os) const {

   case ConversionSpecifier::FreeBSDrArg:
   case ConversionSpecifier::FreeBSDyArg:
     return true;
 
   default:
     return false;
   }
 }
+
 bool PrintfSpecifier::hasValidFieldWidth() const {
   if (FieldWidth.getHowSpecified() == OptionalAmount::NotSpecified)
       return true;
 
   // The field width is valid for all conversions except n
   switch (CS.getKind()) {
   case ConversionSpecifier::nArg:
     return false;
 
   default:
     return true;
   }
 }

lib/Basic/Diagnostic.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/PartialDiagnostic.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/Specifiers.h"
+#include "clang/Basic/TokenKinds.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Locale.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <utility>
+#include <vector>
 
 using namespace clang;
 
 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
                                            DiagNullabilityKind nullability) {
   StringRef string;
   switch (nullability.first) {
   case NullabilityKind::NonNull:

 
   // If there was a delayed diagnostic, emit it now.
   if (!Force && DelayedDiagID && DelayedDiagID != DiagID)
     ReportDelayed();
 
   return Emitted;
 }
 
-
 DiagnosticConsumer::~DiagnosticConsumer() {}
 
 void DiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                                         const Diagnostic &Info) {
   if (!IncludeInDiagnosticCounts())
     return;
 
   if (DiagLevel == DiagnosticsEngine::Warning)

 
   llvm::raw_svector_ostream Out(OutStr);
 
   // We could use text forms for the first N ordinals, but the numeric
   // forms are actually nicer in diagnostics because they stand out.
   Out << ValNo << llvm::getOrdinalSuffix(ValNo);
 }
 
-
 /// PluralNumber - Parse an unsigned integer and advance Start.
 static unsigned PluralNumber(const char *&Start, const char *End) {
   // Programming 101: Parse a decimal number :-)
   unsigned Val = 0;
   while (Start != End && *Start >= '0' && *Start <= '9') {
     Val *= 10;
     Val += *Start - '0';
     ++Start;

 }
 
 /// EvalPluralExpr - Actual expression evaluator for HandlePluralModifier.
 static bool EvalPluralExpr(unsigned ValNo, const char *Start, const char *End) {
   // Empty condition?
   if (*Start == ':')
     return true;
 
-  while (1) {
+  while (true) {
     char C = *Start;
     if (C == '%') {
       // Modulo expression
       ++Start;
       unsigned Arg = PluralNumber(Start, End);
       assert(*Start == '=' && "Bad plural expression syntax: expected =");
       ++Start;
       unsigned ValMod = ValNo % Arg;

 /// Slovak
 /// {1:form0|[2,4]:form1|:form2}
 /// Polish (requires repeated form):
 /// {1:form0|%100=[10,20]:form2|%10=[2,4]:form1|:form2}
 static void HandlePluralModifier(const Diagnostic &DInfo, unsigned ValNo,
                                  const char *Argument, unsigned ArgumentLen,
                                  SmallVectorImpl<char> &OutStr) {
   const char *ArgumentEnd = Argument + ArgumentLen;
-  while (1) {
+  while (true) {
     assert(Argument < ArgumentEnd && "Plural expression didn't match.");
     const char *ExprEnd = Argument;
     while (*ExprEnd != ':') {
       assert(ExprEnd != ArgumentEnd && "Plural missing expression end");
       ++ExprEnd;
     }
     if (EvalPluralExpr(ValNo, Argument, ExprEnd)) {
       Argument = ExprEnd + 1;

lib/Basic/SourceManager.cpp

 //===--- SourceManager.cpp - Track and cache source files -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements the SourceManager interface.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileManager.h"
+#include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceManagerInternals.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Capacity.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
 #include <cstring>
+#include <new>
+#include <tuple>
+#include <utility>
 
 using namespace clang;
 using namespace SrcMgr;
 using llvm::MemoryBuffer;
 
 //===----------------------------------------------------------------------===//
 // SourceManager Helper Classes
 //===----------------------------------------------------------------------===//

 /// location to LineNo/FilenameID.
 void LineTableInfo::AddLineNote(FileID FID, unsigned Offset,
                                 unsigned LineNo, int FilenameID) {
   std::vector<LineEntry> &Entries = LineEntries[FID];
 
   assert((Entries.empty() || Entries.back().FileOffset < Offset) &&
          "Adding line entries out of order!");
 
-  SrcMgr::CharacteristicKind Kind = SrcMgr::C_User;
+  CharacteristicKind Kind = C_User;
   unsigned IncludeOffset = 0;
 
   if (!Entries.empty()) {
     // If this is a '#line 4' after '#line 42 "foo.h"', make sure to remember
     // that we are still in "foo.h".
     if (FilenameID == -1)
       FilenameID = Entries.back().FilenameID;
 

                                 int FilenameID) {
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
 
   bool Invalid = false;
   const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
   if (!Entry.isFile() || Invalid)
     return;
   
-  const SrcMgr::FileInfo &FileInfo = Entry.getFile();
+  const FileInfo &FI = Entry.getFile();
 
   // Remember that this file has #line directives now if it doesn't already.
-  const_cast<SrcMgr::FileInfo&>(FileInfo).setHasLineDirectives();
+  const_cast<FileInfo&>(FI).setHasLineDirectives();
 
   getLineTable().AddLineNote(LocInfo.first, LocInfo.second, LineNo, FilenameID);
 }
 
 /// AddLineNote - Add a GNU line marker to the line table.
 void SourceManager::AddLineNote(SourceLocation Loc, unsigned LineNo,
                                 int FilenameID, bool IsFileEntry,
                                 bool IsFileExit, bool IsSystemHeader,
                                 bool IsExternCHeader) {
   // If there is no filename and no flags, this is treated just like a #line,
   // which does not change the flags of the previous line marker.
   if (FilenameID == -1) {
     assert(!IsFileEntry && !IsFileExit && !IsSystemHeader && !IsExternCHeader &&
            "Can't set flags without setting the filename!");
     return AddLineNote(Loc, LineNo, FilenameID);
   }
 
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
 
   bool Invalid = false;
   const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
   if (!Entry.isFile() || Invalid)
     return;
   
-  const SrcMgr::FileInfo &FileInfo = Entry.getFile();
+  const FileInfo &FI = Entry.getFile();
 
   // Remember that this file has #line directives now if it doesn't already.
-  const_cast<SrcMgr::FileInfo&>(FileInfo).setHasLineDirectives();
+  const_cast<FileInfo&>(FI).setHasLineDirectives();
 
   (void) getLineTable();
 
-  SrcMgr::CharacteristicKind FileKind;
+  CharacteristicKind FileKind;
   if (IsExternCHeader)
-    FileKind = SrcMgr::C_ExternCSystem;
+    FileKind = C_ExternCSystem;
   else if (IsSystemHeader)
-    FileKind = SrcMgr::C_System;
+    FileKind = C_System;
   else
-    FileKind = SrcMgr::C_User;
+    FileKind = C_User;
 
   unsigned EntryExit = 0;
   if (IsFileEntry)
     EntryExit = 1;
   else if (IsFileExit)
     EntryExit = 2;
 
   LineTable->AddLineNote(LocInfo.first, LocInfo.second, LineNo, FilenameID,

   // content cache objects are bump pointer allocated, we just have to run the
   // dtors, but we call the deallocate method for completeness.
   for (unsigned i = 0, e = MemBufferInfos.size(); i != e; ++i) {
     if (MemBufferInfos[i]) {
       MemBufferInfos[i]->~ContentCache();
       ContentCacheAlloc.Deallocate(MemBufferInfos[i]);
     }
   }
-  for (llvm::DenseMap<const FileEntry*, SrcMgr::ContentCache*>::iterator
-       I = FileInfos.begin(), E = FileInfos.end(); I != E; ++I) {
-    if (I->second) {
-      I->second->~ContentCache();
-      ContentCacheAlloc.Deallocate(I->second);
+  for (const auto &I : FileInfos) {
+    if (I.second) {
+      I.second->~ContentCache();
+      ContentCacheAlloc.Deallocate(I.second);
     }
   }
 
   llvm::DeleteContainerSeconds(MacroArgsCacheMap);
 }
 
 void SourceManager::clearIDTables() {
   MainFileID = FileID();

   }
 
   Entry->IsSystemFile = isSystemFile;
   Entry->IsTransient = FilesAreTransient;
 
   return Entry;
 }
 
-
 /// createMemBufferContentCache - Create a new ContentCache for the specified
 ///  memory buffer.  This does no caching.
 const ContentCache *SourceManager::createMemBufferContentCache(
     std::unique_ptr<llvm::MemoryBuffer> Buffer) {
   // Add a new ContentCache to the MemBufferInfos list and return it.
   ContentCache *Entry = ContentCacheAlloc.Allocate<ContentCache>();
   new (Entry) ContentCache();
   MemBufferInfos.push_back(Entry);
   Entry->setBuffer(std::move(Buffer));
   return Entry;
 }
 
 const SrcMgr::SLocEntry &SourceManager::loadSLocEntry(unsigned Index,
                                                       bool *Invalid) const {
   assert(!SLocEntryLoaded[Index]);
   if (ExternalSLocEntries->ReadSLocEntry(-(static_cast<int>(Index) + 2))) {
     if (Invalid)
       *Invalid = true;
     // If the file of the SLocEntry changed we could still have loaded it.
     if (!SLocEntryLoaded[Index]) {
       // Try to recover; create a SLocEntry so the rest of clang can handle it.
       LoadedSLocEntryTable[Index] = SLocEntry::get(0,
                                  FileInfo::get(SourceLocation(),
                                                getFakeContentCacheForRecovery(),
-                                               SrcMgr::C_User));
+                                               C_User));
     }
   }
 
   return LoadedSLocEntryTable[Index];
 }
 
 std::pair<int, unsigned>
 SourceManager::AllocateLoadedSLocEntries(unsigned NumSLocEntries,

   return FakeBufferForRecovery.get();
 }
 
 /// \brief As part of recovering from missing or changed content, produce a
 /// fake content cache.
 const SrcMgr::ContentCache *
 SourceManager::getFakeContentCacheForRecovery() const {
   if (!FakeContentCacheForRecovery) {
-    FakeContentCacheForRecovery = llvm::make_unique<SrcMgr::ContentCache>();
+    FakeContentCacheForRecovery = llvm::make_unique<ContentCache>();
     FakeContentCacheForRecovery->replaceBuffer(getFakeBufferForRecovery(),
                                                /*DoNotFree=*/true);
   }
   return FakeContentCacheForRecovery.get();
 }
 
 /// \brief Returns the previous in-order FileID or an invalid FileID if there
 /// is no previous one.

          "Ran out of source locations!");
   // See createFileID for that +1.
   NextLocalOffset += TokLength + 1;
   return SourceLocation::getMacroLoc(NextLocalOffset - (TokLength + 1));
 }
 
 llvm::MemoryBuffer *SourceManager::getMemoryBufferForFile(const FileEntry *File,
                                                           bool *Invalid) {
-  const SrcMgr::ContentCache *IR = getOrCreateContentCache(File);
+  const ContentCache *IR = getOrCreateContentCache(File);
   assert(IR && "getOrCreateContentCache() cannot return NULL");
   return IR->getBuffer(Diag, *this, SourceLocation(), Invalid);
 }
 
 void SourceManager::overrideFileContents(const FileEntry *SourceFile,
                                          llvm::MemoryBuffer *Buffer,
                                          bool DoNotFree) {
-  const SrcMgr::ContentCache *IR = getOrCreateContentCache(SourceFile);
+  const ContentCache *IR = getOrCreateContentCache(SourceFile);
   assert(IR && "getOrCreateContentCache() cannot return NULL");
 
-  const_cast<SrcMgr::ContentCache *>(IR)->replaceBuffer(Buffer, DoNotFree);
-  const_cast<SrcMgr::ContentCache *>(IR)->BufferOverridden = true;
+  const_cast<ContentCache *>(IR)->replaceBuffer(Buffer, DoNotFree);
+  const_cast<ContentCache *>(IR)->BufferOverridden = true;
 
   getOverriddenFilesInfo().OverriddenFilesWithBuffer.insert(SourceFile);
 }
 
 void SourceManager::overrideFileContents(const FileEntry *SourceFile,
                                          const FileEntry *NewFile) {
   assert(SourceFile->getSize() == NewFile->getSize() &&
          "Different sizes, use the FileManager to create a virtual file with "
          "the correct size");
   assert(FileInfos.count(SourceFile) == 0 &&
          "This function should be called at the initialization stage, before "
          "any parsing occurs.");
   getOverriddenFilesInfo().OverriddenFiles[SourceFile] = NewFile;
 }
 
 void SourceManager::disableFileContentsOverride(const FileEntry *File) {
   if (!isFileOverridden(File))
     return;
 
-  const SrcMgr::ContentCache *IR = getOrCreateContentCache(File);
-  const_cast<SrcMgr::ContentCache *>(IR)->replaceBuffer(nullptr);
-  const_cast<SrcMgr::ContentCache *>(IR)->ContentsEntry = IR->OrigEntry;
+  const ContentCache *IR = getOrCreateContentCache(File);
+  const_cast<ContentCache *>(IR)->replaceBuffer(nullptr);
+  const_cast<ContentCache *>(IR)->ContentsEntry = IR->OrigEntry;
 
   assert(OverriddenFilesInfo);
   OverriddenFilesInfo->OverriddenFiles.erase(File);
   OverriddenFilesInfo->OverriddenFilesWithBuffer.erase(File);
 }
 
 void SourceManager::setFileIsTransient(const FileEntry *File) {
-  const SrcMgr::ContentCache *CC = getOrCreateContentCache(File);
-  const_cast<SrcMgr::ContentCache *>(CC)->IsTransient = true;
+  const ContentCache *CC = getOrCreateContentCache(File);
+  const_cast<ContentCache *>(CC)->IsTransient = true;
 }
 
 StringRef SourceManager::getBufferData(FileID FID, bool *Invalid) const {
   bool MyInvalid = false;
   const SLocEntry &SLoc = getSLocEntry(FID, &MyInvalid);
   if (!SLoc.isFile() || MyInvalid) {
     if (Invalid) 
       *Invalid = true;

   // completely random and may be a very long way away.
   //
   // To handle this, we do a linear search for up to 8 steps to catch #1 quickly
   // then we fall back to a less cache efficient, but more scalable, binary
   // search to find the location.
 
   // See if this is near the file point - worst case we start scanning from the
   // most newly created FileID.
-  const SrcMgr::SLocEntry *I;
+  const SLocEntry *I;
 
   if (LastFileIDLookup.ID < 0 ||
       LocalSLocEntryTable[LastFileIDLookup.ID].getOffset() < SLocOffset) {
     // Neither loc prunes our search.
     I = LocalSLocEntryTable.end();
   } else {
     // Perhaps it is near the file point.
     I = LocalSLocEntryTable.begin()+LastFileIDLookup.ID;
   }
 
   // Find the FileID that contains this.  "I" is an iterator that points to a
   // FileID whose offset is known to be larger than SLocOffset.
   unsigned NumProbes = 0;
-  while (1) {
+  while (true) {
     --I;
     if (I->getOffset() <= SLocOffset) {
       FileID Res = FileID::get(int(I - LocalSLocEntryTable.begin()));
 
       // If this isn't an expansion, remember it.  We have good locality across
       // FileID lookups.
       if (!I->isExpansion())
         LastFileIDLookup = Res;
       NumLinearScans += NumProbes+1;
       return Res;
     }
     if (++NumProbes == 8)
       break;
   }
 
   // Convert "I" back into an index.  We know that it is an entry whose index is
   // larger than the offset we are looking for.
   unsigned GreaterIndex = I - LocalSLocEntryTable.begin();
   // LessIndex - This is the lower bound of the range that we're searching.
   // We know that the offset corresponding to the FileID is is less than
   // SLocOffset.
   unsigned LessIndex = 0;
   NumProbes = 0;
-  while (1) {
+  while (true) {
     bool Invalid = false;
     unsigned MiddleIndex = (GreaterIndex-LessIndex)/2+LessIndex;
     unsigned MidOffset = getLocalSLocEntry(MiddleIndex, &Invalid).getOffset();
     if (Invalid)
       return FileID::get(0);
     
     ++NumProbes;
 

   if (LastID >= 0 || getLoadedSLocEntryByID(LastID).getOffset() < SLocOffset)
     I = 0;
   else
     I = (-LastID - 2) + 1;
 
   unsigned NumProbes;
   for (NumProbes = 0; NumProbes < 8; ++NumProbes, ++I) {
     // Make sure the entry is loaded!
-    const SrcMgr::SLocEntry &E = getLoadedSLocEntry(I);
+    const SLocEntry &E = getLoadedSLocEntry(I);
     if (E.getOffset() <= SLocOffset) {
       FileID Res = FileID::get(-int(I) - 2);
 
       if (!E.isExpansion())
         LastFileIDLookup = Res;
       NumLinearScans += NumProbes + 1;
       return Res;
     }
   }
 
   // Linear scan failed. Do the binary search. Note the reverse sorting of the
   // table: GreaterIndex is the one where the offset is greater, which is
   // actually a lower index!
   unsigned GreaterIndex = I;
   unsigned LessIndex = LoadedSLocEntryTable.size();
   NumProbes = 0;
-  while (1) {
+  while (true) {
     ++NumProbes;
     unsigned MiddleIndex = (LessIndex - GreaterIndex) / 2 + GreaterIndex;
-    const SrcMgr::SLocEntry &E = getLoadedSLocEntry(MiddleIndex);
+    const SLocEntry &E = getLoadedSLocEntry(MiddleIndex);
     if (E.getOffset() == 0)
       return FileID(); // invalid entry.
 
     ++NumProbes;
 
     if (E.getOffset() > SLocOffset) {
       // Sanity checking, otherwise a bug may lead to hanging in release build.
       if (GreaterIndex == MiddleIndex) {

     if (isMacroArgExpansion(Loc))
       Loc = getImmediateSpellingLoc(Loc);
     else
       Loc = getImmediateExpansionRange(Loc).first;
   } while (!Loc.isFileID());
   return Loc;
 }
 
-
 std::pair<FileID, unsigned>
 SourceManager::getDecomposedExpansionLocSlowCase(
                                              const SrcMgr::SLocEntry *E) const {
   // If this is an expansion record, walk through all the expansion points.
   FileID FID;
   SourceLocation Loc;
   unsigned Offset;
   do {

 /// found.  This should not generally be used by clients.
 SourceLocation SourceManager::getImmediateSpellingLoc(SourceLocation Loc) const{
   if (Loc.isFileID()) return Loc;
   std::pair<FileID, unsigned> LocInfo = getDecomposedLoc(Loc);
   Loc = getSLocEntry(LocInfo.first).getExpansion().getSpellingLoc();
   return Loc.getLocWithOffset(LocInfo.second);
 }
 
-
 /// getImmediateExpansionRange - Loc is required to be an expansion location.
 /// Return the start/end of the expansion information.
 std::pair<SourceLocation,SourceLocation>
 SourceManager::getImmediateExpansionRange(SourceLocation Loc) const {
   assert(Loc.isMacroID() && "Not a macro expansion loc!");
   const ExpansionInfo &Expansion = getSLocEntry(getFileID(Loc)).getExpansion();
   return Expansion.getExpansionLocRange();
 }

   return Res;
 }
 
 bool SourceManager::isMacroArgExpansion(SourceLocation Loc,
                                         SourceLocation *StartLoc) const {
   if (!Loc.isMacroID()) return false;
 
   FileID FID = getFileID(Loc);
-  const SrcMgr::ExpansionInfo &Expansion = getSLocEntry(FID).getExpansion();
+  const ExpansionInfo &Expansion = getSLocEntry(FID).getExpansion();
   if (!Expansion.isMacroArgExpansion()) return false;
 
   if (StartLoc)
     *StartLoc = Expansion.getExpansionLocStart();
   return true;
 }
 
 bool SourceManager::isMacroBodyExpansion(SourceLocation Loc) const {
   if (!Loc.isMacroID()) return false;
 
   FileID FID = getFileID(Loc);
-  const SrcMgr::ExpansionInfo &Expansion = getSLocEntry(FID).getExpansion();
+  const ExpansionInfo &Expansion = getSLocEntry(FID).getExpansion();
   return Expansion.isMacroBodyExpansion();
 }
 
 bool SourceManager::isAtStartOfImmediateMacroExpansion(SourceLocation Loc,
                                              SourceLocation *MacroBegin) const {
   assert(Loc.isValid() && Loc.isMacroID() && "Expected a valid macro loc");
 
   std::pair<FileID, unsigned> DecompLoc = getDecomposedLoc(Loc);
   if (DecompLoc.second > 0)
     return false; // Does not point at the start of expansion range.
 
   bool Invalid = false;
-  const SrcMgr::ExpansionInfo &ExpInfo =
+  const ExpansionInfo &Expansion =
       getSLocEntry(DecompLoc.first, &Invalid).getExpansion();
   if (Invalid)
     return false;
-  SourceLocation ExpLoc = ExpInfo.getExpansionLocStart();
+  SourceLocation ExpLoc = Expansion.getExpansionLocStart();
 
-  if (ExpInfo.isMacroArgExpansion()) {
+  if (Expansion.isMacroArgExpansion()) {
     // For macro argument expansions, check if the previous FileID is part of
     // the same argument expansion, in which case this Loc is not at the
     // beginning of the expansion.
     FileID PrevFID = getPreviousFileID(DecompLoc.first);
     if (!PrevFID.isInvalid()) {
-      const SrcMgr::SLocEntry &PrevEntry = getSLocEntry(PrevFID, &Invalid);
+      const SLocEntry &PrevEntry = getSLocEntry(PrevFID, &Invalid);
       if (Invalid)
         return false;
       if (PrevEntry.isExpansion() &&
           PrevEntry.getExpansion().getExpansionLocStart() == ExpLoc)
         return false;
     }
   }
 
   if (MacroBegin)
     *MacroBegin = ExpLoc;
   return true;
 }
 
 bool SourceManager::isAtEndOfImmediateMacroExpansion(SourceLocation Loc,
                                                SourceLocation *MacroEnd) const {
   assert(Loc.isValid() && Loc.isMacroID() && "Expected a valid macro loc");
 
   FileID FID = getFileID(Loc);
   SourceLocation NextLoc = Loc.getLocWithOffset(1);
   if (isInFileID(NextLoc, FID))
     return false; // Does not point at the end of expansion range.
 
   bool Invalid = false;
-  const SrcMgr::ExpansionInfo &ExpInfo =
-      getSLocEntry(FID, &Invalid).getExpansion();
+  const ExpansionInfo &Expansion = getSLocEntry(FID, &Invalid).getExpansion();
   if (Invalid)
     return false;
 
-  if (ExpInfo.isMacroArgExpansion()) {
+  if (Expansion.isMacroArgExpansion()) {
     // For macro argument expansions, check if the next FileID is part of the
     // same argument expansion, in which case this Loc is not at the end of the
     // expansion.
     FileID NextFID = getNextFileID(FID);
     if (!NextFID.isInvalid()) {
-      const SrcMgr::SLocEntry &NextEntry = getSLocEntry(NextFID, &Invalid);
+      const SLocEntry &NextEntry = getSLocEntry(NextFID, &Invalid);
       if (Invalid)
         return false;
       if (NextEntry.isExpansion() &&
           NextEntry.getExpansion().getExpansionLocStart() ==
-              ExpInfo.getExpansionLocStart())
+              Expansion.getExpansionLocStart())
         return false;
     }
   }
 
   if (MacroEnd)
-    *MacroEnd = ExpInfo.getExpansionLocEnd();
+    *MacroEnd = Expansion.getExpansionLocEnd();
   return true;
 }
 
-
 //===----------------------------------------------------------------------===//
 // Queries about the code at a SourceLocation.
 //===----------------------------------------------------------------------===//
 
 /// getCharacterData - Return a pointer to the start of the specified location
 /// in the appropriate MemoryBuffer.
 const char *SourceManager::getCharacterData(SourceLocation SL,
                                             bool *Invalid) const {

   }
   llvm::MemoryBuffer *Buffer = Entry.getFile().getContentCache()->getBuffer(
       Diag, *this, SourceLocation(), &CharDataInvalid);
   if (Invalid)
     *Invalid = CharDataInvalid;
   return Buffer->getBufferStart() + (CharDataInvalid? 0 : LocInfo.second);
 }
 
-
 /// getColumnNumber - Return the column # for the specified file position.
 /// this is significantly cheaper to compute than the line number.
 unsigned SourceManager::getColumnNumber(FileID FID, unsigned FilePos,
                                         bool *Invalid) const {
   bool MyInvalid = false;
   llvm::MemoryBuffer *MemBuf = getBuffer(FID, &MyInvalid);
   if (Invalid)
     *Invalid = MyInvalid;

 
 #ifdef __SSE2__
 #include <emmintrin.h>
 #endif
 
 static LLVM_ATTRIBUTE_NOINLINE void
 ComputeLineNumbers(DiagnosticsEngine &Diag, ContentCache *FI,
                    llvm::BumpPtrAllocator &Alloc,
-                   const SourceManager &SM, bool &Invalid);
-static void ComputeLineNumbers(DiagnosticsEngine &Diag, ContentCache *FI,
-                               llvm::BumpPtrAllocator &Alloc,
-                               const SourceManager &SM, bool &Invalid) {
+                   const SourceManager &SM, bool &Invalid) {
   // Note that calling 'getBuffer()' may lazily page in the file.
   MemoryBuffer *Buffer = FI->getBuffer(Diag, SM, SourceLocation(), &Invalid);
   if (Invalid)
     return;
 
   // Find the file offsets of all of the *physical* source lines.  This does
   // not look at trigraphs, escaped newlines, or anything else tricky.
   SmallVector<unsigned, 256> LineOffsets;
 
   // Line #1 starts at char 0.
   LineOffsets.push_back(0);
 
   const unsigned char *Buf = (const unsigned char *)Buffer->getBufferStart();
   const unsigned char *End = (const unsigned char *)Buffer->getBufferEnd();
   unsigned Offs = 0;
-  while (1) {
+  while (true) {
     // Skip over the contents of the line.
     const unsigned char *NextBuf = (const unsigned char *)Buf;
 
 #ifdef __SSE2__
     // Try to skip to the next newline using SSE instructions. This is very
     // performance sensitive for programs with lots of diagnostics and in -E
     // mode.
     __m128i CRs = _mm_set1_epi8('\r');

 SourceManager::getFileCharacteristic(SourceLocation Loc) const {
   assert(Loc.isValid() && "Can't get file characteristic of invalid loc!");
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
   bool Invalid = false;
   const SLocEntry &SEntry = getSLocEntry(LocInfo.first, &Invalid);
   if (Invalid || !SEntry.isFile())
     return C_User;
   
-  const SrcMgr::FileInfo &FI = SEntry.getFile();
+  const FileInfo &FI = SEntry.getFile();
 
   // If there are no #line directives in this file, just return the whole-file
   // state.
   if (!FI.hasLineDirectives())
     return FI.getFileCharacteristic();
 
   assert(LineTable && "Can't have linetable entries without a LineTable!");
   // See if there is a #line directive before the location.

 /// for normal clients.
 const char *SourceManager::getBufferName(SourceLocation Loc, 
                                          bool *Invalid) const {
   if (isInvalid(Loc, Invalid)) return "<invalid loc>";
 
   return getBuffer(getFileID(Loc), Invalid)->getBufferIdentifier();
 }
 
-
 /// getPresumedLoc - This method returns the "presumed" location of a
 /// SourceLocation specifies.  A "presumed location" can be modified by \#line
 /// or GNU line marker directives.  This provides a view on the data that a
 /// user should see in diagnostics, for example.
 ///
 /// Note that a presumed location is always given as the expansion point of an
 /// expansion location, not at the spelling location.
 PresumedLoc SourceManager::getPresumedLoc(SourceLocation Loc,
                                           bool UseLineDirectives) const {
   if (Loc.isInvalid()) return PresumedLoc();
 
   // Presumed locations are always for expansion points.
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
 
   bool Invalid = false;
   const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
   if (Invalid || !Entry.isFile())
     return PresumedLoc();
   
-  const SrcMgr::FileInfo &FI = Entry.getFile();
-  const SrcMgr::ContentCache *C = FI.getContentCache();
+  const FileInfo &FI = Entry.getFile();
+  const ContentCache *C = FI.getContentCache();
 
   // To get the source name, first consult the FileEntry (if one exists)
   // before the MemBuffer as this will avoid unnecessarily paging in the
   // MemBuffer.
   const char *Filename;
   if (C->OrigEntry)
     Filename = C->OrigEntry->getName();
   else

   // Presumed locations are always for expansion points.
   std::pair<FileID, unsigned> LocInfo = getDecomposedExpansionLoc(Loc);
 
   bool Invalid = false;
   const SLocEntry &Entry = getSLocEntry(LocInfo.first, &Invalid);
   if (Invalid || !Entry.isFile())
     return false;
 
-  const SrcMgr::FileInfo &FI = Entry.getFile();
+  const FileInfo &FI = Entry.getFile();
 
   // Check if there is a line directive for this location.
   if (FI.hasLineDirectives())
     if (const LineEntry *Entry =
             LineTable->FindNearestLineEntry(LocInfo.first, LocInfo.second))
       if (Entry->IncludeOffset)
         return false;
 
   return FI.getIncludeLoc().isInvalid();
 }
 
 /// \brief The size of the SLocEntry that \p FID represents.
 unsigned SourceManager::getFileIDSize(FileID FID) const {
   bool Invalid = false;
-  const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid);
+  const SLocEntry &Entry = getSLocEntry(FID, &Invalid);
   if (Invalid)
     return 0;
 
   int ID = FID.ID;
   unsigned NextOffset;
   if ((ID > 0 && unsigned(ID+1) == local_sloc_entry_size()))
     NextOffset = getNextLocalOffset();
   else if (ID+1 == -1)

   assert(!CachePtr);
 
   CachePtr = new MacroArgsMap();
   MacroArgsMap &MacroArgsCache = *CachePtr;
   // Initially no macro argument chunk is present.
   MacroArgsCache.insert(std::make_pair(0, SourceLocation()));
 
   int ID = FID.ID;
-  while (1) {
+  while (true) {
     ++ID;
     // Stop if there are no more FileIDs to check.
     if (ID > 0) {
       if (unsigned(ID) >= local_sloc_entry_size())
         return;
     } else if (ID == -1) {
       return;
     }
 
     bool Invalid = false;
-    const SrcMgr::SLocEntry &Entry = getSLocEntryByID(ID, &Invalid);
+    const SLocEntry &Entry = getSLocEntryByID(ID, &Invalid);
     if (Invalid)
       return;
     if (Entry.isFile()) {
       SourceLocation IncludeLoc = Entry.getFile().getIncludeLoc();
       if (IncludeLoc.isInvalid())
         continue;
       if (!isInFileID(IncludeLoc, FID))
         return; // No more files/macros that may be "contained" in this file.
 
       // Skip the files/macros of the #include'd file, we only care about macros
       // that lexed macro arguments from our file.
       if (Entry.getFile().NumCreatedFIDs)
         ID += Entry.getFile().NumCreatedFIDs - 1/*because of next ++ID*/;
       continue;
     }
 
-    const ExpansionInfo &ExpInfo = Entry.getExpansion();
+    const ExpansionInfo &Expansion = Entry.getExpansion();
 
-    if (ExpInfo.getExpansionLocStart().isFileID()) {
-      if (!isInFileID(ExpInfo.getExpansionLocStart(), FID))
+    if (Expansion.getExpansionLocStart().isFileID()) {
+      if (!isInFileID(Expansion.getExpansionLocStart(), FID))
         return; // No more files/macros that may be "contained" in this file.
     }
 
-    if (!ExpInfo.isMacroArgExpansion())
+    if (!Expansion.isMacroArgExpansion())
       continue;
 
     associateFileChunkWithMacroArgExp(MacroArgsCache, FID,
-                                 ExpInfo.getSpellingLoc(),
+                                 Expansion.getSpellingLoc(),
                                  SourceLocation::getMacroLoc(Entry.getOffset()),
                                  getFileIDSize(FileID::get(ID)));
   }
 }
 
 void SourceManager::associateFileChunkWithMacroArgExp(
                                          MacroArgsMap &MacroArgsCache,
                                          FileID FID,
                                          SourceLocation SpellLoc,
                                          SourceLocation ExpansionLoc,
                                          unsigned ExpansionLength) const {
   if (!SpellLoc.isFileID()) {
     unsigned SpellBeginOffs = SpellLoc.getOffset();
     unsigned SpellEndOffs = SpellBeginOffs + ExpansionLength;
 
     // The spelling range for this macro argument expansion can span multiple
     // consecutive FileID entries. Go through each entry contained in the
     // spelling range and if one is itself a macro argument expansion, recurse
     // and associate the file chunk that it represents.
 
     FileID SpellFID; // Current FileID in the spelling range.
     unsigned SpellRelativeOffs;
     std::tie(SpellFID, SpellRelativeOffs) = getDecomposedLoc(SpellLoc);
-    while (1) {
+    while (true) {
       const SLocEntry &Entry = getSLocEntry(SpellFID);
       unsigned SpellFIDBeginOffs = Entry.getOffset();
       unsigned SpellFIDSize = getFileIDSize(SpellFID);
       unsigned SpellFIDEndOffs = SpellFIDBeginOffs + SpellFIDSize;
       const ExpansionInfo &Info = Entry.getExpansion();
       if (Info.isMacroArgExpansion()) {
         unsigned CurrSpellLength;
         if (SpellFIDEndOffs < SpellEndOffs)

 
       // Move to the next FileID entry in the spelling range.
       unsigned advance = SpellFIDSize - SpellRelativeOffs + 1;
       ExpansionLoc = ExpansionLoc.getLocWithOffset(advance);
       ExpansionLength -= advance;
       ++SpellFID.ID;
       SpellRelativeOffs = 0;
     }
-
   }
 
   assert(SpellLoc.isFileID());
 
   unsigned BeginOffs;
   if (!isInFileID(SpellLoc, FID, &BeginOffs))
     return;
 

   std::pair<MapTy::iterator, bool>
     InsertOp = IncludedLocMap.insert(std::make_pair(FID, DecompTy()));
   DecompTy &DecompLoc = InsertOp.first->second;
   if (!InsertOp.second)
     return DecompLoc; // already in map.
 
   SourceLocation UpperLoc;
   bool Invalid = false;
-  const SrcMgr::SLocEntry &Entry = getSLocEntry(FID, &Invalid);
+  const SLocEntry &Entry = getSLocEntry(FID, &Invalid);
   if (!Invalid) {
     if (Entry.isExpansion())
       UpperLoc = Entry.getExpansion().getExpansionLocStart();
     else
       UpperLoc = Entry.getFile().getIncludeLoc();
   }
 
   if (UpperLoc.isValid())

                << NumMacroArgsComputed << " files with macro args computed.\n";
   llvm::errs() << "FileID scans: " << NumLinearScans << " linear, "
                << NumBinaryProbes << " binary.\n";
 }
 
 LLVM_DUMP_METHOD void SourceManager::dump() const {
   llvm::raw_ostream &out = llvm::errs();
 
-  auto DumpSLocEntry = [&](int ID, const SrcMgr::SLocEntry &Entry,
+  auto DumpSLocEntry = [&](int ID, const SLocEntry &Entry,
                            llvm::Optional<unsigned> NextStart) {
     out << "SLocEntry <FileID " << ID << "> " << (Entry.isFile() ? "file" : "expansion")
         << " <SourceLocation " << Entry.getOffset() << ":";
     if (NextStart)
       out << *NextStart << ">\n";
     else
       out << "???\?>\n";
     if (Entry.isFile()) {

lib/Index/IndexDecl.cpp

 //===- IndexDecl.cpp - Indexing declarations ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IndexingContext.h"
-#include "clang/Index/IndexDataConsumer.h"
 #include "clang/AST/DeclVisitor.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Index/IndexSymbol.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Casting.h"
+#include <cassert>
 
 using namespace clang;
 using namespace index;
 
 #define TRY_TO(CALL_EXPR)                                                      \
   do {                                                                         \
     if (!CALL_EXPR)                                                            \
       return false;                                                            \
-  } while (0)
+  } while (false)
 
 namespace {
 
 class IndexingDeclVisitor : public ConstDeclVisitor<IndexingDeclVisitor, bool> {
   IndexingContext &IndexCtx;
 
 public:
   explicit IndexingDeclVisitor(IndexingContext &indexCtx)

     return true;
   }
 
   bool VisitImportDecl(const ImportDecl *D) {
     return IndexCtx.importedModule(D);
   }
 };
 
-} // anonymous namespace
+} // end anonymous namespace
 
 bool IndexingContext::indexDecl(const Decl *D) {
   if (D->isImplicit() && shouldIgnoreIfImplicit(D))
     return true;
 
   if (isTemplateImplicitInstantiation(D))
     return true;
 

lib/Index/IndexTypeSourceInfo.cpp

 //===- IndexTypeSourceInfo.cpp - Indexing types ---------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IndexingContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Index/IndexSymbol.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Casting.h"
+#include <cassert>
 
 using namespace clang;
 using namespace index;
 
 namespace {
 
 class TypeIndexer : public RecursiveASTVisitor<TypeIndexer> {
   IndexingContext &IndexCtx;

                                     Parent, ParentDC, SymbolRoleSet(),
                                     Relations);
   }
 
 #define TRY_TO(CALL_EXPR)                                                      \
   do {                                                                         \
     if (!CALL_EXPR)                                                            \
       return false;                                                            \
-  } while (0)
+  } while (false)
 
   bool traverseParamVarHelper(ParmVarDecl *D) {
     TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
     if (D->getTypeSourceInfo())
       TRY_TO(TraverseTypeLoc(D->getTypeSourceInfo()->getTypeLoc()));
     return true;
   }
 

   }
 
   bool TraverseStmt(Stmt *S) {
     IndexCtx.indexBody(S, Parent, ParentDC);
     return true;
   }
 };
 
-} // anonymous namespace
+} // end anonymous namespace
 
 void IndexingContext::indexTypeSourceInfo(TypeSourceInfo *TInfo,
                                           const NamedDecl *Parent,
                                           const DeclContext *DC,
                                           bool isBase) {
   if (!TInfo || TInfo->getTypeLoc().isNull())
     return;
   

lib/Lex/PTHLexer.cpp

 // This file implements the PTHLexer interface.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Lex/PTHLexer.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemStatCache.h"
 #include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/PTHManager.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/Token.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/EndianStream.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/OnDiskHashTable.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
 #include <memory>
-#include <system_error>
+#include <new>
+#include <utility>
+
 using namespace clang;
 
 static const unsigned StoredTokenSize = 1 + 1 + 2 + 4 + 4;
 
 //===----------------------------------------------------------------------===//
 // PTHLexer methods.
 //===----------------------------------------------------------------------===//
 

   // We assume that if the preprocessor wishes to discard to the end of
   // the line that it also means to end the current preprocessor directive.
   ParsingPreprocessorDirective = false;
 
   // Skip tokens by only peeking at their token kind and the flags.
   // We don't need to actually reconstruct full tokens from the token buffer.
   // This saves some copies and it also reduces IdentifierInfo* lookup.
   const unsigned char* p = CurPtr;
-  while (1) {
+  while (true) {
     // Read the token kind.  Are we at the end of the file?
     tok::TokenKind x = (tok::TokenKind) (uint8_t) *p;
     if (x == tok::eof) break;
 
     // Read the token flags.  Are we at the start of the next line?
     Token::TokenFlags y = (Token::TokenFlags) (uint8_t) p[1];
     if (y & Token::StartOfLine) break;
 

 //===----------------------------------------------------------------------===//
 // PTH file lookup: map from strings to file data.
 //===----------------------------------------------------------------------===//
 
 /// PTHFileLookup - This internal data structure is used by the PTHManager
 ///  to map from FileEntry objects managed by FileManager to offsets within
 ///  the PTH file.
 namespace {
+
 class PTHFileData {
   const uint32_t TokenOff;
   const uint32_t PPCondOff;
+
 public:
   PTHFileData(uint32_t tokenOff, uint32_t ppCondOff)
     : TokenOff(tokenOff), PPCondOff(ppCondOff) {}
 
   uint32_t getTokenOffset() const { return TokenOff; }
   uint32_t getPPCondOffset() const { return PPCondOff; }
 };
 
-
 class PTHFileLookupCommonTrait {
 public:
   typedef std::pair<unsigned char, const char*> internal_key_type;
   typedef unsigned hash_value_type;
   typedef unsigned offset_type;
 
   static hash_value_type ComputeHash(internal_key_type x) {
     return llvm::HashString(x.second);

   return new PTHLexer(*PP, FID, data, ppcond, *this);
 }
 
 //===----------------------------------------------------------------------===//
 // 'stat' caching.
 //===----------------------------------------------------------------------===//
 
 namespace {
+
 class PTHStatData {
 public:
   uint64_t Size;
   time_t ModTime;
   llvm::sys::fs::UniqueID UniqueID;
   const bool HasData;
   bool IsDirectory;
 

   static bool EqualKey(internal_key_type a, internal_key_type b) {
     // When doing 'stat' lookups we don't care about the kind of 'a' and 'b',
     // just the paths.
     return strcmp(a.second, b.second) == 0;
   }
 
   static data_type ReadData(const internal_key_type& k, const unsigned char* d,
                             unsigned) {
-
     if (k.first /* File or Directory */) {
       bool IsDirectory = true;
       if (k.first == 0x1 /* File */) {
         IsDirectory = false;
         d += 4 * 2; // Skip the first 2 words.
       }
 
       using namespace llvm::support;
 
       uint64_t File = endian::readNext<uint64_t, little, unaligned>(d);
       uint64_t Device = endian::readNext<uint64_t, little, unaligned>(d);
       llvm::sys::fs::UniqueID UniqueID(Device, File);
       time_t ModTime = endian::readNext<uint64_t, little, unaligned>(d);
       uint64_t Size = endian::readNext<uint64_t, little, unaligned>(d);
       return data_type(Size, ModTime, UniqueID, IsDirectory);
     }
 
     // Negative stat.  Don't read anything.
     return data_type();
   }
 };
+
 } // end anonymous namespace
 
 namespace clang {
+
 class PTHStatCache : public FileSystemStatCache {
   typedef llvm::OnDiskChainedHashTable<PTHStatLookupTrait> CacheTy;
   CacheTy Cache;
 
 public:
   PTHStatCache(PTHManager::PTHFileLookup &FL)
       : Cache(FL.getNumBuckets(), FL.getNumEntries(), FL.getBuckets(),
               FL.getBase()) {}

     Data.UniqueID = D.UniqueID;
     Data.IsDirectory = D.IsDirectory;
     Data.IsNamedPipe = false;
     Data.InPCH = true;
 
     return CacheExists;
   }
 };
-}
+
+} // end namespace clang
 
 std::unique_ptr<FileSystemStatCache> PTHManager::createStatCache() {
   return llvm::make_unique<PTHStatCache>(*FileLookup);
 }

lib/Parse/ParseCXXInlineMethods.cpp

 //===--- ParseCXXInlineMethods.cpp - C++ class inline methods parsing------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements parsing for C++ class inline methods.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Parse/Parser.h"
 #include "RAIIObjectsForParser.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclTemplate.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/TokenKinds.h"
+#include "clang/Lex/Token.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Sema/DeclSpec.h"
+#include "clang/Sema/Ownership.h"
 #include "clang/Sema/Scope.h"
+#include "clang/Sema/Sema.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+
 using namespace clang;
 
 /// ParseCXXInlineMethodDef - We parsed and verified that the specified
 /// Declarator is a well formed C++ inline method definition. Now lex its body
 /// and store its tokens for parsing after the C++ class is complete.
 NamedDecl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS,
                                       AttributeList *AccessAttrs,
                                       ParsingDeclarator &D,

 /// Returns true if token 'T1' or 'T2' was found.
 /// NOTE: This is a specialized version of Parser::SkipUntil.
 bool Parser::ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2,
                                   CachedTokens &Toks,
                                   bool StopAtSemi, bool ConsumeFinalToken) {
   // We always want this function to consume at least one token if the first
   // token isn't T and if not at EOF.
   bool isFirstTokenConsumed = true;
-  while (1) {
+  while (true) {
     // If we found one of the tokens, stop and return true.
     if (Tok.is(T1) || Tok.is(T2)) {
       if (ConsumeFinalToken) {
         Toks.push_back(Tok);
         ConsumeAnyToken();
       }
       return true;
     }

   bool IsFirstToken = true;
 
   // Number of possible unclosed <s we've seen so far. These might be templates,
   // and might not, but if there were none of them (or we know for sure that
   // we're within a template), we can avoid a tentative parse.
   unsigned AngleCount = 0;
   unsigned KnownTemplateCount = 0;
 
-  while (1) {
+  while (true) {
     switch (Tok.getKind()) {
     case tok::comma:
       // If we might be in a template, perform a tentative parse to check.
       if (!AngleCount)
         // Not a template argument: this is the end of the initializer.
         return true;
       if (KnownTemplateCount)
         goto consume_token;

lib/Parse/ParseDecl.cpp

 //  This file implements the Declaration portions of the Parser interfaces.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Parse/Parser.h"
 #include "RAIIObjectsForParser.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
-#include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/CharInfo.h"
-#include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/ExceptionSpecificationType.h"
+#include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/Specifiers.h"
+#include "clang/Basic/TokenKinds.h"
+#include "clang/Basic/VersionTuple.h"
+#include "clang/Lex/Token.h"
 #include "clang/Parse/ParseDiagnostic.h"
+#include "clang/Sema/AttributeList.h"
+#include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Lookup.h"
+#include "clang/Sema/Ownership.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/PrettyDeclStackTrace.h"
 #include "clang/Sema/Scope.h"
+#include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaDiagnostic.h"
+#include "llvm/ADT/None.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ScopedPrinter.h"
+#include <cassert>
+#include <cstddef>
+#include <memory>
+#include <string>
 
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 // C99 6.7: Declarations.
 //===----------------------------------------------------------------------===//
 
 /// ParseTypeName

     DS.SetRangeEnd(SourceLocation());
   }
 
   bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level);
   bool AttrsLastTime = false;
   ParsedAttributesWithRange attrs(AttrFactory);
   // We use Sema's policy to get bool macros right.
   PrintingPolicy Policy = Actions.getPrintingPolicy();
-  while (1) {
+  while (true) {
     bool isInvalid = false;
     bool isStorageClass = false;
     const char *PrevSpec = nullptr;
     unsigned DiagID = 0;
 
     // HACK: MSVC doesn't consider _Atomic to be a keyword and its STL
     // implementation for VS2013 uses _Atomic as an identifier for one of the
     // classes in <atomic>.
     //
     // A typedef declaration containing _Atomic<...> is among the places where
     // the class is used.  If we are currently parsing such a declaration, treat
     // the token as an identifier.
     if (getLangOpts().MSVCCompat && Tok.is(tok::kw__Atomic) &&
-        DS.getStorageClassSpec() == clang::DeclSpec::SCS_typedef &&
+        DS.getStorageClassSpec() == DeclSpec::SCS_typedef &&
         !DS.hasTypeSpecifier() && GetLookAheadToken(1).is(tok::less))
       Tok.setKind(tok::identifier);
 
     SourceLocation Loc = Tok.getLocation();
 
     switch (Tok.getKind()) {
     default:
     DoneWithDeclSpec:

     assert(!AnonRecord && "Did not expect anonymous struct or union here");
     DS.complete(TheDecl);
     return;
   }
 
   // Read struct-declarators until we find the semicolon.
   bool FirstDeclarator = true;
   SourceLocation CommaLoc;
-  while (1) {
+  while (true) {
     ParsingFieldDeclarator DeclaratorInfo(*this, DS);
     DeclaratorInfo.D.setCommaLoc(CommaLoc);
 
     // Attributes are only allowed here on successive declarators.
     if (!FirstDeclarator)
       MaybeParseGNUAttributes(DeclaratorInfo.D);
 
     /// struct-declarator: declarator

       isCXX11AttributeSpecifier()) {
     ParsedAttributesWithRange attrs(AttrFactory);
     ParseCXX11Attributes(attrs);
     DS.takeAttributesFrom(attrs);
   }
 
   SourceLocation EndLoc;
 
-  while (1) {
+  while (true) {
     bool isInvalid = false;
     const char *PrevSpec = nullptr;
     unsigned DiagID = 0;
     SourceLocation Loc = Tok.getLocation();
 
     switch (Tok.getKind()) {
     case tok::code_completion:
       Actions.CodeCompleteTypeQualifiers(DS);

  PastIdentifier:
   assert(D.isPastIdentifier() &&
          "Haven't past the location of the identifier yet?");
 
   // Don't parse attributes unless we have parsed an unparenthesized name.
   if (D.hasName() && !D.getNumTypeObjects())
     MaybeParseCXX11Attributes(D);
 
-  while (1) {
+  while (true) {
     if (Tok.is(tok::l_paren)) {
       // Enter function-declaration scope, limiting any declarators to the
       // function prototype scope, including parameter declarators.
       ParseScope PrototypeScope(this,
                                 Scope::FunctionPrototypeScope|Scope::DeclScope|
                                 (D.isFunctionDeclaratorAFunctionDeclaration()
                                    ? Scope::FunctionDeclarationScope : 0));
 

lib/Parse/ParseExpr.cpp

 /// operator (e.g. '/') or a ternary operator ("?:").  The unary leaves are
 /// handled by ParseCastExpression, the higher level pieces are handled by
 /// ParseBinaryExpression.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "RAIIObjectsForParser.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/OperatorPrecedence.h"
 #include "clang/Basic/PrettyStackTrace.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Basic/TokenKinds.h"
+#include "clang/Basic/TypeTraits.h"
+#include "clang/Basic/VersionTuple.h"
+#include "clang/Lex/Token.h"
 #include "clang/Parse/Parser.h"
+#include "clang/Sema/AttributeList.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
+#include "clang/Sema/Ownership.h"
 #include "clang/Sema/Scope.h"
+#include "clang/Sema/Sema.h"
 #include "clang/Sema/TypoCorrection.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <algorithm>
+#include <cassert>
+#include <functional>
+
 using namespace clang;
 
 /// \brief Simple precedence-based parser for binary/ternary operators.
 ///
 /// Note: we diverge from the C99 grammar when parsing the assignment-expression
 /// production.  C99 specifies that the LHS of an assignment operator should be
 /// parsed as a unary-expression, but consistency dictates that it be a
 /// conditional-expession.  In practice, the important thing here is that the

 /// precedence of at least \p MinPrec.
 ExprResult
 Parser::ParseRHSOfBinaryExpression(ExprResult LHS, prec::Level MinPrec) {
   prec::Level NextTokPrec = getBinOpPrecedence(Tok.getKind(),
                                                GreaterThanIsOperator,
                                                getLangOpts().CPlusPlus11);
   SourceLocation ColonLoc;
 
-  while (1) {
+  while (true) {
     // If this token has a lower precedence than we are allowed to parse (e.g.
     // because we are called recursively, or because the token is not a binop),
     // then we are done!
     if (NextTokPrec < MinPrec)
       return LHS;
 
     // Consume the operator, saving the operator token for error reporting.
     Token OpToken = Tok;

                                        NotCastExpr,
                                        isTypeCast);
   if (NotCastExpr)
     Diag(Tok, diag::err_expected_expression);
   return Res;
 }
 
 namespace {
+
 class CastExpressionIdValidator : public CorrectionCandidateCallback {
- public:
   CastExpressionIdValidator(Token Next, bool AllowTypes, bool AllowNonTypes)
       : NextToken(Next), AllowNonTypes(AllowNonTypes) {
     WantTypeSpecifiers = WantFunctionLikeCasts = AllowTypes;
   }
 
   bool ValidateCandidate(const TypoCorrection &candidate) override {
     NamedDecl *ND = candidate.getCorrectionDecl();
     if (!ND)

     for (auto *C : candidate) {
       NamedDecl *ND = C->getUnderlyingDecl();
       if (isa<ValueDecl>(ND) && !isa<FunctionDecl>(ND))
         return true;
     }
     return false;
   }
 
- private:
   Token NextToken;
   bool AllowNonTypes;
 };
-}
+
+} // end anonymous namespace
 
 /// \brief Parse a cast-expression, or, if \pisUnaryExpression is true, parse
 /// a unary-expression.
 ///
 /// \p isAddressOfOperand exists because an id-expression that is the operand
 /// of address-of gets special treatment due to member pointers. NotCastExpr
 /// is set to true if the token is not the start of a cast-expression, and no
 /// diagnostic is emitted in this case and no tokens are consumed.

 ///         argument-expression ...[opt]
 ///         argument-expression-list ',' assignment-expression ...[opt]
 /// \endverbatim
 ExprResult
 Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {
   // Now that the primary-expression piece of the postfix-expression has been
   // parsed, see if there are any postfix-expression pieces here.
   SourceLocation Loc;
-  while (1) {
+  while (true) {
     switch (Tok.getKind()) {
     case tok::code_completion:
       if (InMessageExpression)
         return LHS;
         
       Actions.CodeCompletePostfixExpression(getCurScope(), LHS);
       cutOffParsing();
       return ExprError();

     }
   }
 
   // If we get here, the operand to the typeof/sizeof/alignof was an expresion.
   isCastExpr = false;
   return Operand;
 }
 
-
 /// \brief Parse a sizeof or alignof expression.
 ///
 /// \verbatim
 ///       unary-expression:  [C99 6.5.3]
 ///         'sizeof' unary-expression
 ///         'sizeof' '(' type-name ')'
 /// [C++11] 'sizeof' '...' '(' identifier ')'
 /// [GNU]   '__alignof' unary-expression

     SmallVector<Sema::OffsetOfComponent, 4> Comps;
 
     Comps.push_back(Sema::OffsetOfComponent());
     Comps.back().isBrackets = false;
     Comps.back().U.IdentInfo = Tok.getIdentifierInfo();
     Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken();
 
     // FIXME: This loop leaks the index expressions on error.
-    while (1) {
+    while (true) {
       if (Tok.is(tok::period)) {
         // offsetof-member-designator: offsetof-member-designator '.' identifier
         Comps.push_back(Sema::OffsetOfComponent());
         Comps.back().isBrackets = false;
         Comps.back().LocStart = ConsumeToken();
 
         if (Tok.isNot(tok::identifier)) {
           Diag(Tok, diag::err_expected) << tok::identifier;

 /// [C++0x] initializer-clause:
 /// [C++0x]   assignment-expression
 /// [C++0x]   braced-init-list
 /// \endverbatim
 bool Parser::ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,
                                  SmallVectorImpl<SourceLocation> &CommaLocs,
                                  std::function<void()> Completer) {
   bool SawError = false;
-  while (1) {
+  while (true) {
     if (Tok.is(tok::code_completion)) {
       if (Completer)
         Completer();
       else
         Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
       cutOffParsing();
       return true;
     }

 /// \verbatim
 ///       simple-expression-list:
 ///         assignment-expression
 ///         simple-expression-list , assignment-expression
 /// \endverbatim
 bool
 Parser::ParseSimpleExpressionList(SmallVectorImpl<Expr*> &Exprs,
                                   SmallVectorImpl<SourceLocation> &CommaLocs) {
-  while (1) {
+  while (true) {
     ExprResult Expr = ParseAssignmentExpression();
     if (Expr.isInvalid())
       return true;
 
     Exprs.push_back(Expr.get());
 
     if (Tok.isNot(tok::comma))
       return false;

lib/Rewrite/DeltaTree.cpp

 //===--- DeltaTree.cpp - B-Tree for Rewrite Delta tracking ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the DeltaTree and related classes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Rewrite/Core/DeltaTree.h"
 #include "clang/Basic/LLVM.h"
-#include <cstdio>
+#include "llvm/Support/Casting.h"
+#include <cassert>
 #include <cstring>
+
 using namespace clang;
 
 /// The DeltaTree class is a multiway search tree (BTree) structure with some
 /// fancy features.  B-Trees are generally more memory and cache efficient
 /// than binary trees, because they store multiple keys/values in each node.
 ///
 /// DeltaTree implements a key/value mapping from FileIndex to Delta, allowing
 /// fast lookup by FileIndex.  However, an added (important) bonus is that it
 /// can also efficiently tell us the full accumulated delta for a specific
 /// file offset as well, without traversing the whole tree.
 ///
 /// The nodes of the tree are made up of instances of two classes:
 /// DeltaTreeNode and DeltaTreeInteriorNode.  The later subclasses the
 /// former and adds children pointers.  Each node knows the full delta of all
 /// entries (recursively) contained inside of it, which allows us to get the
 /// full delta implied by a whole subtree in constant time.
 
 namespace {
+
   /// SourceDelta - As code in the original input buffer is added and deleted,
   /// SourceDelta records are used to keep track of how the input SourceLocation
   /// object is mapped into the output buffer.
   struct SourceDelta {
     unsigned FileLoc;
     int Delta;
 
     static SourceDelta get(unsigned Loc, int D) {

 
     /// IsLeaf - This is true if this is a leaf of the btree.  If false, this is
     /// an interior node, and is actually an instance of DeltaTreeInteriorNode.
     bool IsLeaf;
 
     /// FullDelta - This is the full delta of all the values in this node and
     /// all children nodes.
     int FullDelta;
+
   public:
     DeltaTreeNode(bool isLeaf = true)
       : NumValuesUsed(0), IsLeaf(isLeaf), FullDelta(0) {}
 
     bool isLeaf() const { return IsLeaf; }
     int getFullDelta() const { return FullDelta; }
     bool isFull() const { return NumValuesUsed == 2*WidthFactor-1; }
 
     unsigned getNumValuesUsed() const { return NumValuesUsed; }
+
     const SourceDelta &getValue(unsigned i) const {
       assert(i < NumValuesUsed && "Invalid value #");
       return Values[i];
     }
     SourceDelta &getValue(unsigned i) {
       assert(i < NumValuesUsed && "Invalid value #");
       return Values[i];
     }
 
     /// DoInsertion - Do an insertion of the specified FileIndex/Delta pair into
     /// this node.  If insertion is easy, do it and return false.  Otherwise,
     /// split the node, populate InsertRes with info about the split, and return
     /// true.
     bool DoInsertion(unsigned FileIndex, int Delta, InsertResult *InsertRes);
 
     void DoSplit(InsertResult &InsertRes);
 
 
     /// RecomputeFullDeltaLocally - Recompute the FullDelta field by doing a
     /// local walk over our contained deltas.
     void RecomputeFullDeltaLocally();
 
     void Destroy();
   };
-} // end anonymous namespace
 
-namespace {
   /// DeltaTreeInteriorNode - When isLeaf = false, a node has child pointers.
   /// This class tracks them.
   class DeltaTreeInteriorNode : public DeltaTreeNode {
     DeltaTreeNode *Children[2*WidthFactor];
+
     ~DeltaTreeInteriorNode() {
       for (unsigned i = 0, e = NumValuesUsed+1; i != e; ++i)
         Children[i]->Destroy();
     }
+
     friend class DeltaTreeNode;
+
   public:
     DeltaTreeInteriorNode() : DeltaTreeNode(false /*nonleaf*/) {}
 
     DeltaTreeInteriorNode(const InsertResult &IR)
       : DeltaTreeNode(false /*nonleaf*/) {
       Children[0] = IR.LHS;
       Children[1] = IR.RHS;
       Values[0] = IR.Split;
       FullDelta = IR.LHS->getFullDelta()+IR.RHS->getFullDelta()+IR.Split.Delta;
       NumValuesUsed = 1;
     }
 
     const DeltaTreeNode *getChild(unsigned i) const {
       assert(i < getNumValuesUsed()+1 && "Invalid child");
       return Children[i];
     }
     DeltaTreeNode *getChild(unsigned i) {
       assert(i < getNumValuesUsed()+1 && "Invalid child");
       return Children[i];
     }
 
     static inline bool classof(const DeltaTreeNode *N) { return !N->isLeaf(); }
   };
-}
 
+} // end anonymous namespace
 
 /// Destroy - A 'virtual' destructor.
 void DeltaTreeNode::Destroy() {
   if (isLeaf())
     delete this;
   else
     delete cast<DeltaTreeInteriorNode>(this);
 }

   NewNode->RecomputeFullDeltaLocally();
   RecomputeFullDeltaLocally();
 
   InsertRes.LHS = this;
   InsertRes.RHS = NewNode;
   InsertRes.Split = Values[WidthFactor-1];
 }
 
-
-
 //===----------------------------------------------------------------------===//
 //                        DeltaTree Implementation
 //===----------------------------------------------------------------------===//
 
 //#define VERIFY_TREE
 
 #ifdef VERIFY_TREE
 /// VerifyTree - Walk the btree performing assertions on various properties to

 /// This includes all insertions or delections that occurred *before* the
 /// specified file index.
 int DeltaTree::getDeltaAt(unsigned FileIndex) const {
   const DeltaTreeNode *Node = getRoot(Root);
 
   int Result = 0;
 
   // Walk down the tree.
-  while (1) {
+  while (true) {
     // For all nodes, include any local deltas before the specified file
     // index by summing them up directly.  Keep track of how many were
     // included.
     unsigned NumValsGreater = 0;
     for (unsigned e = Node->getNumValuesUsed(); NumValsGreater != e;
          ++NumValsGreater) {
       const SourceDelta &Val = Node->getValue(NumValsGreater);
 

   if (MyRoot->DoInsertion(FileIndex, Delta, &InsertRes)) {
     Root = MyRoot = new DeltaTreeInteriorNode(InsertRes);
   }
 
 #ifdef VERIFY_TREE
   VerifyTree(MyRoot);
 #endif
 }
-

lib/Rewrite/HTMLRewrite.cpp

 //== HTMLRewrite.cpp - Translate source code into prettified HTML --*- C++ -*-//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the HTMLRewriter class, which is used to translate the
 //  text of a source file into prettified HTML.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Rewrite/Core/HTMLRewrite.h"
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Lex/Token.h"
 #include "clang/Lex/TokenConcatenation.h"
+#include "clang/Rewrite/Core/RewriteBuffer.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
-#include <memory>
-using namespace clang;
+#include <cassert>
+#include <string>
+#include <utility>
+#include <vector>
 
+using namespace clang;
 
 /// HighlightRange - Highlight a range in the source code with the specified
 /// start/end tags.  B/E must be in the same file.  This ensures that
 /// start/end tags are placed at the start/end of each line if the range is
 /// multiline.
 void html::HighlightRange(Rewriter &R, SourceLocation B, SourceLocation E,
                           const char *StartTag, const char *EndTag) {
   SourceManager &SM = R.getSourceMgr();

 
   // Add one big table tag that surrounds all of the code.
   RB.InsertTextBefore(0, "<table class=\"code\">\n");
   RB.InsertTextAfter(FileEnd - FileBeg, "</table>");
 }
 
 void html::AddHeaderFooterInternalBuiltinCSS(Rewriter& R, FileID FID,
                                              const char *title) {
-
   const llvm::MemoryBuffer *Buf = R.getSourceMgr().getBuffer(FID);
   const char* FileStart = Buf->getBufferStart();
   const char* FileEnd = Buf->getBufferEnd();
 
   SourceLocation StartLoc = R.getSourceMgr().getLocForStartOfFile(FID);
   SourceLocation EndLoc = StartLoc.getLocWithOffset(FileEnd-FileStart);
 
   std::string s;

   const SourceManager &SM = PP.getSourceManager();
   std::vector<Token> TokenStream;
 
   const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
   Lexer L(FID, FromFile, SM, PP.getLangOpts());
 
   // Lex all the tokens in raw mode, to avoid entering #includes or expanding
   // macros.
-  while (1) {
+  while (true) {
     Token Tok;
     L.LexFromRawLexer(Tok);
 
     // If this is a # at the start of a line, discard it from the token stream.
     // We don't want the re-preprocess step to see #defines, #includes or other
     // preprocessor directives.
     if (Tok.is(tok::hash) && Tok.isAtStartOfLine())
       continue;

       Expansion += EscapeText(TmpPP.getSpelling(Tok));
       LineLen += Expansion.size();
 
       PrevPrevTok = PrevTok;
       PrevTok = Tok;
       TmpPP.Lex(Tok);
     }
 
-
     // Insert the expansion as the end tag, so that multi-line macros all get
     // highlighted.
     Expansion = "<span class='expansion'>" + Expansion + "</span></span>";
 
     HighlightRange(R, LLoc.first, LLoc.second,
                    "<span class='macro'>", Expansion.c_str());
   }
 
   // Restore the preprocessor's old state.
   TmpPP.setDiagnostics(*OldDiags);
   TmpPP.setPragmasEnabled(PragmasPreviouslyEnabled);
 }