[Clang] Fix Clang-tidy modernize-deprecated-headers warnings; other minor fixes

[Eugene.Zelenko]

Summary

Some Include What You Use suggestions were used too.

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

[aaron.ballman]

include/clang-c/Index.h

19

Is this produced by the deprecated headers check? If not, what value does ctime add over time.h?

lib/Lex/ModuleMap.cpp

1286

namespace instead of namespaces

[Eugene.Zelenko]

include/clang-c/Index.h

19

Yes, since file is include from C and C++.

lib/Lex/ModuleMap.cpp

1286

Will fix in commit.

[Eugene.Zelenko]

Updated from trunk. More Include What You Use warnings fixes.

include/clang-c/Index.h

 #ifndef LLVM_CLANG_C_INDEX_H
 #define LLVM_CLANG_C_INDEX_H
 
+#ifdef __cplusplus
+#include <ctime>
+#else
 #include <time.h>
+#endif
 
 #include "clang-c/Platform.h"
 #include "clang-c/CXErrorCode.h"
 #include "clang-c/CXString.h"
-#include "clang-c/BuildSystem.h"
 
 /**
  * \brief The version constants for the libclang API.

 
   CXEval_UnExposed = 0
 
-} CXEvalResultKind ;
+} CXEvalResultKind;
 
 /**
  * \brief Evaluation result of a cursor

 #ifdef __cplusplus
 }
 #endif
-#endif
+
+#endif /* LLVM_CLANG_C_INDEX_H */

include/clang/Analysis/Analyses/ThreadSafetyTIL.h

-//===- ThreadSafetyTIL.h ---------------------------------------*- C++ --*-===//
+//===- ThreadSafetyTIL.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 // All clang include dependencies for this file must be put in
 // ThreadSafetyUtil.h.
 #include "ThreadSafetyUtil.h"
+#include "clang/AST/Decl.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Casting.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
-#include <stdint.h>
+#include <cstdint>
+#include <iterator>
 #include <utility>
 
-
 namespace clang {
 namespace threadSafety {
 namespace til {
 
-
 /// Enum for the different distinct classes of SExpr
 enum TIL_Opcode {
 #define TIL_OPCODE_DEF(X) COP_##X,

 /// Return the name of a binary opcode.
 StringRef getBinaryOpcodeString(TIL_BinaryOpcode Op);
 
-
 /// ValueTypes are data types that can actually be held in registers.
 /// All variables and expressions must have a value type.
 /// Pointer types are further subdivided into the various heap-allocated

   unsigned char VectSize;  // 0 for scalar, otherwise num elements in vector
 };
 
-
 inline ValueType::SizeType ValueType::getSizeType(unsigned nbytes) {
   switch (nbytes) {
     case 1: return ST_8;

   }
 }
 
-
 template<>
 inline ValueType ValueType::getValueType<void>() {
   return ValueType(BT_Void, ST_0, false, 0);

   return ValueType(BT_Pointer, getSizeType(sizeof(void*)), false, 0);
 }
 
-
 class BasicBlock;
 
-
 /// Base class for AST nodes in the typed intermediate language.
 class SExpr {
 public:

   void *operator new(size_t) = delete;
 };
 
-
 // Contains various helper functions for SExprs.
 namespace ThreadSafetyTIL {
   inline bool isTrivial(const SExpr *E) {
     unsigned Op = E->opcode();
     return Op == COP_Variable || Op == COP_Literal || Op == COP_LiteralPtr;
   }
-}
+} // end namespace ThreadSafetyTIL
 
 // Nodes which declare variables
 class Function;
 class SFunction;
 class Let;
 
-
 /// A named variable, e.g. "x".
 ///
 /// There are two distinct places in which a Variable can appear in the AST.

   const clang::ValueDecl *Cvdecl;  // The clang declaration for this variable.
 };
 
-
 /// Placeholder for an expression that has not yet been created.
 /// Used to implement lazy copy and rewriting strategies.
 class Future : public SExpr {

   SExpr *Result;
 };
 
-
 /// Placeholder for expressions that cannot be represented in the TIL.
 class Undefined : public SExpr {
 public:

   const clang::Stmt *Cstmt;
 };
 
-
 /// Placeholder for a wildcard that matches any other expression.
 class Wildcard : public SExpr {
 public:

   }
 };
 
-
 template <class T> class LiteralT;
 
 // Base class for literal values.

   const clang::Expr *Cexpr;
 };
 
-
 // Derived class for literal values, which stores the actual value.
 template<class T>
 class LiteralT : public Literal {

   T Val;
 };
 
