[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"

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

 #include <algorithm>
 #include <cassert>
 #include <cstddef>
-#include <stdint.h>
+#include <cstdint>
 #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 <cassert>
+#include <cstdint>
 #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 <cstdint>
 #include "clang/Basic/Builtins.h"
 #undef PPC
 

 
 } // end namespace clang.
 
-#endif
+#endif // LLVM_CLANG_BASIC_TARGETBUILTINS_H

lib/CodeGen/CGOpenCLRuntime.cpp

 #include "CodeGenFunction.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalValue.h"
-#include <assert.h>
+#include <cassert>
+#include <cstdint>
 
 using namespace clang;
 using namespace CodeGen;

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;

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

 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 "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>
+
 using namespace clang;
 
 const IdentifierInfo *

   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 "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");

     
     bool parseModuleMapFile();
   };
-}
+} // end namespace clang
 
 SourceLocation ModuleMapParser::consumeToken() {
 retry:

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

   if (parseOptionalAttributes(Attrs))
     return;
 
-  
   // Parse the opening brace.
   if (!Tok.is(MMToken::LBrace)) {
     Diags.Report(Tok.getLocation(), diag::err_mmap_expected_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 <cstring>
+
 using namespace clang;
 using namespace sema;
 

lib/Serialization/ASTWriter.cpp

 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include <algorithm>
-#include <cstdio>
-#include <string.h>
+#include <cstdlib>
+#include <cstring>
+#include <deque>
+#include <limits>
 #include <utility>
 
 using namespace clang;

 void TypeLocWriter::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
   // nothing to do
 }
+
 void TypeLocWriter::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
   Writer.AddSourceLocation(TL.getBuiltinLoc(), Record);
   if (TL.needsExtraLocalData()) {

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

   if (TL.getSizeExpr())
     Writer.AddStmt(TL.getSizeExpr());
 }
+
 void TypeLocWriter::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
+
 void TypeLocWriter::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
+
 void TypeLocWriter::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
+
 void TypeLocWriter::VisitDependentSizedArrayTypeLoc(
                                             DependentSizedArrayTypeLoc TL) {
   VisitArrayTypeLoc(TL);
 }
+
 void TypeLocWriter::VisitDependentSizedExtVectorTypeLoc(
                                         DependentSizedExtVectorTypeLoc TL) {
   Writer.AddSourceLocation(TL.getNameLoc(), Record);
 }
+
 void TypeLocWriter::VisitVectorTypeLoc(VectorTypeLoc TL) {
   Writer.AddSourceLocation(TL.getNameLoc(), Record);
 }
+
 void TypeLocWriter::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
   Writer.AddSourceLocation(TL.getNameLoc(), Record);
 }
+
 void TypeLocWriter::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
   Writer.AddSourceLocation(TL.getLocalRangeBegin(), Record);
   Writer.AddSourceLocation(TL.getLParenLoc(), Record);

   for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i)
     Writer.AddDeclRef(TL.getParam(i), Record);
 }
+
 void TypeLocWriter::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
   VisitFunctionTypeLoc(TL);
 }
+
 void TypeLocWriter::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
   VisitFunctionTypeLoc(TL);
 }
+
 void TypeLocWriter::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
   Writer.AddSourceLocation(TL.getNameLoc(), Record);
 }
+
 void TypeLocWriter::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
   Writer.AddSourceLocation(TL.getNameLoc(), Record);
 }
+
 void TypeLocWriter::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
   Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
   Writer.AddSourceLocation(TL.getLParenLoc(), Record);
   Writer.AddSourceLocation(TL.getRParenLoc(), Record);
 }
+
 void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
   Writer.AddSourceLocation(TL.getTypeofLoc(), Record);
   Writer.AddSourceLocation(TL.getLParenLoc(), Record);
   Writer.AddSourceLocation(TL.getRParenLoc(), Record);
   Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
 }
+
 void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
   Writer.AddSourceLocation(TL.getNameLoc(), Record);
 }
+
 void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
   Writer.AddSourceLocation(TL.getKWLoc(), Record);
   Writer.AddSourceLocation(TL.getLParenLoc(), Record);
   Writer.AddSourceLocation(TL.getRParenLoc(), Record);
   Writer.AddTypeSourceInfo(TL.getUnderlyingTInfo(), Record);
 }
+
 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
   Writer.AddSourceLocation(TL.getNameLoc(), Record);
 }
+
 void TypeLocWriter::VisitRecordTypeLoc(RecordTypeLoc TL) {
   Writer.AddSourceLocation(TL.getNameLoc(), Record);
 }
+
 void TypeLocWriter::VisitEnumTypeLoc(EnumTypeLoc TL) {
   Writer.AddSourceLocation(TL.getNameLoc(), Record);
 }
+
 void TypeLocWriter::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
   Writer.AddSourceLocation(TL.getAttrNameLoc(), Record);
   if (TL.hasAttrOperand()) {

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

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

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

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

lib/Tooling/Core/QualTypeNames.cpp

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
-#include <stdio.h>
+#include <cassert>
+#include <cstdio>
 #include <memory>
 
 namespace clang {

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/Index.h"
+#include <cassert>
 #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