[clang-tidy] Cleanups utils files

[etienneb]

Summary

Cleanup some code by using appropriate APIs.
Some coding style cleanups.

There is no behavior changes.

• Function IncludeSorter::CreateFixIt can be replaced by FixItHint::CreateReplacement.
• Function cleanPath is a wrapper for llvm::sys::path::remove_dots.

[alexfh]

LG

clang-tidy/utils/DeclRefExprUtils.cpp

 #include "DeclRefExprUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
 namespace clang {
 namespace tidy {
-namespace utils {  
+namespace utils {
 namespace decl_ref_expr {
 
 using namespace ::clang::ast_matchers;
 using llvm::SmallPtrSet;
 
 namespace {
 
 template <typename S> bool isSetDifferenceEmpty(const S &S1, const S &S2) {

clang-tidy/utils/HeaderFileExtensionsUtils.h

 //===--- HeaderFileExtensionsUtils.h - clang-tidy----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADER_FILE_EXTENSIONS_UTILS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADER_FILE_EXTENSIONS_UTILS_H
 
-#include <string>
-
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/SmallSet.h"
-#include "llvm/Support/Path.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
 typedef llvm::SmallSet<llvm::StringRef, 5> HeaderFileExtensionsSet;
 
 /// \brief Checks whether expansion location of Loc is in header file.

clang-tidy/utils/HeaderFileExtensionsUtils.cpp

 //===--- HeaderFileExtensionsUtils.cpp - clang-tidy--------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "HeaderFileExtensionsUtils.h"
 #include "clang/Basic/CharInfo.h"
+#include "llvm/Support/Path.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
 bool isExpansionLocInHeaderFile(
     SourceLocation Loc, const SourceManager &SM,
     const HeaderFileExtensionsSet &HeaderFileExtensions) {

clang-tidy/utils/HeaderGuard.cpp

 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/Path.h"
 
 namespace clang {
 namespace tidy {
 namespace utils {
 
 /// \brief canonicalize a path by removing ./ and ../ components.
-// FIXME: Consider moving this to llvm::sys::path.
 static std::string cleanPath(StringRef Path) {
-  SmallString<256> NewPath;
-  for (auto I = llvm::sys::path::begin(Path), E = llvm::sys::path::end(Path);
-       I != E; ++I) {
-    if (*I == ".")
-      continue;
-    if (*I == "..") {
-      // Drop the last component.
-      NewPath.resize(llvm::sys::path::parent_path(NewPath).size());
-    } else {
-      if (!NewPath.empty() && !NewPath.endswith("/"))
-        NewPath += '/';
-      NewPath += *I;
-    }
-  }
-  return NewPath.str();
+  SmallString<256> Result =  Path;
+  llvm::sys::path::remove_dots(Result, true);
+  return Result.str();
 }
 
 namespace {
 class HeaderGuardPPCallbacks : public PPCallbacks {
 public:
-  explicit HeaderGuardPPCallbacks(Preprocessor *PP, HeaderGuardCheck *Check)
+  HeaderGuardPPCallbacks(Preprocessor *PP, HeaderGuardCheck *Check)
       : PP(PP), Check(Check) {}
 
   void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                    SrcMgr::CharacteristicKind FileType,
                    FileID PrevFID) override {
     // Record all files we enter. We'll need them to diagnose headers without
     // guards.
     SourceManager &SM = PP->getSourceManager();

clang-tidy/utils/IncludeInserter.h

public:
   std::unique_ptr<PPCallbacks> CreatePPCallbacks();
 
   // Creates a Header inclusion directive fixit. Returns None on error or
   // if inclusion directive already exists.
   llvm::Optional<FixItHint>
   CreateIncludeInsertion(FileID FileID, llvm::StringRef Header, bool IsAngled);
 
 private:
-  void AddInclude(StringRef file_name, bool IsAngled,
-                  SourceLocation hash_location, SourceLocation end_location);
+  void AddInclude(StringRef FileName, bool IsAngled,
+                  SourceLocation HashLocation, SourceLocation EndLocation);
 
   llvm::DenseMap<FileID, std::unique_ptr<IncludeSorter>> IncludeSorterByFile;
   llvm::DenseMap<FileID, std::set<std::string>> InsertedHeaders;
   const SourceManager &SourceMgr;
   const LangOptions &LangOpts;
   const IncludeSorter::IncludeStyle Style;
   friend class IncludeInserterCallback;
 };
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDEINSERTER_H

clang-tidy/utils/IncludeInserter.cpp

IncludeSorterByFile.insert(std::make_pair(
         llvm::make_unique<IncludeSorter>(
             &SourceMgr, &LangOpts, FileID,
             SourceMgr.getFilename(SourceMgr.getLocForStartOfFile(FileID)),
             Style)));
   }
   return IncludeSorterByFile[FileID]->CreateIncludeInsertion(Header, IsAngled);
 }
 
-void IncludeInserter::AddInclude(StringRef file_name, bool IsAngled,
+void IncludeInserter::AddInclude(StringRef FileName, bool IsAngled,
                                  SourceLocation HashLocation,
-                                 SourceLocation end_location) {
+                                 SourceLocation EndLocation) {
   FileID FileID = SourceMgr.getFileID(HashLocation);
   if (IncludeSorterByFile.find(FileID) == IncludeSorterByFile.end()) {
     IncludeSorterByFile.insert(std::make_pair(
         FileID, llvm::make_unique<IncludeSorter>(
                     &SourceMgr, &LangOpts, FileID,
                     SourceMgr.getFilename(HashLocation), Style)));
   }
-  IncludeSorterByFile[FileID]->AddInclude(file_name, IsAngled, HashLocation,
-                                          end_location);
+  IncludeSorterByFile[FileID]->AddInclude(FileName, IsAngled, HashLocation,
+                                          EndLocation);
 }
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/IncludeSorter.h

 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H
 
 #include "../ClangTidy.h"
 #include <string>
 
 namespace clang {
 namespace tidy {
-namespace utils {  
+namespace utils {
 
 // Class used by IncludeSorterCallback and IncludeInserterCallback to record the
 // names of the inclusions in a given source file being processed and generate
 // the necessary commands to sort the inclusions according to the precedence
 // enocded in IncludeKinds.
 class IncludeSorter {
 public:
   // Supported include styles.
public:
 
   // Creates a quoted inclusion directive in the right sort order. Returns None
   // on error or if header inclusion directive for header already exists.
   Optional<FixItHint> CreateIncludeInsertion(StringRef FileName, bool IsAngled);
 
 private:
   typedef SmallVector<SourceRange, 1> SourceRangeVector;
 
-  // Creates a fix-it for the given replacements.
-  // Takes the the source location that will be replaced, and the new text.
-  FixItHint CreateFixIt(SourceRange EditRange, const std::string &NewText);
-
   const SourceManager *SourceMgr;
   const LangOptions *LangOpts;
   const IncludeStyle Style;
   FileID CurrentFileID;
   // The file name stripped of common suffixes.
   StringRef CanonicalFile;
   // Locations of visited include directives.
   SourceRangeVector SourceLocations;

clang-tidy/utils/IncludeSorter.cpp

 //===---------- IncludeSorter.cpp - clang-tidy ----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "IncludeSorter.h"
 #include "clang/Lex/Lexer.h"
 
 namespace clang {
 namespace tidy {
-namespace utils {  
+namespace utils {
 
 namespace {
 
 StringRef RemoveFirstSuffix(StringRef Str, ArrayRef<const char *> Suffixes) {
   for (StringRef Suffix : Suffixes) {
     if (Str.endswith(Suffix)) {
       return Str.substr(0, Str.size() - Suffix.size());
     }
if (LineEdit.first == CurrentEndLine + 1 &&
       if (EditRange.getBegin() != EditRange.getEnd()) {
         ++CurrentEndLine;
         CurrentRange.setEnd(EditRange.getEnd());
       }
       CurrentText += LineEdit.second.second;
       // Otherwise report the current block edit and start a new block.
     } else {
       if (CurrentEndLine) {
-        Fixes.push_back(CreateFixIt(CurrentRange, CurrentText));
+        Fixes.push_back(
+            FixItHint::CreateReplacement(CurrentRange, CurrentText));
       }
 
       CurrentEndLine = LineEdit.first;
       CurrentRange = LineEdit.second.first;
       CurrentText = LineEdit.second.second;
     }
   }
   // Finally, report the current block edit if there is one.
   if (CurrentEndLine) {
-    Fixes.push_back(CreateFixIt(CurrentRange, CurrentText));
+    Fixes.push_back(FixItHint::CreateReplacement(CurrentRange, CurrentText));
   }
 
   // Reset the remaining internal state.
   SourceLocations.clear();
   IncludeLocations.clear();
   return Fixes;
 }
 
-// Creates a fix-it for the given replacements.
-// Takes the the source location that will be replaced, and the new text.
-FixItHint IncludeSorter::CreateFixIt(SourceRange EditRange,
-                                     const std::string &NewText) {
-  FixItHint Fix;
-  Fix.RemoveRange = CharSourceRange::getCharRange(EditRange);
-  Fix.CodeToInsert = NewText;
-  return Fix;
-}
-
 IncludeSorter::IncludeStyle
 IncludeSorter::parseIncludeStyle(const std::string &Value) {
   return Value == "llvm" ? IS_LLVM : IS_Google;
 }
 
 StringRef IncludeSorter::toString(IncludeStyle Style) {
   return Style == IS_LLVM ? "llvm" : "google";
 }
 
 } // namespace utils
 } // namespace tidy
 } // namespace clang

clang-tidy/utils/TypeTraits.cpp

for (const CXXBaseSpecifier &Base : ClassDecl->bases()) {
     if (!isTriviallyDefaultConstructible(Base.getType(), Context))
       return false;
   }
 
   return true;
 }
 
 // Based on QualType::isTrivial.
-bool isTriviallyDefaultConstructible(QualType Type, const ASTContext &Context) {
+bool isTriviallyDefaultConstructible(QualType Type,
+                                     const ASTContext &Context) {
   if (Type.isNull())
     return false;
 
   if (Type->isArrayType())
     return isTriviallyDefaultConstructible(Context.getBaseElementType(Type),
                                            Context);
 
   // Return false for incomplete types after skipping any incomplete array