-
-
 template <class V>
 typename V::R_SExpr Literal::traverse(V &Vs, typename V::R_Ctx Ctx) {
   if (Cexpr)

   return Vs.reduceLiteral(*this);
 }
 
-
 /// A Literal pointer to an object allocated in memory.
 /// At compile time, pointer literals are represented by symbolic names.
 class LiteralPtr : public SExpr {

   const clang::ValueDecl *Cvdecl;
 };
 
-
 /// A function -- a.k.a. lambda abstraction.
 /// Functions with multiple arguments are created by currying,
 /// e.g. (Function (x: Int) (Function (y: Int) (Code { return x + y })))

   SExpr* Body;
 };
 
-
 /// A self-applicable function.
 /// A self-applicable function can be applied to itself.  It's useful for
 /// implementing objects and late binding.

   SExpr* Body;
 };
 
-
 /// A block of code -- e.g. the body of a function.
 class Code : public SExpr {
 public:

   SExpr* Body;
 };
 
-
 /// A typed, writable location in memory
 class Field : public SExpr {
 public:

   SExpr* Body;
 };
 
-
 /// Apply an argument to a function.
 /// Note that this does not actually call the function.  Functions are curried,
 /// so this returns a closure in which the first parameter has been applied.

   SExpr* Arg;
 };
 
-
 /// Apply a self-argument to a self-applicable function.
 class SApply : public SExpr {
 public:

   SExpr* Arg;
 };
 
-
 /// Project a named slot from a C++ struct or class.
 class Project : public SExpr {
 public:

   const clang::ValueDecl *Cvdecl;
 };
 
-
 /// Call a function (after all arguments have been applied).
 class Call : public SExpr {
 public:

   const clang::CallExpr *Cexpr;
 };
 
-
 /// Allocate memory for a new value on the heap or stack.
 class Alloc : public SExpr {
 public:

   SExpr* Dtype;
 };
 
-
 /// Load a value from memory.
 class Load : public SExpr {
 public:

   SExpr* Ptr;
 };
 
-
 /// Store a value to memory.
 /// The destination is a pointer to a field, the source is the value to store.
 class Store : public SExpr {

   SExpr* Source;
 };
 
-
 /// If p is a reference to an array, then p[i] is a reference to the i'th
 /// element of the array.
 class ArrayIndex : public SExpr {

   SExpr* Index;
 };
 
-
 /// Pointer arithmetic, restricted to arrays only.
 /// If p is a reference to an array, then p + n, where n is an integer, is
 /// a reference to a subarray.

   SExpr* Index;
 };
 
-
 /// Simple arithmetic unary operations, e.g. negate and not.
 /// These operations have no side-effects.
 class UnaryOp : public SExpr {

   SExpr* Expr0;
 };
 
-
 /// Simple arithmetic binary operations, e.g. +, -, etc.
 /// These operations have no side effects.
 class BinaryOp : public SExpr {

   SExpr* Expr1;
 };
 
-
 /// Cast expressions.
 /// Cast expressions are essentially unary operations, but we treat them
 /// as a distinct AST node because they only change the type of the result.

   SExpr* Expr0;
 };
 
-
 class SCFG;
 
-
 /// Phi Node, for code in SSA form.
 /// Each Phi node has an array of possible values that it can take,
 /// depending on where control flow comes from.

   const clang::ValueDecl* Cvdecl;
 };
 
-
 /// Base class for basic block terminators:  Branch, Goto, and Return.
 class Terminator : public SExpr {
 public:

   }
 };
 
-
 /// Jump to another basic block.
 /// A goto instruction is essentially a tail-recursive call into another
 /// block.  In addition to the block pointer, it specifies an index into the

   unsigned Index;
 };
 
-
 /// A conditional branch to two other blocks.
 /// Note that unlike Goto, Branch does not have an index.  The target blocks
 /// must be child-blocks, and cannot have Phi nodes.

   BasicBlock *Branches[2];
 };
 
-
 /// Return from the enclosing function, passing the return value to the caller.
 /// Only the exit block should end with a return statement.
 class Return : public Terminator {

   SExpr* Retval;
 };
 
-
 inline ArrayRef<BasicBlock*> Terminator::successors() {
   switch (opcode()) {
     case COP_Goto:   return cast<Goto>(this)->successors();

   }
 }
 
-
 /// A basic block is part of an SCFG.  It can be treated as a function in
 /// continuation passing style.  A block consists of a sequence of phi nodes,
 /// which are "arguments" to the function, followed by a sequence of

   void computeDominator();
   void computePostDominator();
 
-private:
   MemRegionRef Arena;        // The arena used to allocate this block.
   SCFG         *CFGPtr;      // The CFG that contains this block.
   int          BlockID : 31; // unique id for this BB in the containing CFG.

   TopologyNode PostDominatorNode;   // The post-dominator tree
 };
 
-
 /// An SCFG is a control-flow graph.  It consists of a set of basic blocks,
 /// each of which terminates in a branch to another basic block.  There is one
 /// entry point, and one exit point.

 private:
   void renumberInstrs();       // assign unique ids to all instructions
 
-private:
   MemRegionRef Arena;
   BlockArray   Blocks;
   BasicBlock   *Entry;

   bool         Normal;
 };
 
-
-
 /// An identifier, e.g. 'foo' or 'x'.
 /// This is a pseduo-term; it will be lowered to a variable or projection.
 class Identifier : public SExpr {

   StringRef Name;
 };
 
-
 /// An if-then-else expression.
 /// This is a pseduo-term; it will be lowered to a branch in a CFG.
 class IfThenElse : public SExpr {

   SExpr* ElseExpr;
 };
 
-
 /// A let-expression,  e.g.  let x=t; u.
 /// This is a pseduo-term; it will be lowered to instructions in a CFG.
 class Let : public SExpr {

   SExpr* Body;
 };
 
-
-
 const SExpr *getCanonicalVal(const SExpr *E);
 SExpr* simplifyToCanonicalVal(SExpr *E);
 void simplifyIncompleteArg(til::Phi *Ph);
 
-
 } // end namespace til
 } // end namespace threadSafety
 } // end namespace clang
 
-#endif
+#endif // LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETYTIL_H

include/clang/Basic/Linkage.h

 /// \brief Defines the Linkage enumeration and various utility functions.
 ///
 //===----------------------------------------------------------------------===//
+
 #ifndef LLVM_CLANG_BASIC_LINKAGE_H
 #define LLVM_CLANG_BASIC_LINKAGE_H
 
-#include <assert.h>
-#include <stdint.h>
 #include <utility>
 
 namespace clang {

include/clang/Basic/TargetBuiltins.h

 #ifndef LLVM_CLANG_BASIC_TARGETBUILTINS_H
 #define LLVM_CLANG_BASIC_TARGETBUILTINS_H
 
-#include <stdint.h>
 #include "clang/Basic/Builtins.h"
+#include <cstdint>
+
 #undef PPC
 
 namespace clang {

 #include "clang/Basic/BuiltinsNEON.def"
     FirstTSBuiltin
   };
-  }
+  } // end namespace NEON
 
   /// \brief ARM builtins
   namespace ARM {

 #include "clang/Basic/BuiltinsARM.def"
       LastTSBuiltin
     };
-  }
+  } // end namespace ARM
 
   /// \brief AArch64 builtins
   namespace AArch64 {

   #include "clang/Basic/BuiltinsAArch64.def"
     LastTSBuiltin
   };
-  }
+  } // end namespace AArch64
 
   /// \brief PPC builtins
   namespace PPC {

 #include "clang/Basic/BuiltinsPPC.def"
         LastTSBuiltin
     };
-  }
+  } // end namespace PPC
 
   /// \brief NVPTX builtins
   namespace NVPTX {

 #include "clang/Basic/BuiltinsNVPTX.def"
         LastTSBuiltin
     };
-  }
+  } // end namespace NVPTX
 
   /// \brief AMDGPU builtins
   namespace AMDGPU {

   #include "clang/Basic/BuiltinsAMDGPU.def"
     LastTSBuiltin
   };
-  }
+  } // end namespace AMDGPU
 
   /// \brief X86 builtins
   namespace X86 {

 #include "clang/Basic/BuiltinsX86.def"
         LastTSBuiltin
     };
-  }
+  } // end namespace X86
 
   /// \brief Flags to identify the types for overloaded Neon builtins.
   ///

     }
 
     EltType getEltType() const { return (EltType)(Flags & EltTypeMask); }
+
     bool isPoly() const {
       EltType ET = getEltType();
       return ET == Poly8 || ET == Poly16;
     }
+
     bool isUnsigned() const { return (Flags & UnsignedFlag) != 0; }
+
     bool isQuad() const { return (Flags & QuadFlag) != 0; }
   };
 

 #include "clang/Basic/BuiltinsHexagon.def"
         LastTSBuiltin
     };
-  }
+  } // end namespace Hexagon
 
   /// \brief MIPS builtins
   namespace Mips {

 #include "clang/Basic/BuiltinsMips.def"
         LastTSBuiltin
     };
-  }
+  } // end namespace Mips
 
   /// \brief XCore builtins
   namespace XCore {

 #include "clang/Basic/BuiltinsXCore.def"
         LastTSBuiltin
     };
-  }
+  } // end namespace XCore
 
   /// \brief Le64 builtins
   namespace Le64 {

   #include "clang/Basic/BuiltinsLe64.def"
     LastTSBuiltin
   };
-  }
+  } // end namespace Le64
 
   /// \brief SystemZ builtins
   namespace SystemZ {

 #include "clang/Basic/BuiltinsSystemZ.def"
         LastTSBuiltin
     };
-  }
+  } // end namespace SystemZ
 
   /// \brief WebAssembly builtins
   namespace WebAssembly {

 #include "clang/Basic/BuiltinsWebAssembly.def"
       LastTSBuiltin
     };
-  }
+  } // end namespace WebAssembly
 
 } // end namespace clang.
 
-#endif
+#endif // LLVM_CLANG_BASIC_TARGETBUILTINS_H

lib/CodeGen/CGOpenCLRuntime.cpp

 
 #include "CGOpenCLRuntime.h"
 #include "CodeGenFunction.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Type.h"
+#include "clang/Basic/AddressSpaces.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalValue.h"
-#include <assert.h>
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <cassert>
+#include <cstdint>
 
 using namespace clang;
 using namespace CodeGen;

 }
 
 llvm::Type *CGOpenCLRuntime::getPipeType() {
-  if (!PipeTy){
+  if (PipeTy == nullptr ) {
     uint32_t PipeAddrSpc =
       CGM.getContext().getTargetAddressSpace(LangAS::opencl_global);
     PipeTy = llvm::PointerType::get(llvm::StructType::create(

lib/Driver/Types.cpp

 
 #include "clang/Driver/Types.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSwitch.h"
 #include <cassert>
-#include <string.h>
+#include <cstring>
 
 using namespace clang::driver;
 using namespace clang::driver::types;

 }
 
 types::ID types::lookupTypeForTypeSpecifier(const char *Name) {
-  for (unsigned i=0; i<numTypes; ++i) {
+  for (unsigned i = 0; i < numTypes; ++i) {
     types::ID Id = (types::ID) (i + 1);
     if (canTypeBeUserSpecified(Id) &&
         strcmp(Name, getInfo(Id).Name) == 0)

lib/Frontend/CodeGenOptions.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Frontend/CodeGenOptions.h"
-#include <string.h>
+#include "llvm/ADT/StringRef.h"
+#include <cstring>
 
 namespace clang {
 

   return false;
 }
 
-}  // end namespace clang
+} // end namespace clang

lib/Frontend/CompilerInstance.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/AST/Decl.h"
 #include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticIDs.h"
+#include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/TargetOptions.h"
 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
 #include "clang/Frontend/ChainedDiagnosticConsumer.h"
+#include "clang/Frontend/CodeGenOptions.h"
+#include "clang/Frontend/CommandLineSourceLoc.h"
+#include "clang/Frontend/DependencyOutputOptions.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
+#include "clang/Frontend/FrontendOptions.h"
 #include "clang/Frontend/LogDiagnosticPrinter.h"
+#include "clang/Frontend/PreprocessorOutputOptions.h"
 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
 #include "clang/Lex/HeaderSearch.h"
+#include "clang/Lex/MacroInfo.h"
+#include "clang/Lex/ModuleMap.h"
 #include "clang/Lex/PTHManager.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Serialization/ASTReader.h"
 #include "clang/Serialization/GlobalModuleIndex.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Errc.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/LockFileManager.h"

 #include "llvm/Support/Signals.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cerrno>
+#include <ctime>
+#include <limits>
+#include <system_error>
+#include <utility>
 #include <sys/stat.h>
-#include <system_error>
-#include <time.h>
 
 using namespace clang;
 

 }
 
 void CompilerInstance::setTarget(TargetInfo *Value) { Target = Value; }
+
 void CompilerInstance::setAuxTarget(TargetInfo *Value) { AuxTarget = Value; }
 
 void CompilerInstance::setFileManager(FileManager *Value) {

 IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
   return ModuleManager;
 }
+
 void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
   ModuleManager = Reader;
 }

 
   return false;
 }
+
 void CompilerInstance::resetAndLeakSema() { BuryPointer(takeSema()); }

lib/Lex/HeaderSearch.cpp

-//===--- HeaderSearch.cpp - Resolve Header File Locations ---===//
+//===--- HeaderSearch.cpp - Resolve Header File Locations -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //

 //===----------------------------------------------------------------------===//
 
 #include "clang/Lex/HeaderSearch.h"
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/Module.h"
+#include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/ExternalPreprocessorSource.h"
 #include "clang/Lex/HeaderMap.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/LexDiagnostic.h"
-#include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Capacity.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <cassert>
 #include <cstdio>
-#if defined(LLVM_ON_UNIX)
-#include <limits.h>
-#endif
+#include <cstring>
+#include <system_error>
+
 using namespace clang;
 
 const IdentifierInfo *

     Filename = StringRef(MappedName.begin(), MappedName.size());
     HasBeenMapped = true;
     Result = HM->LookupFile(Filename, HS.getFileMgr());
-
   } else {
     Result = HS.getFileMgr().getFile(Dest);
   }

   ModMap.setTarget(Target);
 }
 
-
 //===----------------------------------------------------------------------===//
 // Header File Location.
 //===----------------------------------------------------------------------===//

   return ModMap.findModule(Name);
 }
 
-
 HeaderSearch::LoadModuleMapResult 
 HeaderSearch::loadModuleMapFile(StringRef DirName, bool IsSystem,
                                 bool IsFramework) {

lib/Lex/ModuleMap.cpp

 // of a module as it relates to headers.
 //
 //===----------------------------------------------------------------------===//
+
 #include "clang/Lex/ModuleMap.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/DiagnosticIDs.h"
 #include "clang/Basic/FileManager.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
-#include "clang/Basic/TargetOptions.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/LiteralSupport.h"
+#include "clang/Lex/Token.h"
+#include "llvm/ADT/None.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/Allocator.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
-#include <stdlib.h>
-#if defined(LLVM_ON_UNIX)
-#include <limits.h>
-#endif
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <system_error>
+
 using namespace clang;
 
 Module::ExportDecl 

   } else
     ModuleMapFile = getModuleMapFileForUniquing(Parent);
 
-
   // Look for an umbrella header.
   SmallString<128> UmbrellaName = StringRef(FrameworkDir->getName());
   llvm::sys::path::append(UmbrellaName, "Headers", ModuleName + ".h");

 //----------------------------------------------------------------------------//
 
 namespace clang {
+
   /// \brief A token in a module map file.
   struct MMToken {
     enum TokenKind {

     
     bool parseModuleMapFile();
   };
-}
 
+} // end namespace clang
+
 SourceLocation ModuleMapParser::consumeToken() {
 retry:
   SourceLocation Result = Tok.getLocation();

 }
 
 namespace {
+
   /// \brief Enumerates the known attributes.
   enum AttributeKind {
     /// \brief An unknown attribute.

     /// \brief The 'exhaustive' attribute.
     AT_exhaustive
   };
-}
 
+} // end anonymous namespace
+
 /// \brief Parse a module declaration.
 ///
 ///   module-declaration:

   Attributes Attrs;
   if (parseOptionalAttributes(Attrs))
     return;
-
   
   // Parse the opening brace.
   if (!Tok.is(MMToken::LBrace)) {

       Done = true;
       break;
 
-    case MMToken::ExcludeKeyword: {
+    case MMToken::ExcludeKeyword:
       if (ActiveModule) {
         Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
           << (ActiveModule != nullptr);

         .push_back(Tok.getString());
       consumeToken();
       break;
-    }
 
     case MMToken::ExportKeyword:
       if (!ActiveModule) {

lib/Sema/DelayedDiagnostic.cpp

 // This file also defines AccessedEntity.
 //
 //===----------------------------------------------------------------------===//
+
 #include "clang/Sema/DelayedDiagnostic.h"
-#include <string.h>
+#include "llvm/Support/ErrorHandling.h"
+#include <cstring>
+
 using namespace clang;
 using namespace sema;
 

                                     SourceLocation Loc,
                                     const NamedDecl *D,
                                     const ObjCInterfaceDecl *UnknownObjCClass,
-                                    const ObjCPropertyDecl  *ObjCProperty,
+                                    const ObjCPropertyDecl *ObjCProperty,
                                     StringRef Msg,
                                     bool ObjCPropertyAccess) {
   DelayedDiagnostic DD;

lib/Serialization/ASTWriter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Serialization/ASTWriter.h"
-#include "clang/Serialization/ModuleFileExtension.h"
 #include "ASTCommon.h"
 #include "ASTReaderInternals.h"
 #include "MultiOnDiskHashTable.h"
 #include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTUnresolvedSet.h"
+#include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclContextInternals.h"
+#include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclFriend.h"
-#include "clang/AST/DeclLookups.h"
+#include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/AST/LambdaCapture.h"
+#include "clang/AST/NestedNameSpecifier.h"
+#include "clang/AST/RawCommentList.h"
+#include "clang/AST/TemplateName.h"
 #include "clang/AST/Type.h"
+#include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeLocVisitor.h"
+#include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
-#include "clang/Basic/FileSystemStatCache.h"
+#include "clang/Basic/FileSystemOptions.h"
+#include "clang/Basic/Lambda.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/Module.h"
+#include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/SourceManagerInternals.h"
 #include "clang/Basic/TargetInfo.h"

 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/HeaderSearchOptions.h"
 #include "clang/Lex/MacroInfo.h"
+#include "clang/Lex/ModuleMap.h"
 #include "clang/Lex/PreprocessingRecord.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/PreprocessorOptions.h"
+#include "clang/Lex/Token.h"
 #include "clang/Sema/IdentifierResolver.h"
+#include "clang/Sema/ObjCMethodList.h"
 #include "clang/Sema/Sema.h"
+#include "clang/Sema/Weak.h"
 #include "clang/Serialization/ASTReader.h"
+#include "clang/Serialization/Module.h"
+#include "clang/Serialization/ModuleFileExtension.h"
 #include "clang/Serialization/SerializationDiagnostic.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Bitcode/BitCodes.h"
 #include "llvm/Bitcode/BitstreamWriter.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/EndianStream.h"
-#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/OnDiskHashTable.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include <algorithm>
-#include <cstdio>
-#include <string.h>
+#include <cassert>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <deque>
+#include <limits>
+#include <tuple>
 #include <utility>
+#include <vector>
 
 using namespace clang;
 using namespace clang::serialization;

 //===----------------------------------------------------------------------===//
 
 namespace clang {
+
   class ASTTypeWriter {
     ASTWriter &Writer;
     ASTRecordWriter Record;

 #define ABSTRACT_TYPE(Class, Base)
 #include "clang/AST/TypeNodes.def"
   };
+
 } // end namespace clang
 
 void ASTTypeWriter::VisitBuiltinType(const BuiltinType *T) {

 void TypeLocWriter::VisitComplexTypeLoc(ComplexTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitPointerTypeLoc(PointerTypeLoc TL) {
   Record.AddSourceLocation(TL.getStarLoc());
 }
+
 void TypeLocWriter::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
   // nothing to do
 }
+
 void TypeLocWriter::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
   // nothing to do
 }
+
 void TypeLocWriter::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
   Record.AddSourceLocation(TL.getCaretLoc());
 }
+
 void TypeLocWriter::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
   Record.AddSourceLocation(TL.getAmpLoc());
 }
+
 void TypeLocWriter::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
   Record.AddSourceLocation(TL.getAmpAmpLoc());
 }
+
 void TypeLocWriter::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
   Record.AddSourceLocation(TL.getStarLoc());
   Record.AddTypeSourceInfo(TL.getClassTInfo());
 }
+
 void TypeLocWriter::VisitArrayTypeLoc(ArrayTypeLoc TL) {
   Record.AddSourceLocation(TL.getLBracketLoc());
   Record.AddSourceLocation(TL.getRBracketLoc());

                                         DependentSizedExtVectorTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
   Record.AddSourceLocation(TL.getLocalRangeBegin());
   Record.AddSourceLocation(TL.getLParenLoc());

   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i)
     Record.AddDeclRef(TL.getParam(i));
 }
+
 void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
   VisitFunctionTypeLoc(TL);
 }
+
 void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
   VisitFunctionTypeLoc(TL);
 }
+
 void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
   Record.AddSourceLocation(TL.getTypeofLoc());
   Record.AddSourceLocation(TL.getLParenLoc());
   Record.AddSourceLocation(TL.getRParenLoc());
 }
+
 void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
   Record.AddSourceLocation(TL.getTypeofLoc());
   Record.AddSourceLocation(TL.getLParenLoc());

 void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
   Record.AddSourceLocation(TL.getAttrNameLoc());
   if (TL.hasAttrOperand()) {

     Record.AddSourceLocation(TL.getAttrEnumOperandLoc());
   }
 }
+
 void TypeLocWriter::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitSubstTemplateTypeParmTypeLoc(
                                             SubstTemplateTypeParmTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitSubstTemplateTypeParmPackTypeLoc(
                                           SubstTemplateTypeParmPackTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitTemplateSpecializationTypeLoc(
                                            TemplateSpecializationTypeLoc TL) {
   Record.AddSourceLocation(TL.getTemplateKeywordLoc());

     Record.AddTemplateArgumentLocInfo(TL.getArgLoc(i).getArgument().getKind(),
                                       TL.getArgLoc(i).getLocInfo());
 }
+
 void TypeLocWriter::VisitParenTypeLoc(ParenTypeLoc TL) {
   Record.AddSourceLocation(TL.getLParenLoc());
   Record.AddSourceLocation(TL.getRParenLoc());
 }
+
 void TypeLocWriter::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
   Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
   Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
 }
+
 void TypeLocWriter::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
   Record.AddSourceLocation(TL.getElaboratedKeywordLoc());
   Record.AddNestedNameSpecifierLoc(TL.getQualifierLoc());
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitDependentTemplateSpecializationTypeLoc(
        DependentTemplateSpecializationTypeLoc TL) {
   Record.AddSourceLocation(TL.getElaboratedKeywordLoc());

     Record.AddTemplateArgumentLocInfo(TL.getArgLoc(I).getArgument().getKind(),
                                       TL.getArgLoc(I).getLocInfo());
 }
+
 void TypeLocWriter::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
   Record.AddSourceLocation(TL.getEllipsisLoc());
 }
+
 void TypeLocWriter::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
+
 void TypeLocWriter::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
   Record.push_back(TL.hasBaseTypeAsWritten());
   Record.AddSourceLocation(TL.getTypeArgsLAngleLoc());

   for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
     Record.AddSourceLocation(TL.getProtocolLoc(i));
 }
+
 void TypeLocWriter::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
   Record.AddSourceLocation(TL.getStarLoc());
 }
+
 void TypeLocWriter::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
   Record.AddSourceLocation(TL.getKWLoc());
   Record.AddSourceLocation(TL.getLParenLoc());
   Record.AddSourceLocation(TL.getRParenLoc());
 }
+
 void TypeLocWriter::VisitPipeTypeLoc(PipeTypeLoc TL) {
   Record.AddSourceLocation(TL.getKWLoc());
 }

 }
 
 namespace  {
+
   /// \brief An input file.
   struct InputFileEntry {
     const FileEntry *File;

     bool IsTransient;
     bool BufferOverridden;
   };
+
 } // end anonymous namespace
 
 void ASTWriter::WriteInputFiles(SourceManager &SourceMgr,

 }
 
 namespace {
+
   // Trait used for the on-disk hash table of header search information.
   class HeaderFileInfoTrait {
     ASTWriter &Writer;

     const char *strings_begin() const { return FrameworkStringData.begin(); }
     const char *strings_end() const { return FrameworkStringData.end(); }
   };
+
 } // end anonymous namespace
 
 /// \brief Write the header search block for the list of files that 

 //===----------------------------------------------------------------------===//
 
 namespace {
+
 // Trait used for the on-disk hash table used in the method pool.
 class ASTMethodPoolTrait {
   ASTWriter &Writer;

     assert(Out.tell() - Start == DataLen && "Data length is wrong");
   }
 };
+
 } // end anonymous namespace
 
 /// \brief Write ObjC data: selectors and the method pool.

 }
 
 namespace {
+
 class ASTIdentifierTableTrait {
   ASTWriter &Writer;
   Preprocessor &PP;

   /// doesn't check whether the name has macros defined; use PublicMacroIterator
   /// to check that.
   bool isInterestingIdentifier(const IdentifierInfo *II, uint64_t MacroOffset) {
-    if (MacroOffset ||
+    return (MacroOffset ||
             II->isPoisoned() ||
             (IsModule ? II->hasRevertedBuiltin() : II->getObjCOrBuiltinID()) ||
             II->hasRevertedTokenIDToIdentifier() ||
-        (NeedDecls && II->getFETokenInfo<void>()))
-      return true;
-
-    return false;
+            (NeedDecls && II->getFETokenInfo<void>()));
   }
 
 public:

     auto MacroOffset = Writer.getMacroDirectivesOffset(II);
     return isInterestingIdentifier(II, MacroOffset);
   }
+
   bool isInterestingNonMacroIdentifier(const IdentifierInfo *II) {
     return isInterestingIdentifier(II, 0);
   }

     }
   }
 };
+
 } // end anonymous namespace
 
 /// \brief Write the identifier table into the AST file.

 //===----------------------------------------------------------------------===//
 
 namespace {
+
 // Trait used for the on-disk hash table used in the method pool.
 class ASTDeclContextNameLookupTrait {
   ASTWriter &Writer;

     assert(Out.tell() - Start == DataLen && "Data length is wrong");
   }
 };
+
 } // end anonymous namespace
 
 bool ASTWriter::isLookupResultExternal(StoredDeclsList &Result,

   }
 
   Record->push_back(NestedNames.size());
-  while(!NestedNames.empty()) {
+  while (!NestedNames.empty()) {
     NNS = NestedNames.pop_back_val();
     NestedNameSpecifier::SpecifierKind Kind
       = NNS.getNestedNameSpecifier()->getKind();

lib/Tooling/Core/QualTypeNames.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/Core/QualTypeNames.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclBase.h"
+#include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/DeclarationName.h"
-#include "clang/AST/GlobalDecl.h"
-#include "clang/AST/Mangle.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
+#include "clang/AST/NestedNameSpecifier.h"
+#include "clang/AST/PrettyPrinter.h"
+#include "clang/AST/TemplateBase.h"
+#include "clang/AST/TemplateName.h"
+#include "clang/AST/Type.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <cassert>
+#include <string>
 
-#include <stdio.h>
-#include <memory>
-
 namespace clang {
+namespace TypeName {
 
-namespace TypeName {
 /// \brief Generates a QualType that can be used to name the same type
 /// if used at the end of the current translation unit. This ignores
 /// issues such as type shadowing.

tools/libclang/CIndexDiagnostic.h

 |* Implements the diagnostic functions of the Clang C interface.              *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
+
 #ifndef LLVM_CLANG_TOOLS_LIBCLANG_CINDEXDIAGNOSTIC_H
 #define LLVM_CLANG_TOOLS_LIBCLANG_CINDEXDIAGNOSTIC_H
 
+#include "clang-c/CXString.h"
 #include "clang-c/Index.h"
+#include <cassert>
+#include <cstddef>
 #include <memory>
 #include <vector>
-#include <assert.h>
 
 namespace clang {
 

 class CXDiagnosticSetImpl {
   std::vector<std::unique_ptr<CXDiagnosticImpl>> Diagnostics;
   const bool IsExternallyManaged;
+
 public:
   CXDiagnosticSetImpl(bool isManaged = false)
     : IsExternallyManaged(isManaged) {}

 
 } // end namespace clang
 
-#endif
+#endif // LLVM_CLANG_TOOLS_LIBCLANG_CINDEXDIAGNOSTIC_H

unittests/libclang/LibclangTest.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#include "clang-c/BuildSystem.h"
+#include "clang-c/CXErrorCode.h"
 #include "clang-c/Index.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
+#include <cassert>
 #include <fstream>
 #include <set>
+#include <string>
+
 #define DEBUG_TYPE "libclang-test"
 
 TEST(libclang, clang_parseTranslationUnit2_InvalidArgs) {

 }
 
 namespace {
+
 struct TestVFO {
   const char *Contents;
   CXVirtualFileOverlay VFO;

     clang_VirtualFileOverlay_dispose(VFO);
   }
 };
-}
 
+} // end anonymous namespace
+
 TEST(libclang, VirtualFileOverlay_Basic) {
   const char *contents =
       "{\n"

   clang_ModuleMapDescriptor_dispose(MMD);
 }
 
+namespace {
+
 class LibclangReparseTest : public ::testing::Test {
   std::set<std::string> Files;
+
 public:
   std::string TestDir;
   CXIndex Index;

               clang_defaultEditingTranslationUnitOptions();
     Index = clang_createIndex(0, 0);
   }
+
   void TearDown() override {
     clang_disposeTranslationUnit(ClangTU);
     clang_disposeIndex(Index);

       llvm::sys::fs::remove(Path);
     llvm::sys::fs::remove(TestDir);
   }
+
   void WriteFile(std::string &Filename, const std::string &Contents) {
     if (!llvm::sys::path::is_absolute(Filename)) {
       llvm::SmallString<256> Path(TestDir);

     OS << Contents;
     assert(OS.good());
   }
+
   void DisplayDiagnostics() {
     unsigned NumDiagnostics = clang_getNumDiagnostics(ClangTU);
     for (unsigned i = 0; i < NumDiagnostics; ++i) {

       clang_disposeDiagnostic(Diag);
     }
   }
+
   bool ReparseTU(unsigned num_unsaved_files, CXUnsavedFile* unsaved_files) {
     if (clang_reparseTranslationUnit(ClangTU, num_unsaved_files, unsaved_files,
                                      clang_defaultReparseOptions(ClangTU))) {

   }
 };
 
+} // end anonymous namespace
 
 TEST_F(LibclangReparseTest, Reparse) {
   const char *HeaderTop = "#ifndef H\n#define H\nstruct Foo { int bar;";