Merging r197483:

------------------------------------------------------------------------
r197483 | yrnkrn | 2013-12-17 00:40:11 -0800 (Tue, 17 Dec 2013) | 8 lines

There are no __register_frame and __deregister_frame functions 
when using structured exception handling (SEH) on Windows 64.

http://llvm-reviews.chandlerc.com/D2378

Patch by Jonathan Liu!


------------------------------------------------------------------------

llvm-svn: 197944

clang-tools-extra/.arcconfig

@@ -1,4 +1,4 @@
 {
   "project_id" : "clang-tools-extra",
-  "conduit_uri" : "http://reviews.llvm.org/"
+  "conduit_uri" : "http://llvm-reviews.chandlerc.com/"
 }

clang-tools-extra/CMakeLists.txt

@@ -1,20 +1,14 @@
+check_library_exists(edit el_init "" HAVE_LIBEDIT)
+
 add_subdirectory(clang-apply-replacements)
 add_subdirectory(clang-modernize)
-add_subdirectory(clang-rename)
-add_subdirectory(modularize)
-add_subdirectory(module-map-checker)
-add_subdirectory(remove-cstr-calls)
-if(CLANG_ENABLE_STATIC_ANALYZER)
-add_subdirectory(clang-tidy)
-endif()
-
 add_subdirectory(clang-query)
+add_subdirectory(clang-tidy)
+add_subdirectory(modularize)
 add_subdirectory(pp-trace)
+add_subdirectory(remove-cstr-calls)
 add_subdirectory(tool-template)
 
 # Add the common testsuite after all the tools.
-# TODO: Support tests with more granularity when features are off?
-if(CLANG_ENABLE_STATIC_ANALYZER)
 add_subdirectory(test)
 add_subdirectory(unittests)
-endif()

clang-tools-extra/LICENSE.TXT

@@ -4,7 +4,7 @@ LLVM Release License
 University of Illinois/NCSA
 Open Source License
 
-Copyright (c) 2007-2014 University of Illinois at Urbana-Champaign.
+Copyright (c) 2007-2013 University of Illinois at Urbana-Champaign.
 All rights reserved.
 
 Developed by:

clang-tools-extra/Makefile

@@ -11,10 +11,9 @@ CLANG_LEVEL := ../..
 
 include $(CLANG_LEVEL)/../../Makefile.config
 
-PARALLEL_DIRS := remove-cstr-calls tool-template modularize \
- module-map-checker pp-trace
-DIRS := clang-apply-replacements clang-modernize clang-rename clang-tidy \
-	clang-query unittests
+PARALLEL_DIRS := remove-cstr-calls tool-template modularize pp-trace
+DIRS := clang-apply-replacements clang-modernize clang-tidy clang-query \
+	unittests
 
 include $(CLANG_LEVEL)/Makefile
 

clang-tools-extra/clang-apply-replacements/CMakeLists.txt

@@ -1,15 +1,19 @@
 set(LLVM_LINK_COMPONENTS
-  Support
+  ${LLVM_TARGETS_TO_BUILD}
+  asmparser
+  bitreader
+  support
+  mc
   )
 
 add_clang_library(clangApplyReplacements
   lib/Tooling/ApplyReplacements.cpp
-
-  LINK_LIBS
-  clangAST
+  )
+target_link_libraries(clangApplyReplacements
+  clangTooling
   clangBasic
-  clangRewrite
-  clangToolingCore
+  clangRewriteFrontend
+  clangFormat
   )
 
 include_directories(

clang-tools-extra/clang-apply-replacements/include/clang-apply-replacements/Tooling/ApplyReplacements.h

@@ -19,9 +19,9 @@
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include <string>
-#include <system_error>
+#include "llvm/Support/system_error.h"
 #include <vector>
+#include <string>
 
 namespace clang {
 
@@ -45,9 +45,8 @@ TUReplacements;
 typedef std::vector<std::string> TUReplacementFiles;
 
 /// \brief Map mapping file name to Replacements targeting that file.
-typedef llvm::DenseMap<const clang::FileEntry *,
-                       std::vector<clang::tooling::Replacement>>
-    FileToReplacementsMap;
+typedef llvm::StringMap<std::vector<clang::tooling::Replacement> >
+FileToReplacementsMap;
 
 /// \brief Recursively descends through a directory structure rooted at \p
 /// Directory and attempts to deserialize *.yaml files as
@@ -66,7 +65,7 @@ typedef llvm::DenseMap<const clang::FileEntry *,
 ///
 /// \returns An error_code indicating success or failure in navigating the
 /// directory structure.
-std::error_code
+llvm::error_code
 collectReplacementsFromDirectory(const llvm::StringRef Directory,
                                  TUReplacements &TUs,
                                  TUReplacementFiles &TURFiles,

clang-tools-extra/clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

@@ -36,7 +36,7 @@ static void eatDiagnostics(const SMDiagnostic &, void *) {}
 namespace clang {
 namespace replace {
 
-std::error_code
+llvm::error_code
 collectReplacementsFromDirectory(const llvm::StringRef Directory,
                                  TUReplacements &TUs,
                                  TUReplacementFiles & TURFiles,
@@ -44,7 +44,7 @@ collectReplacementsFromDirectory(const llvm::StringRef Directory,
   using namespace llvm::sys::fs;
   using namespace llvm::sys::path;
 
-  std::error_code ErrorCode;
+  error_code ErrorCode;
 
   for (recursive_directory_iterator I(Directory, ErrorCode), E;
        I != E && !ErrorCode; I.increment(ErrorCode)) {
@@ -59,15 +59,15 @@ collectReplacementsFromDirectory(const llvm::StringRef Directory,
 
     TURFiles.push_back(I->path());
 
-    ErrorOr<std::unique_ptr<MemoryBuffer>> Out =
-        MemoryBuffer::getFile(I->path());
-    if (std::error_code BufferError = Out.getError()) {
+    OwningPtr<MemoryBuffer> Out;
+    error_code BufferError = MemoryBuffer::getFile(I->path(), Out);
+    if (BufferError) {
       errs() << "Error reading " << I->path() << ": " << BufferError.message()
              << "\n";
       continue;
     }
 
-    yaml::Input YIn(Out.get()->getBuffer(), nullptr, &eatDiagnostics);
+    yaml::Input YIn(Out->getBuffer(), NULL, &eatDiagnostics);
     tooling::TranslationUnitReplacements TU;
     YIn >> TU;
     if (YIn.error()) {
@@ -98,26 +98,29 @@ static void reportConflict(
 
   // FIXME: Output something a little more user-friendly (e.g. unified diff?)
   errs() << "The following changes conflict:\n";
-  for (const tooling::Replacement &R : ConflictingReplacements) {
-    if (R.getLength() == 0) {
-      errs() << "  Insert at " << SM.getLineNumber(FID, R.getOffset()) << ":"
-             << SM.getColumnNumber(FID, R.getOffset()) << " "
-             << R.getReplacementText() << "\n";
+  for (const tooling::Replacement *I = ConflictingReplacements.begin(),
+                                  *E = ConflictingReplacements.end();
+       I != E; ++I) {
+    if (I->getLength() == 0) {
+      errs() << "  Insert at " << SM.getLineNumber(FID, I->getOffset()) << ":"
+             << SM.getColumnNumber(FID, I->getOffset()) << " "
+             << I->getReplacementText() << "\n";
     } else {
-      if (R.getReplacementText().empty())
+      if (I->getReplacementText().empty())
         errs() << "  Remove ";
       else
         errs() << "  Replace ";
 
-      errs() << SM.getLineNumber(FID, R.getOffset()) << ":"
-             << SM.getColumnNumber(FID, R.getOffset()) << "-"
-             << SM.getLineNumber(FID, R.getOffset() + R.getLength() - 1) << ":"
-             << SM.getColumnNumber(FID, R.getOffset() + R.getLength() - 1);
+      errs() << SM.getLineNumber(FID, I->getOffset()) << ":"
+             << SM.getColumnNumber(FID, I->getOffset()) << "-"
+             << SM.getLineNumber(FID, I->getOffset() + I->getLength() - 1)
+             << ":"
+             << SM.getColumnNumber(FID, I->getOffset() + I->getLength() - 1);
 
-      if (R.getReplacementText().empty())
+      if (I->getReplacementText().empty())
         errs() << "\n";
       else
-        errs() << " with \"" << R.getReplacementText() << "\"\n";
+        errs() << " with \"" << I->getReplacementText() << "\"\n";
     }
   }
 }
@@ -137,24 +140,33 @@ static bool deduplicateAndDetectConflicts(FileToReplacementsMap &Replacements,
                                           SourceManager &SM) {
   bool conflictsFound = false;
 
-  for (auto &FileAndReplacements : Replacements) {
-    const FileEntry *Entry = FileAndReplacements.first;
-    auto &Replacements = FileAndReplacements.second;
-    assert(Entry != nullptr && "No file entry!");
+  for (FileToReplacementsMap::iterator I = Replacements.begin(),
+                                       E = Replacements.end();
+       I != E; ++I) {
+
+    const FileEntry *Entry = SM.getFileManager().getFile(I->getKey());
+    if (!Entry) {
+      errs() << "Described file '" << I->getKey()
+             << "' doesn't exist. Ignoring...\n";
+      continue;
+    }
 
     std::vector<tooling::Range> Conflicts;
-    tooling::deduplicate(FileAndReplacements.second, Conflicts);
+    tooling::deduplicate(I->getValue(), Conflicts);
 
     if (Conflicts.empty())
       continue;
 
     conflictsFound = true;
 
-    errs() << "There are conflicting changes to " << Entry->getName() << ":\n";
+    errs() << "There are conflicting changes to " << I->getKey() << ":\n";
 
-    for (const tooling::Range &Conflict : Conflicts) {
-      auto ConflictingReplacements = llvm::makeArrayRef(
-          &Replacements[Conflict.getOffset()], Conflict.getLength());
+    for (std::vector<tooling::Range>::const_iterator
+             ConflictI = Conflicts.begin(),
+             ConflictE = Conflicts.end();
+         ConflictI != ConflictE; ++ConflictI) {
+      ArrayRef<tooling::Replacement> ConflictingReplacements(
+          &I->getValue()[ConflictI->getOffset()], ConflictI->getLength());
       reportConflict(Entry, ConflictingReplacements, SM);
     }
   }
@@ -167,20 +179,14 @@ bool mergeAndDeduplicate(const TUReplacements &TUs,
                          clang::SourceManager &SM) {
 
   // Group all replacements by target file.
-  std::set<StringRef> Warned;
-  for (const auto &TU : TUs) {
-    for (const tooling::Replacement &R : TU.Replacements) {
-      // Use the file manager to deduplicate paths. FileEntries are
-      // automatically canonicalized.
-      const FileEntry *Entry = SM.getFileManager().getFile(R.getFilePath());
-      if (!Entry && Warned.insert(R.getFilePath()).second) {
-        errs() << "Described file '" << R.getFilePath()
-               << "' doesn't exist. Ignoring...\n";
-        continue;
-      }
-      GroupedReplacements[Entry].push_back(R);
-    }
-  }
+  for (TUReplacements::const_iterator TUI = TUs.begin(), TUE = TUs.end();
+       TUI != TUE; ++TUI)
+    for (std::vector<tooling::Replacement>::const_iterator
+             RI = TUI->Replacements.begin(),
+             RE = TUI->Replacements.end();
+         RI != RE; ++RI)
+      GroupedReplacements[RI->getFilePath()].push_back(*RI);
+
 
   // Ask clang to deduplicate and report conflicts.
   if (deduplicateAndDetectConflicts(GroupedReplacements, SM))
@@ -198,8 +204,10 @@ bool applyReplacements(const FileToReplacementsMap &GroupedReplacements,
   // data structure for applying replacements. Rewriter certainly doesn't care.
   // However, until we nail down the design of ReplacementGroups, might as well
   // leave this as is.
-  for (const auto &FileAndReplacements : GroupedReplacements) {
-    if (!tooling::applyAllReplacements(FileAndReplacements.second, Rewrites))
+  for (FileToReplacementsMap::const_iterator I = GroupedReplacements.begin(),
+                                             E = GroupedReplacements.end();
+       I != E; ++I) {
+    if (!tooling::applyAllReplacements(I->getValue(), Rewrites))
       return false;
   }
 
@@ -215,7 +223,11 @@ RangeVector calculateChangedRanges(
   // NOTE: This is O(n^2) in the number of replacements. If this starts to
   // become a problem inline shiftedCodePosition() here and do shifts in a
   // single run through this loop.
-  for (const tooling::Replacement &R : Replaces) {
+  for (std::vector<clang::tooling::Replacement>::const_iterator
+           I = Replaces.begin(),
+           E = Replaces.end();
+       I != E; ++I) {
+    const tooling::Replacement &R = *I;
     unsigned Offset = tooling::shiftedCodePosition(Replaces, R.getOffset());
     unsigned Length = R.getReplacementText().size();
 
@@ -233,10 +245,11 @@ bool writeFiles(const clang::Rewriter &Rewrites) {
     const char *FileName =
         Rewrites.getSourceMgr().getFileEntryForID(BufferI->first)->getName();
 
-    std::error_code EC;
-    llvm::raw_fd_ostream FileStream(FileName, EC, llvm::sys::fs::F_Text);
-    if (EC) {
-      errs() << "Warning: Could not write to " << EC.message() << "\n";
+    std::string ErrorInfo;
+
+    llvm::raw_fd_ostream FileStream(FileName, ErrorInfo);
+    if (!ErrorInfo.empty()) {
+      errs() << "Warning: Could not write to " << FileName << "\n";
       continue;
     }
     BufferI->second.write(FileStream);
@@ -248,12 +261,13 @@ bool writeFiles(const clang::Rewriter &Rewrites) {
 bool deleteReplacementFiles(const TUReplacementFiles &Files,
                             clang::DiagnosticsEngine &Diagnostics) {
   bool Success = true;
-  for (const auto &Filename : Files) {
-    std::error_code Error = llvm::sys::fs::remove(Filename);
+  for (TUReplacementFiles::const_iterator I = Files.begin(), E = Files.end();
+       I != E; ++I) {
+    error_code Error = llvm::sys::fs::remove(*I);
     if (Error) {
       Success = false;
       // FIXME: Use Diagnostics for outputting errors.
-      errs() << "Error deleting file: " << Filename << "\n";
+      errs() << "Error deleting file: " << *I << "\n";
       errs() << Error.message() << "\n";
       errs() << "Please delete the file manually\n";
     }

clang-tools-extra/clang-apply-replacements/tool/CMakeLists.txt

@@ -1,5 +1,9 @@
 set(LLVM_LINK_COMPONENTS
-  Support
+  ${LLVM_TARGETS_TO_BUILD}
+  asmparser
+  bitreader
+  support
+  mc
   )
 
 add_clang_executable(clang-apply-replacements
@@ -7,10 +11,6 @@ add_clang_executable(clang-apply-replacements
   )
 target_link_libraries(clang-apply-replacements
   clangApplyReplacements
-  clangBasic
-  clangFormat
-  clangRewrite
-  clangToolingCore
   )
 
 install(TARGETS clang-apply-replacements

clang-tools-extra/clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp

@@ -199,10 +199,11 @@ int main(int argc, char **argv) {
   // Only include our options in -help output.
   StringMap<cl::Option*> OptMap;
   cl::getRegisteredOptions(OptMap);
-  const char **EndOpts = std::end(OptionsToShow);
-  for (const auto &Opt : OptMap) {
-    if (std::find(OptionsToShow, EndOpts, Opt.getKey()) == EndOpts)
-      Opt.getValue()->setHiddenFlag(cl::ReallyHidden);
+  const char **EndOpts = OptionsToShow + array_lengthof(OptionsToShow);
+  for (StringMap<cl::Option *>::iterator I = OptMap.begin(), E = OptMap.end();
+       I != E; ++I) {
+    if (std::find(OptionsToShow, EndOpts, I->getKey()) == EndOpts)
+      I->getValue()->setHiddenFlag(cl::ReallyHidden);
   }
 
   cl::SetVersionPrinter(&printVersion);
@@ -211,17 +212,17 @@ int main(int argc, char **argv) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions());
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
-      DiagOpts.get());
+      DiagOpts.getPtr());
 
   // Determine a formatting style from options.
   format::FormatStyle FormatStyle;
   if (DoFormat)
-    FormatStyle = format::getStyle(FormatStyleOpt, FormatStyleConfig, "LLVM");
+    FormatStyle = format::getStyle(FormatStyleOpt, FormatStyleConfig);
 
   TUReplacements TUs;
   TUReplacementFiles TURFiles;
 
-  std::error_code ErrorCode =
+  error_code ErrorCode =
       collectReplacementsFromDirectory(Directory, TUs, TURFiles, Diagnostics);
 
   if (ErrorCode) {
@@ -232,7 +233,7 @@ int main(int argc, char **argv) {
 
   // Remove the TUReplacementFiles (triggered by "remove-change-desc-files"
   // command line option) when exiting main().
-  std::unique_ptr<ScopedFileRemover> Remover;
+  OwningPtr<ScopedFileRemover> Remover;
   if (RemoveTUReplacementFiles)
     Remover.reset(new ScopedFileRemover(TURFiles, Diagnostics));
 
@@ -245,34 +246,35 @@ int main(int argc, char **argv) {
 
   Rewriter ReplacementsRewriter(SM, LangOptions());
 
-  for (const auto &FileAndReplacements : GroupedReplacements) {
-    // This shouldn't happen but if a file somehow has no replacements skip to
-    // next file.
-    if (FileAndReplacements.second.empty())
-      continue;
+  for (FileToReplacementsMap::const_iterator I = GroupedReplacements.begin(),
+                                             E = GroupedReplacements.end();
+       I != E; ++I) {
 
     std::string NewFileData;
-    const char *FileName = FileAndReplacements.first->getName();
-    if (!applyReplacements(FileAndReplacements.second, NewFileData,
-                           Diagnostics)) {
-      errs() << "Failed to apply replacements to " << FileName << "\n";
+
+    // This shouldn't happen but if a file somehow has no replacements skip to
+    // next file.
+    if (I->getValue().empty())
+      continue;
+
+    if (!applyReplacements(I->getValue(), NewFileData, Diagnostics)) {
+      errs() << "Failed to apply replacements to " << I->getKey() << "\n";
       continue;
     }
 
     // Apply formatting if requested.
-    if (DoFormat &&
-        !applyFormatting(FileAndReplacements.second, NewFileData, NewFileData,
-                         FormatStyle, Diagnostics)) {
-      errs() << "Failed to apply reformatting replacements for " << FileName
+    if (DoFormat && !applyFormatting(I->getValue(), NewFileData, NewFileData,
+                                     FormatStyle, Diagnostics)) {
+      errs() << "Failed to apply reformatting replacements for " << I->getKey()
              << "\n";
       continue;
     }
 
     // Write new file to disk
-    std::error_code EC;
-    llvm::raw_fd_ostream FileStream(FileName, EC, llvm::sys::fs::F_None);
-    if (EC) {
-      llvm::errs() << "Could not open " << FileName << " for writing\n";
+    std::string ErrorInfo;
+    llvm::raw_fd_ostream FileStream(I->getKey().str().c_str(), ErrorInfo);
+    if (!ErrorInfo.empty()) {
+      llvm::errs() << "Could not open " << I->getKey() << " for writing\n";
       continue;
     }
 

clang-tools-extra/clang-apply-replacements/tool/Makefile

@@ -18,10 +18,9 @@ TOOL_NO_EXPORTS = 1
 SOURCES = ClangApplyReplacementsMain.cpp
 
 LINK_COMPONENTS := $(TARGETS_TO_BUILD) asmparser bitreader support mc mcparser option
-USEDLIBS = clangApplyReplacements.a clangFormat.a \
-	   clangTooling.a clangToolingCore.a clangFrontend.a \
+USEDLIBS = clangApplyReplacements.a clangFormat.a clangTooling.a clangFrontend.a \
 	   clangSerialization.a clangDriver.a clangRewriteFrontend.a \
-	   clangRewrite.a clangParse.a clangSema.a clangAnalysis.a \
+	   clangRewriteCore.a clangParse.a clangSema.a clangAnalysis.a \
 	   clangAST.a clangASTMatchers.a clangEdit.a clangLex.a clangBasic.a
 
 include $(CLANG_LEVEL)/Makefile

clang-tools-extra/clang-modernize/AddOverride/AddOverride.cpp

@@ -16,6 +16,7 @@
 #include "AddOverride.h"
 #include "AddOverrideActions.h"
 #include "AddOverrideMatchers.h"
+
 #include "clang/Frontend/CompilerInstance.h"
 
 using clang::ast_matchers::MatchFinder;
@@ -40,7 +41,7 @@ int AddOverrideTransform::apply(const CompilationDatabase &Database,
   // Make Fixer available to handleBeginSource().
   this->Fixer = &Fixer;
 
-  if (int result = AddOverrideTool.run(createActionFactory(Finder).get())) {
+  if (int result = AddOverrideTool.run(createActionFactory(Finder))) {
     llvm::errs() << "Error encountered during translation.\n";
     return result;
   }
@@ -51,7 +52,7 @@ int AddOverrideTransform::apply(const CompilationDatabase &Database,
 
 bool AddOverrideTransform::handleBeginSource(clang::CompilerInstance &CI,
                                              llvm::StringRef Filename) {
-  assert(Fixer != nullptr && "Fixer must be set");
+  assert(Fixer != NULL && "Fixer must be set");
   Fixer->setPreprocessor(CI.getPreprocessor());
   return Transform::handleBeginSource(CI, Filename);
 }
@@ -69,7 +70,7 @@ struct AddOverrideFactory : TransformFactory {
     }
   }
 
-  Transform *createTransform(const TransformOptions &Opts) override {
+  Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
     return new AddOverrideTransform(Opts);
   }
 };

clang-tools-extra/clang-modernize/AddOverride/AddOverride.h

@@ -32,10 +32,10 @@ public:
 
   /// \see Transform::run().
   virtual int apply(const clang::tooling::CompilationDatabase &Database,
-                    const std::vector<std::string> &SourcePaths) override;
+                    const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
 
   virtual bool handleBeginSource(clang::CompilerInstance &CI,
-                                 llvm::StringRef Filename) override;
+                                 llvm::StringRef Filename) LLVM_OVERRIDE;
 
 private:
   AddOverrideFixer *Fixer;

clang-tools-extra/clang-modernize/AddOverride/AddOverrideActions.cpp

@@ -16,10 +16,11 @@
 #include "AddOverrideActions.h"
 #include "AddOverrideMatchers.h"
 #include "Core/Transform.h"
+
+#include "clang/Basic/CharInfo.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/RecursiveASTVisitor.h"
-#include "clang/Basic/CharInfo.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 
@@ -88,7 +89,7 @@ void AddOverrideFixer::run(const MatchFinder::MatchResult &Result) {
 
   std::string ReplacementText = " override";
   if (DetectMacros) {
-    assert(PP && "No access to Preprocessor object for macro detection");
+    assert(PP != 0 && "No access to Preprocessor object for macro detection");
     clang::TokenValue Tokens[] = { PP->getIdentifierInfo("override") };
     llvm::StringRef MacroName = PP->getLastMacroWithSpelling(StartLoc, Tokens);
     if (!MacroName.empty())

clang-tools-extra/clang-modernize/Core/CMakeLists.txt

@@ -7,13 +7,11 @@ add_clang_library(modernizeCore
   IncludeExcludeInfo.cpp
   PerfSupport.cpp
   IncludeDirectives.cpp
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangFrontend
-  clangLex
-  clangTooling
-  clangToolingCore
+  )
+target_link_libraries(modernizeCore
+  clangFormat
+  clangTooling
+  clangBasic
+  clangASTMatchers
+  clangRewriteFrontend
   )

clang-tools-extra/clang-modernize/Core/IncludeDirectives.cpp

@@ -32,7 +32,7 @@ class IncludeDirectivesPPCallback : public clang::PPCallbacks {
   // Struct helping the detection of header guards in the various callbacks
   struct GuardDetection {
     GuardDetection(FileID FID)
-      : FID(FID), Count(0), TheMacro(nullptr), CountAtEndif(0) {}
+      : FID(FID), Count(0), TheMacro(0), CountAtEndif(0) {}
 
     FileID FID;
     // count for relevant preprocessor directives
@@ -58,16 +58,15 @@ class IncludeDirectivesPPCallback : public clang::PPCallbacks {
   };
 
 public:
-  IncludeDirectivesPPCallback(IncludeDirectives *Self)
-      : Self(Self), Guard(nullptr) {}
-  virtual ~IncludeDirectivesPPCallback() {}
+  IncludeDirectivesPPCallback(IncludeDirectives *Self) : Self(Self), Guard(0) {}
 
 private:
+  virtual ~IncludeDirectivesPPCallback() {}
   void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                           StringRef FileName, bool IsAngled,
                           CharSourceRange FilenameRange, const FileEntry *File,
                           StringRef SearchPath, StringRef RelativePath,
-                          const Module *Imported) override {
+                          const Module *Imported) LLVM_OVERRIDE {
     SourceManager &SM = Self->Sources;
     const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(HashLoc));
     assert(FE && "Valid file expected.");
@@ -80,7 +79,7 @@ private:
   // Keep track of the current file in the stack
   virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
                            SrcMgr::CharacteristicKind FileType,
-                           FileID PrevFID) override {
+                           FileID PrevFID) {
     SourceManager &SM = Self->Sources;
     switch (Reason) {
     case EnterFile:
@@ -116,8 +115,7 @@ private:
     // checking for equality because it can also be part of the preamble if the
     // preamble is the whole file.
     unsigned Preamble =
-        Lexer::ComputePreamble(SM.getBuffer(Guard.FID)->getBuffer(), LangOpts)
-            .first;
+        Lexer::ComputePreamble(SM.getBuffer(Guard.FID), LangOpts).first;
     unsigned IfndefOffset = SM.getFileOffset(Guard.IfndefLoc);
     if (IfndefOffset > (Preamble + 1))
       return;
@@ -144,13 +142,13 @@ private:
   }
 
   virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
-                      const MacroDirective *MD) override {
+                      const MacroDirective *MD) {
     Guard->Count++;
 
     // If this #ifndef is the top-most directive and the symbol isn't defined
     // store those information in the guard detection, the next step will be to
     // check for the define.
-    if (Guard->Count == 1 && MD == nullptr) {
+    if (Guard->Count == 1 && MD == 0) {
       IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
 
       if (MII->hasMacroDefinition())
@@ -161,13 +159,13 @@ private:
   }
 
   virtual void MacroDefined(const Token &MacroNameTok,
-                            const MacroDirective *MD) override {
+                            const MacroDirective *MD) {
     Guard->Count++;
 
     // If this #define is the second directive of the file and the symbol
     // defined is the same as the one checked in the #ifndef then store the
     // information about this define.
-    if (Guard->Count == 2 && Guard->TheMacro != nullptr) {
+    if (Guard->Count == 2 && Guard->TheMacro != 0) {
       IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
 
       // macro unrelated to the ifndef, doesn't look like a proper header guard
@@ -178,7 +176,7 @@ private:
     }
   }
 
-  void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
+  virtual void Endif(SourceLocation Loc, SourceLocation IfLoc) {
     Guard->Count++;
 
     // If it's the #endif corresponding to the top-most #ifndef
@@ -197,32 +195,23 @@ private:
   }
 
   virtual void MacroExpands(const Token &, const MacroDirective *, SourceRange,
-                            const MacroArgs *) override {
+                            const MacroArgs *) {
     Guard->Count++;
   }
-  virtual void MacroUndefined(const Token &,
-                              const MacroDirective *) override {
+  virtual void MacroUndefined(const Token &, const MacroDirective *) {
     Guard->Count++;
   }
-  virtual void Defined(const Token &, const MacroDirective *,
-                       SourceRange) override {
+  virtual void Defined(const Token &, const MacroDirective *, SourceRange) {
     Guard->Count++;
   }
-  virtual void If(SourceLocation, SourceRange,
-                  ConditionValueKind) override {
+  virtual void If(SourceLocation, SourceRange, bool) { Guard->Count++; }
+  virtual void Elif(SourceLocation, SourceRange, bool, SourceLocation) {
     Guard->Count++;
   }
-  virtual void Elif(SourceLocation, SourceRange, ConditionValueKind,
-                    SourceLocation) override {
-    Guard->Count++;
-  }
-  virtual void Ifdef(SourceLocation, const Token &,
-                     const MacroDirective *) override {
-    Guard->Count++;
-  }
-  void Else(SourceLocation, SourceLocation) override {
+  virtual void Ifdef(SourceLocation, const Token &, const MacroDirective *) {
     Guard->Count++;
   }
+  virtual void Else(SourceLocation, SourceLocation) { Guard->Count++; }
 
   IncludeDirectives *Self;
   // keep track of the guard info through the include stack
@@ -311,8 +300,7 @@ static std::pair<unsigned, bool> findDirectiveEnd(SourceLocation HashLoc,
 IncludeDirectives::IncludeDirectives(clang::CompilerInstance &CI)
     : CI(CI), Sources(CI.getSourceManager()) {
   // addPPCallbacks takes ownership of the callback
-  CI.getPreprocessor().addPPCallbacks(
-                          llvm::make_unique<IncludeDirectivesPPCallback>(this));
+  CI.getPreprocessor().addPPCallbacks(new IncludeDirectivesPPCallback(this));
 }
 
 bool IncludeDirectives::lookForInclude(const FileEntry *File,
@@ -366,7 +354,7 @@ Replacement IncludeDirectives::addAngledInclude(const clang::FileEntry *File,
     return Replacement();
 
   unsigned Offset, NLFlags;
-  std::tie(Offset, NLFlags) = angledIncludeInsertionOffset(FID);
+  llvm::tie(Offset, NLFlags) = angledIncludeInsertionOffset(FID);
 
   StringRef EOL = guessEOL(Sources, FID);
   llvm::SmallString<32> InsertionText;

clang-tools-extra/clang-modernize/Core/IncludeDirectives.h

@@ -19,8 +19,8 @@
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include <vector>
 
 namespace clang {

clang-tools-extra/clang-modernize/Core/IncludeExcludeInfo.cpp

@@ -82,8 +82,8 @@ std::string removeRelativeOperators(StringRef Path) {
 
 /// \brief Helper function to tokenize a string of paths and populate
 /// the vector.
-std::error_code parseCLInput(StringRef Line, std::vector<std::string> &List,
-                             StringRef Separator) {
+error_code parseCLInput(StringRef Line, std::vector<std::string> &List,
+                        StringRef Separator) {
   SmallVector<StringRef, 32> Tokens;
   Line.split(Tokens, Separator, /*MaxSplit=*/ -1, /*KeepEmpty=*/ false);
   for (SmallVectorImpl<StringRef>::iterator I = Tokens.begin(),
@@ -91,7 +91,7 @@ std::error_code parseCLInput(StringRef Line, std::vector<std::string> &List,
        I != E; ++I) {
     // Convert each path to its absolute path.
     PathString Path = I->rtrim();
-    if (std::error_code Err = sys::fs::make_absolute(Path))
+    if (error_code Err = sys::fs::make_absolute(Path))
       return Err;
     // Remove relative operators from the path.
     std::string AbsPath = removeRelativeOperators(Path);
@@ -103,50 +103,44 @@ std::error_code parseCLInput(StringRef Line, std::vector<std::string> &List,
 
     llvm::errs() << "Parse: " <<List.back() << "\n";
   }
-  return std::error_code();
+  return error_code::success();
 }
 } // end anonymous namespace
 
-std::error_code
-IncludeExcludeInfo::readListFromString(StringRef IncludeString,
-                                       StringRef ExcludeString) {
-  if (std::error_code Err = parseCLInput(IncludeString, IncludeList,
-                                         /*Separator=*/","))
+error_code IncludeExcludeInfo::readListFromString(StringRef IncludeString,
+                                                  StringRef ExcludeString) {
+  if (error_code Err = parseCLInput(IncludeString, IncludeList,
+                                    /*Separator=*/ ","))
     return Err;
-  if (std::error_code Err = parseCLInput(ExcludeString, ExcludeList,
-                                         /*Separator=*/","))
+  if (error_code Err = parseCLInput(ExcludeString, ExcludeList,
+                                    /*Separator=*/ ","))
     return Err;
-  return std::error_code();
+  return error_code::success();
 }
 
-std::error_code
-IncludeExcludeInfo::readListFromFile(StringRef IncludeListFile,
-                                     StringRef ExcludeListFile) {
+error_code IncludeExcludeInfo::readListFromFile(StringRef IncludeListFile,
+                                                StringRef ExcludeListFile) {
   if (!IncludeListFile.empty()) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> FileBuf =
-        MemoryBuffer::getFile(IncludeListFile);
-    if (std::error_code Err = FileBuf.getError()) {
+    OwningPtr<MemoryBuffer> FileBuf;
+    if (error_code Err = MemoryBuffer::getFile(IncludeListFile, FileBuf)) {
       errs() << "Unable to read from include file.\n";
       return Err;
     }
-    if (std::error_code Err =
-            parseCLInput(FileBuf.get()->getBuffer(), IncludeList,
-                         /*Separator=*/"\n"))
+    if (error_code Err = parseCLInput(FileBuf->getBuffer(), IncludeList,
+                                      /*Separator=*/ "\n"))
       return Err;
   }
   if (!ExcludeListFile.empty()) {
-    ErrorOr<std::unique_ptr<MemoryBuffer>> FileBuf =
-        MemoryBuffer::getFile(ExcludeListFile);
-    if (std::error_code Err = FileBuf.getError()) {
+    OwningPtr<MemoryBuffer> FileBuf;
+    if (error_code Err = MemoryBuffer::getFile(ExcludeListFile, FileBuf)) {
       errs() << "Unable to read from exclude file.\n";
       return Err;
     }
-    if (std::error_code Err =
-            parseCLInput(FileBuf.get()->getBuffer(), ExcludeList,
-                         /*Separator=*/"\n"))
+    if (error_code Err = parseCLInput(FileBuf->getBuffer(), ExcludeList,
+                                      /*Separator=*/ "\n"))
       return Err;
   }
-  return std::error_code();
+  return error_code::success();
 }
 
 bool IncludeExcludeInfo::isFileIncluded(StringRef FilePath) const {

clang-tools-extra/clang-modernize/Core/IncludeExcludeInfo.h

@@ -17,7 +17,7 @@
 #define CLANG_MODERNIZE_INCLUDEEXCLUDEINFO_H
 
 #include "llvm/ADT/StringRef.h"
-#include <system_error>
+#include "llvm/Support/system_error.h"
 #include <vector>
 
 /// \brief Class encapsulating the handling of include and exclude paths
@@ -29,16 +29,16 @@ public:
   ///
   /// Returns error_code::success() on successful parse of the strings or
   /// an error_code indicating the encountered error.
-  std::error_code readListFromString(llvm::StringRef IncludeString,
-                                     llvm::StringRef ExcludeString);
+  llvm::error_code readListFromString(llvm::StringRef IncludeString,
+                                      llvm::StringRef ExcludeString);
 
   /// \brief Read and parse the lists of paths from \a IncludeListFile
   /// and \a ExcludeListFile. Each file should contain one path per line.
   ///
   /// Returns error_code::success() on successful read and parse of both files
   /// or an error_code indicating the encountered error.
-  std::error_code readListFromFile(llvm::StringRef IncludeListFile,
-                                   llvm::StringRef ExcludeListFile);
+  llvm::error_code readListFromFile(llvm::StringRef IncludeListFile,
+                                    llvm::StringRef ExcludeListFile);
 
   /// \brief Determine if the given path is in the list of include paths but
   /// not in the list of exclude paths.

clang-tools-extra/clang-modernize/Core/PerfSupport.cpp

@@ -15,9 +15,9 @@
 #include "PerfSupport.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/Path.h"
 
 void collectSourcePerfData(const Transform &T, SourcePerfData &Data) {
   for (Transform::TimingVec::const_iterator I = T.timing_begin(),
@@ -50,8 +50,8 @@ void writePerfDataJSON(
   SS << DirectoryName << "/" << static_cast<int>(T.getWallTime()) << "_" << Pid
      << ".json";
 
-  std::error_code EC;
-  llvm::raw_fd_ostream FileStream(SS.str(), EC, llvm::sys::fs::F_Text);
+  std::string ErrorInfo;
+  llvm::raw_fd_ostream FileStream(SS.str().c_str(), ErrorInfo);
   FileStream << "{\n";
   FileStream << "  \"Sources\" : [\n";
   for (SourcePerfData::const_iterator I = TimingResults.begin(),

clang-tools-extra/clang-modernize/Core/PerfSupport.h

@@ -18,6 +18,7 @@
 
 #include "Transform.h"
 #include "llvm/ADT/StringRef.h"
+
 #include <map>
 #include <vector>
 

clang-tools-extra/clang-modernize/Core/ReplacementHandling.cpp

@@ -18,22 +18,21 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
-#include <system_error>
+#include "llvm/Support/system_error.h"
 
 using namespace llvm;
 using namespace llvm::sys;
 using namespace clang::tooling;
 
 bool ReplacementHandling::findClangApplyReplacements(const char *Argv0) {
-  ErrorOr<std::string> CARPathOrErr =
-      findProgramByName("clang-apply-replacements");
-  if (!CARPathOrErr)
+  CARPath = FindProgramByName("clang-apply-replacements");
+
+  if (!CARPath.empty())
     return true;
 
-  CARPath = *CARPathOrErr;
   static int StaticSymbol;
-  std::string ClangModernizePath = fs::getMainExecutable(Argv0, &StaticSymbol);
-  SmallString<128> TestPath = path::parent_path(ClangModernizePath);
+  CARPath = fs::getMainExecutable(Argv0, &StaticSymbol);
+  SmallString<128> TestPath = path::parent_path(CARPath);
   path::append(TestPath, "clang-apply-replacements");
   if (fs::can_execute(Twine(TestPath)))
     CARPath = TestPath.str();
@@ -73,10 +72,11 @@ bool ReplacementHandling::serializeReplacements(
       continue;
     }
 
-    std::error_code EC;
-    raw_fd_ostream ReplacementsFile(ReplacementsFileName, EC, fs::F_None);
-    if (EC) {
-      errs() << "Error opening file: " << EC.message() << "\n";
+    std::string ErrorInfo;
+    raw_fd_ostream ReplacementsFile(ReplacementsFileName.c_str(), ErrorInfo,
+                                    fs::F_Binary);
+    if (!ErrorInfo.empty()) {
+      errs() << "Error opening file: " << ErrorInfo << "\n";
       Errors = true;
       continue;
     }
@@ -101,12 +101,12 @@ bool ReplacementHandling::applyReplacements() {
   Argv.push_back(DestinationDir.c_str());
 
   // Argv array needs to be null terminated.
-  Argv.push_back(nullptr);
+  Argv.push_back(0);
 
   std::string ErrorMsg;
   bool ExecutionFailed = false;
-  int ReturnCode = ExecuteAndWait(CARPath.c_str(), Argv.data(),
-                                  /* env */ nullptr, /* redirects */ nullptr,
+  int ReturnCode = ExecuteAndWait(CARPath.c_str(), Argv.data(), /* env */ 0,
+                                  /* redirects */ 0,
                                   /* secondsToWait */ 0, /* memoryLimit */ 0,
                                   &ErrorMsg, &ExecutionFailed);
   if (ExecutionFailed || !ErrorMsg.empty()) {
@@ -144,7 +144,7 @@ bool ReplacementHandling::generateReplacementsFileName(
   Error.clear();
   SmallString<128> Prefix = DestinationDir;
   path::append(Prefix, path::filename(MainSourceFile));
-  if (std::error_code EC =
+  if (error_code EC =
           fs::createUniqueFile(Prefix + "_%%_%%_%%_%%_%%_%%.yaml", Result)) {
     const std::string &Msg = EC.message();
     Error.append(Msg.begin(), Msg.end());

clang-tools-extra/clang-modernize/Core/ReplacementHandling.h

@@ -16,8 +16,8 @@
 #ifndef CLANG_MODERNIZE_REPLACEMENTHANDLING_H
 #define CLANG_MODERNIZE_REPLACEMENTHANDLING_H
 
-#include "Core/Transform.h"
 #include "llvm/ADT/StringRef.h"
+#include "Core/Transform.h"
 
 class ReplacementHandling {
 public:

clang-tools-extra/clang-modernize/Core/Transform.cpp

@@ -21,8 +21,6 @@
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/STLExtras.h"
 
-template class llvm::Registry<TransformFactory>;
-
 using namespace clang;
 
 llvm::cl::OptionCategory TransformsOptionsCategory("Transforms' options");
@@ -39,7 +37,7 @@ public:
   ActionFactory(MatchFinder &Finder, Transform &Owner)
   : Finder(Finder), Owner(Owner) {}
 
-  FrontendAction *create() override {
+  virtual FrontendAction *create() LLVM_OVERRIDE {
     return new FactoryAdaptor(Finder, Owner);
   }
 
@@ -49,20 +47,19 @@ private:
     FactoryAdaptor(MatchFinder &Finder, Transform &Owner)
         : Finder(Finder), Owner(Owner) {}
 
-    std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &,
-                                                   StringRef) override {
+    ASTConsumer *CreateASTConsumer(CompilerInstance &, StringRef) {
       return Finder.newASTConsumer();
     }
 
     virtual bool BeginSourceFileAction(CompilerInstance &CI,
-                                       StringRef Filename) override {
+                                       StringRef Filename) LLVM_OVERRIDE {
       if (!ASTFrontendAction::BeginSourceFileAction(CI, Filename))
         return false;
 
       return Owner.handleBeginSource(CI, Filename);
     }
 
-    void EndSourceFileAction() override {
+    virtual void EndSourceFileAction() LLVM_OVERRIDE {
       Owner.handleEndSource();
       return ASTFrontendAction::EndSourceFileAction();
     }
@@ -129,19 +126,18 @@ Transform::addReplacementForCurrentTU(const clang::tooling::Replacement &R) {
   return true;
 }
 
-std::unique_ptr<FrontendActionFactory>
-Transform::createActionFactory(MatchFinder &Finder) {
-  return llvm::make_unique<ActionFactory>(Finder, /*Owner=*/*this);
+FrontendActionFactory *Transform::createActionFactory(MatchFinder &Finder) {
+  return new ActionFactory(Finder, /*Owner=*/ *this);
 }
 
 Version Version::getFromString(llvm::StringRef VersionStr) {
   llvm::StringRef MajorStr, MinorStr;
   Version V;
 
-  std::tie(MajorStr, MinorStr) = VersionStr.split('.');
+  llvm::tie(MajorStr, MinorStr) = VersionStr.split('.');
   if (!MinorStr.empty()) {
     llvm::StringRef Ignore;
-    std::tie(MinorStr, Ignore) = MinorStr.split('.');
+    llvm::tie(MinorStr, Ignore) = MinorStr.split('.');
     if (MinorStr.getAsInteger(10, V.Minor))
       return Version();
   }

clang-tools-extra/clang-modernize/Core/Transform.h

@@ -18,6 +18,7 @@
 
 #include "Core/IncludeExcludeInfo.h"
 #include "Core/Refactoring.h"
+#include "llvm/ADT/OwningPtr.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Registry.h"
 #include "llvm/Support/Timer.h"
@@ -208,8 +209,8 @@ protected:
   ///
   /// The factory returned by this function is responsible for calling back to
   /// Transform to call handleBeginSource() and handleEndSource().
-  std::unique_ptr<clang::tooling::FrontendActionFactory>
-  createActionFactory(clang::ast_matchers::MatchFinder &Finder);
+  clang::tooling::FrontendActionFactory *
+      createActionFactory(clang::ast_matchers::MatchFinder &Finder);
 
 private:
   const std::string Name;
@@ -290,7 +291,7 @@ struct CompilerVersions {
 ///     Since.Msvc = Version(10);
 ///   }
 ///
-///   Transform *createTransform(const TransformOptions &Opts) override {
+///   Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
 ///     return new MyTransform(Opts);
 ///   }
 /// };
@@ -322,6 +323,4 @@ protected:
 
 typedef llvm::Registry<TransformFactory> TransformFactoryRegistry;
 
-extern template class llvm::Registry<TransformFactory>;
-
 #endif // CLANG_MODERNIZE_TRANSFORM_H

clang-tools-extra/clang-modernize/Core/Transforms.cpp

@@ -61,7 +61,7 @@ Transforms::createSelectedTransforms(const TransformOptions &GlobalOptions,
     if (!OptionEnabled)
       continue;
 
-    std::unique_ptr<TransformFactory> Factory(I->instantiate());
+    llvm::OwningPtr<TransformFactory> Factory(I->instantiate());
     if (Factory->supportsCompilers(RequiredVersions))
       ChosenTransforms.push_back(Factory->createTransform(GlobalOptions));
     else if (ExplicitlyEnabled)

clang-tools-extra/clang-modernize/Core/Transforms.h

@@ -17,8 +17,9 @@
 #ifndef CLANG_MODERNIZE_TRANSFORMS_H
 #define CLANG_MODERNIZE_TRANSFORMS_H
 
-#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/ADT/StringRef.h"
+
 #include <vector>
 
 // Forward declarations

clang-tools-extra/clang-modernize/LoopConvert/LoopActions.cpp

@@ -73,9 +73,9 @@ class ForLoopIndexUseVisitor
     Context(Context), IndexVar(IndexVar), EndVar(EndVar),
     ContainerExpr(ContainerExpr), ArrayBoundExpr(ArrayBoundExpr),
     ContainerNeedsDereference(ContainerNeedsDereference),
-    OnlyUsedAsIndex(true),  AliasDecl(nullptr), ConfidenceLevel(RL_Safe),
-    NextStmtParent(nullptr), CurrStmtParent(nullptr),
-    ReplaceWithAliasUse(false), AliasFromForInit(false) {
+    OnlyUsedAsIndex(true),  AliasDecl(NULL), ConfidenceLevel(RL_Safe),
+    NextStmtParent(NULL), CurrStmtParent(NULL), ReplaceWithAliasUse(false),
+    AliasFromForInit(false) {
      if (ContainerExpr) {
        addComponent(ContainerExpr);
        llvm::FoldingSetNodeID ID;
@@ -208,7 +208,7 @@ static StringRef getStringFromRange(SourceManager &SourceMgr,
                                     SourceRange Range) {
   if (SourceMgr.getFileID(Range.getBegin()) !=
       SourceMgr.getFileID(Range.getEnd()))
-    return nullptr;
+    return NULL;
 
   CharSourceRange SourceChars(Range, true);
   return Lexer::getSourceText(SourceChars, SourceMgr, LangOpts);
@@ -224,7 +224,7 @@ static const DeclRefExpr *getDeclRef(const Expr *E) {
 static const VarDecl *getReferencedVariable(const Expr *E) {
   if (const DeclRefExpr *DRE = getDeclRef(E))
     return dyn_cast<VarDecl>(DRE->getDecl());
-  return nullptr;
+  return NULL;
 }
 
 /// \brief Returns true when the given expression is a member expression
@@ -277,14 +277,14 @@ static bool areSameExpr(ASTContext *Context, const Expr *First,
 /// as being initialized from `v.begin()`
 static const Expr *digThroughConstructors(const Expr *E) {
   if (!E)
-    return nullptr;
+    return NULL;
   E = E->IgnoreParenImpCasts();
   if (const CXXConstructExpr *ConstructExpr = dyn_cast<CXXConstructExpr>(E)) {
     // The initial constructor must take exactly one parameter, but base class
     // and deferred constructors can take more.
     if (ConstructExpr->getNumArgs() != 1 ||
         ConstructExpr->getConstructionKind() != CXXConstructExpr::CK_Complete)
-      return nullptr;
+      return NULL;
     E = ConstructExpr->getArg(0);
     if (const MaterializeTemporaryExpr *Temp =
         dyn_cast<MaterializeTemporaryExpr>(E))
@@ -298,13 +298,13 @@ static const Expr *digThroughConstructors(const Expr *E) {
 /// operand. Otherwise, return NULL.
 static const Expr *getDereferenceOperand(const Expr *E) {
   if (const UnaryOperator *Uop = dyn_cast<UnaryOperator>(E))
-    return Uop->getOpcode() == UO_Deref ? Uop->getSubExpr() : nullptr;
+    return Uop->getOpcode() == UO_Deref ? Uop->getSubExpr() : NULL;
 
   if (const CXXOperatorCallExpr *OpCall = dyn_cast<CXXOperatorCallExpr>(E))
     return OpCall->getOperator() == OO_Star && OpCall->getNumArgs() == 1 ?
-        OpCall->getArg(0) : nullptr;
+        OpCall->getArg(0) : NULL;
 
-  return nullptr;
+  return NULL;
 }
 
 /// \brief Returns true when the Container contains an Expr equivalent to E.
@@ -450,16 +450,9 @@ static bool isAliasDecl(const Decl *TheDecl, const VarDecl *IndexVar) {
       const CXXOperatorCallExpr *OpCall = cast<CXXOperatorCallExpr>(Init);
       if (OpCall->getOperator() == OO_Star)
         return isDereferenceOfOpCall(OpCall, IndexVar);
-      if (OpCall->getOperator() == OO_Subscript) {
-        assert(OpCall->getNumArgs() == 2);
-        return true;
-      }
       break;
   }
 
-  case Stmt::CXXMemberCallExprClass:
-    return true;
-
   default:
     break;
   }
@@ -886,19 +879,19 @@ static const Expr *getContainerFromBeginEndCall(const Expr *Init, bool IsBegin,
   const CXXMemberCallExpr *TheCall =
       dyn_cast_or_null<CXXMemberCallExpr>(digThroughConstructors(Init));
   if (!TheCall || TheCall->getNumArgs() != 0)
-      return nullptr;
+      return NULL;
 
   const MemberExpr *Member = dyn_cast<MemberExpr>(TheCall->getCallee());
   if (!Member)
-    return nullptr;
+    return NULL;
   const std::string Name = Member->getMemberDecl()->getName();
   const std::string TargetName = IsBegin ? "begin" : "end";
   if (Name != TargetName)
-    return nullptr;
+    return NULL;
 
   const Expr *SourceExpr = Member->getBase();
   if (!SourceExpr)
-    return nullptr;
+    return NULL;
 
   *IsArrow = Member->isArrow();
   return SourceExpr;
@@ -919,7 +912,7 @@ static const Expr *findContainer(ASTContext *Context, const Expr *BeginExpr,
   const Expr *BeginContainerExpr =
       getContainerFromBeginEndCall(BeginExpr, /*IsBegin=*/true, &BeginIsArrow);
   if (!BeginContainerExpr)
-      return nullptr;
+      return NULL;
 
   const Expr *EndContainerExpr =
       getContainerFromBeginEndCall(EndExpr, /*IsBegin=*/false, &EndIsArrow);
@@ -927,7 +920,7 @@ static const Expr *findContainer(ASTContext *Context, const Expr *BeginExpr,
   //  for (IteratorType It = Obj.begin(), E = Obj->end(); It != E; ++It) { }
   if (!EndContainerExpr || BeginIsArrow != EndIsArrow ||
       !areSameExpr(Context, EndContainerExpr, BeginContainerExpr))
-    return nullptr;
+    return NULL;
 
   *ContainerNeedsDereference = BeginIsArrow;
   return BeginContainerExpr;
@@ -1063,7 +1056,7 @@ void LoopFixer::run(const MatchFinder::MatchResult &Result) {
   if (FixerKind != LFK_Array && !EndVar)
     ConfidenceLevel.lowerTo(RL_Reasonable);
 
-  const Expr *ContainerExpr = nullptr;
+  const Expr *ContainerExpr = NULL;
   bool DerefByValue = false;
   bool DerefByConstRef = false;
   bool ContainerNeedsDereference = false;
@@ -1079,9 +1072,9 @@ void LoopFixer::run(const MatchFinder::MatchResult &Result) {
 
     const CXXMemberCallExpr *BeginCall =
         Nodes.getNodeAs<CXXMemberCallExpr>(BeginCallName);
-    assert(BeginCall && "Bad Callback. No begin call expression.");
+    assert(BeginCall != 0 && "Bad Callback. No begin call expression.");
     QualType CanonicalBeginType =
-        BeginCall->getMethodDecl()->getReturnType().getCanonicalType();
+        BeginCall->getMethodDecl()->getResultType().getCanonicalType();
 
     if (CanonicalBeginType->isPointerType() &&
         CanonicalInitVarType->isPointerType()) {
@@ -1098,7 +1091,7 @@ void LoopFixer::run(const MatchFinder::MatchResult &Result) {
         return;
     }
 
-    DerefByValue = Nodes.getNodeAs<QualType>(DerefByValueResultName) != nullptr;
+    DerefByValue = Nodes.getNodeAs<QualType>(DerefByValueResultName) != 0;
     if (!DerefByValue) {
       if (const QualType *DerefType =
               Nodes.getNodeAs<QualType>(DerefByRefResultName)) {

clang-tools-extra/clang-modernize/LoopConvert/LoopActions.h

@@ -16,8 +16,8 @@
 #ifndef CLANG_MODERNIZE_LOOP_ACTIONS_H
 #define CLANG_MODERNIZE_LOOP_ACTIONS_H
 
-#include "Core/Transform.h"
 #include "StmtAncestor.h"
+#include "Core/Transform.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
@@ -53,7 +53,7 @@ struct TUTrackingInfo {
   /// \}
 
 private:
-  std::unique_ptr<StmtAncestorASTVisitor> ParentFinder;
+  llvm::OwningPtr<StmtAncestorASTVisitor> ParentFinder;
   StmtGeneratedVarNameMap GeneratedDecls;
   ReplacedVarsMap ReplacedVars;
 };

clang-tools-extra/clang-modernize/LoopConvert/LoopConvert.cpp

@@ -48,7 +48,7 @@ int LoopConvertTransform::apply(const CompilationDatabase &Database,
                                   LFK_PseudoArray, /*Owner=*/ *this);
   Finder.addMatcher(makePseudoArrayLoopMatcher(), &PseudoarrrayLoopFixer);
 
-  if (int result = LoopTool.run(createActionFactory(Finder).get())) {
+  if (int result = LoopTool.run(createActionFactory(Finder))) {
     llvm::errs() << "Error encountered during translation.\n";
     return result;
   }
@@ -77,7 +77,7 @@ struct LoopConvertFactory : TransformFactory {
     Since.Msvc = Version(11);
   }
 
-  Transform *createTransform(const TransformOptions &Opts) override {
+  Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
     return new LoopConvertTransform(Opts);
   }
 };

clang-tools-extra/clang-modernize/LoopConvert/LoopConvert.h

@@ -18,7 +18,7 @@
 #define CLANG_MODERNIZE_LOOP_CONVERT_H
 
 #include "Core/Transform.h"
-#include "llvm/Support/Compiler.h" // For override
+#include "llvm/Support/Compiler.h" // For LLVM_OVERRIDE
 
 // Forward decl for private implementation.
 struct TUTrackingInfo;
@@ -32,12 +32,12 @@ public:
 
   /// \see Transform::run().
   virtual int apply(const clang::tooling::CompilationDatabase &Database,
-                    const std::vector<std::string> &SourcePaths) override;
+                    const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
 
   virtual bool handleBeginSource(clang::CompilerInstance &CI,
-                                 llvm::StringRef Filename) override;
+                                 llvm::StringRef Filename) LLVM_OVERRIDE;
 private:
-  std::unique_ptr<TUTrackingInfo> TUInfo;
+  llvm::OwningPtr<TUTrackingInfo> TUInfo;
 };
 
 #endif // CLANG_MODERNIZE_LOOP_CONVERT_H

clang-tools-extra/clang-modernize/LoopConvert/StmtAncestor.cpp

@@ -68,7 +68,7 @@ bool DependencyFinderASTVisitor::VisitDeclRefExpr(DeclRefExpr *DeclRef) {
 bool DependencyFinderASTVisitor::VisitVarDecl(VarDecl *V) {
   const Stmt *Curr = DeclParents->lookup(V);
   // First, see if the variable was declared within an inner scope of the loop.
-  while (Curr != nullptr) {
+  while (Curr != NULL) {
     if (Curr == ContainingStmt) {
       DependsOnInsideVariable = true;
       return false;

clang-tools-extra/clang-modernize/LoopConvert/StmtAncestor.h

@@ -43,7 +43,7 @@ class StmtAncestorASTVisitor :
   public clang::RecursiveASTVisitor<StmtAncestorASTVisitor> {
 public:
   StmtAncestorASTVisitor() {
-    StmtStack.push_back(nullptr);
+    StmtStack.push_back(NULL);
   }
 
   /// \brief Run the analysis on the TranslationUnitDecl.

clang-tools-extra/clang-modernize/LoopConvert/VariableNaming.cpp

@@ -65,7 +65,7 @@ std::string VariableNamer::createIndexName() {
 /// We also check to see if the same identifier was generated by this loop
 /// converter in a loop nested within SourceStmt.
 bool VariableNamer::declarationExists(StringRef Symbol) {
-  assert(Context != nullptr && "Expected an ASTContext");
+  assert(Context != 0 && "Expected an ASTContext");
   IdentifierInfo &Ident = Context->Idents.get(Symbol);
 
   // Check if the symbol is not an identifier (ie. is a keyword or alias).
@@ -77,7 +77,7 @@ bool VariableNamer::declarationExists(StringRef Symbol) {
     return true;
 
   // Determine if the symbol was generated in a parent context.
-  for (const Stmt *S = SourceStmt; S != nullptr; S = ReverseAST->lookup(S)) {
+  for (const Stmt *S = SourceStmt; S != NULL; S = ReverseAST->lookup(S)) {
     StmtGeneratedVarNameMap::const_iterator I = GeneratedDecls->find(S);
     if (I != GeneratedDecls->end() && I->second == Symbol)
       return true;

clang-tools-extra/clang-modernize/PassByValue/PassByValue.cpp

@@ -35,7 +35,7 @@ int PassByValueTransform::apply(const tooling::CompilationDatabase &Database,
   // make the replacer available to handleBeginSource()
   this->Replacer = &Replacer;
 
-  if (Tool.run(createActionFactory(Finder).get())) {
+  if (Tool.run(createActionFactory(Finder))) {
     llvm::errs() << "Error encountered during translation.\n";
     return 1;
   }
@@ -62,7 +62,7 @@ struct PassByValueFactory : TransformFactory {
     Since.Msvc = Version(11);
   }
 
-  Transform *createTransform(const TransformOptions &Opts) override {
+  Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
     return new PassByValueTransform(Opts);
   }
 };

clang-tools-extra/clang-modernize/PassByValue/PassByValue.h

@@ -16,8 +16,8 @@
 #ifndef CLANG_MODERNIZE_PASS_BY_VALUE_H
 #define CLANG_MODERNIZE_PASS_BY_VALUE_H
 
-#include "Core/IncludeDirectives.h"
 #include "Core/Transform.h"
+#include "Core/IncludeDirectives.h"
 
 class ConstructorParamReplacer;
 
@@ -55,18 +55,18 @@ class ConstructorParamReplacer;
 class PassByValueTransform : public Transform {
 public:
   PassByValueTransform(const TransformOptions &Options)
-      : Transform("PassByValue", Options), Replacer(nullptr) {}
+      : Transform("PassByValue", Options), Replacer(0) {}
 
   /// \see Transform::apply().
   virtual int apply(const clang::tooling::CompilationDatabase &Database,
-                    const std::vector<std::string> &SourcePaths) override;
+                    const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
 
 private:
   /// \brief Setups the \c IncludeDirectives for the replacer.
   virtual bool handleBeginSource(clang::CompilerInstance &CI,
-                                 llvm::StringRef Filename) override;
+                                 llvm::StringRef Filename) LLVM_OVERRIDE;
 
-  std::unique_ptr<IncludeDirectives> IncludeManager;
+  llvm::OwningPtr<IncludeDirectives> IncludeManager;
   ConstructorParamReplacer *Replacer;
 };
 

clang-tools-extra/clang-modernize/PassByValue/PassByValueActions.cpp

@@ -14,9 +14,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "PassByValueActions.h"
+#include "PassByValueMatchers.h"
 #include "Core/IncludeDirectives.h"
 #include "Core/Transform.h"
-#include "PassByValueMatchers.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Lexer.h"

clang-tools-extra/clang-modernize/PassByValue/PassByValueActions.h

@@ -54,7 +54,7 @@ public:
   ConstructorParamReplacer(unsigned &AcceptedChanges, unsigned &RejectedChanges,
                            Transform &Owner)
       : AcceptedChanges(AcceptedChanges), RejectedChanges(RejectedChanges),
-        Owner(Owner), IncludeManager(nullptr) {}
+        Owner(Owner), IncludeManager(0) {}
 
   void setIncludeDirectives(IncludeDirectives *Includes) {
     IncludeManager = Includes;
@@ -63,7 +63,7 @@ public:
 private:
   /// \brief Entry point to the callback called when matches are made.
   virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
-      override;
+      LLVM_OVERRIDE;
 
   unsigned &AcceptedChanges;
   unsigned &RejectedChanges;

clang-tools-extra/clang-modernize/ReplaceAutoPtr/ReplaceAutoPtr.cpp

@@ -34,7 +34,7 @@ ReplaceAutoPtrTransform::apply(const CompilationDatabase &Database,
   Finder.addMatcher(makeAutoPtrUsingDeclMatcher(), &Replacer);
   Finder.addMatcher(makeTransferOwnershipExprMatcher(), &Fixer);
 
-  if (Tool.run(createActionFactory(Finder).get())) {
+  if (Tool.run(createActionFactory(Finder))) {
     llvm::errs() << "Error encountered during translation.\n";
     return 1;
   }
@@ -52,7 +52,7 @@ struct ReplaceAutoPtrFactory : TransformFactory {
     Since.Msvc = Version(11);
   }
 
-  Transform *createTransform(const TransformOptions &Opts) override {
+  Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
     return new ReplaceAutoPtrTransform(Opts);
   }
 };

clang-tools-extra/clang-modernize/ReplaceAutoPtr/ReplaceAutoPtr.h

@@ -48,7 +48,7 @@ public:
 
   /// \see Transform::run().
   virtual int apply(const clang::tooling::CompilationDatabase &Database,
-                    const std::vector<std::string> &SourcePaths) override;
+                    const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
 };
 
 #endif // CLANG_MODERNIZE_REPLACE_AUTO_PTR_H

clang-tools-extra/clang-modernize/ReplaceAutoPtr/ReplaceAutoPtrActions.cpp

@@ -14,8 +14,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "ReplaceAutoPtrActions.h"
-#include "Core/Transform.h"
 #include "ReplaceAutoPtrMatchers.h"
+#include "Core/Transform.h"
+
 #include "clang/AST/ASTContext.h"
 #include "clang/Lex/Lexer.h"
 

clang-tools-extra/clang-modernize/ReplaceAutoPtr/ReplaceAutoPtrActions.h

@@ -30,7 +30,7 @@ public:
 
   /// \brief Entry point to the callback called when matches are made.
   virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
-      override;
+      LLVM_OVERRIDE;
 
 private:
   /// \brief Locates the \c auto_ptr token when it is referred by a \c TypeLoc.
@@ -89,7 +89,7 @@ public:
 
   /// \brief Entry point to the callback called when matches are made.
   virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
-      override;
+      LLVM_OVERRIDE;
 
 private:
   unsigned &AcceptedChanges;

clang-tools-extra/clang-modernize/UseAuto/UseAuto.cpp

@@ -36,7 +36,7 @@ int UseAutoTransform::apply(const clang::tooling::CompilationDatabase &Database,
   Finder.addMatcher(makeIteratorDeclMatcher(), &ReplaceIterators);
   Finder.addMatcher(makeDeclWithNewMatcher(), &ReplaceNew);
 
-  if (int Result = UseAutoTool.run(createActionFactory(Finder).get())) {
+  if (int Result = UseAutoTool.run(createActionFactory(Finder))) {
     llvm::errs() << "Error encountered during translation.\n";
     return Result;
   }
@@ -54,7 +54,7 @@ struct UseAutoFactory : TransformFactory {
     Since.Msvc = Version(10);
   }
 
-  Transform *createTransform(const TransformOptions &Opts) override {
+  Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
     return new UseAutoTransform(Opts);
   }
 };

clang-tools-extra/clang-modernize/UseAuto/UseAuto.h

@@ -35,7 +35,7 @@ public:
 
   /// \see Transform::run().
   virtual int apply(const clang::tooling::CompilationDatabase &Database,
-                    const std::vector<std::string> &SourcePaths) override;
+                    const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
 };
 
 #endif // CLANG_MODERNIZE_USE_AUTO_H

clang-tools-extra/clang-modernize/UseAuto/UseAutoActions.h

@@ -30,7 +30,7 @@ public:
 
   /// \brief Entry point to the callback called when matches are made.
   virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
-      override;
+      LLVM_OVERRIDE;
 
 private:
   unsigned &AcceptedChanges;
@@ -46,7 +46,7 @@ public:
 
   /// \brief Entry point to the callback called when matches are made.
   virtual void run(const clang::ast_matchers::MatchFinder::MatchResult &Result)
-      override;
+      LLVM_OVERRIDE;
 
 private:
   unsigned &AcceptedChanges;

clang-tools-extra/clang-modernize/UseNullptr/NullptrActions.cpp

@@ -16,8 +16,10 @@
 
 #include "NullptrActions.h"
 #include "NullptrMatchers.h"
+
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
+
 #include "clang/Basic/CharInfo.h"
 #include "clang/Lex/Lexer.h"
 
@@ -151,7 +153,7 @@ public:
                       unsigned &AcceptedChanges, Transform &Owner)
       : SM(Context.getSourceManager()), Context(Context),
         UserNullMacros(UserNullMacros), AcceptedChanges(AcceptedChanges),
-        Owner(Owner), FirstSubExpr(nullptr), PruneSubtree(false) {}
+        Owner(Owner), FirstSubExpr(0), PruneSubtree(false) {}
 
   bool TraverseStmt(Stmt *S) {
     // Stop traversing down the tree if requested.
@@ -167,7 +169,7 @@ public:
   bool VisitStmt(Stmt *S) {
     CastExpr *C = dyn_cast<CastExpr>(S);
     if (!C) {
-      FirstSubExpr = nullptr;
+      FirstSubExpr = 0;
       return true;
     } else if (!FirstSubExpr) {
       FirstSubExpr = C->getSubExpr()->IgnoreParens();
@@ -383,27 +385,27 @@ private:
     assert(MacroLoc.isFileID());
 
     do {
-      const auto &Parents = Context.getParents(Start);
+      ASTContext::ParentVector Parents = Context.getParents(Start);
       if (Parents.empty())
         return false;
       assert(Parents.size() == 1 &&
              "Found an ancestor with more than one parent!");
 
-      const ast_type_traits::DynTypedNode &Parent = Parents[0];
+      ASTContext::ParentVector::const_iterator I = Parents.begin();
 
       SourceLocation Loc;
-      if (const Decl *D = Parent.get<Decl>())
+      if (const Decl *D = I->get<Decl>())
         Loc = D->getLocStart();
-      else if (const Stmt *S = Parent.get<Stmt>())
+      else if (const Stmt *S = I->get<Stmt>())
         Loc = S->getLocStart();
       else
         llvm_unreachable("Expected to find Decl or Stmt containing ancestor");
 
       if (!expandsFrom(Loc, MacroLoc)) {
-        Result = Parent;
+        Result = *I;
         return true;
       }
-      Start = Parent;
+      Start = *I;
     } while (1);
 
     llvm_unreachable("findContainingAncestor");

clang-tools-extra/clang-modernize/UseNullptr/UseNullptr.cpp

@@ -46,7 +46,8 @@ int UseNullptrTransform::apply(const CompilationDatabase &Database,
   NullptrFixer Fixer(AcceptedChanges, MacroNames, /*Owner=*/ *this);
 
   Finder.addMatcher(makeCastSequenceMatcher(), &Fixer);
-  if (int result = UseNullptrTool.run(createActionFactory(Finder).get())) {
+
+  if (int result = UseNullptrTool.run(createActionFactory(Finder))) {
     llvm::errs() << "Error encountered during translation.\n";
     return result;
   }
@@ -64,7 +65,7 @@ struct UseNullptrFactory : TransformFactory {
     Since.Msvc = Version(10);
   }
 
-  Transform *createTransform(const TransformOptions &Opts) override {
+  Transform *createTransform(const TransformOptions &Opts) LLVM_OVERRIDE {
     return new UseNullptrTransform(Opts);
   }
 };

clang-tools-extra/clang-modernize/UseNullptr/UseNullptr.h

@@ -18,7 +18,7 @@
 #define CLANG_MODERNIZE_USE_NULLPTR_H
 
 #include "Core/Transform.h"
-#include "llvm/Support/Compiler.h" // For override
+#include "llvm/Support/Compiler.h" // For LLVM_OVERRIDE
 
 /// \brief Subclass of Transform that transforms null pointer constants into
 /// C++11's nullptr keyword where possible.
@@ -29,7 +29,7 @@ public:
 
   /// \see Transform::run().
   virtual int apply(const clang::tooling::CompilationDatabase &Database,
-                    const std::vector<std::string> &SourcePaths) override;
+                    const std::vector<std::string> &SourcePaths) LLVM_OVERRIDE;
 };
 
 #endif // CLANG_MODERNIZE_USE_NULLPTR_H

clang-tools-extra/clang-modernize/tool/CMakeLists.txt

@@ -34,14 +34,6 @@ add_dependencies(clang-modernize
   )
 
 target_link_libraries(clang-modernize
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangFormat
-  clangFrontend
-  clangLex
-  clangTooling
-  clangToolingCore
   modernizeCore
   )
 

clang-tools-extra/clang-modernize/tool/ClangModernize.cpp

@@ -213,13 +213,13 @@ static CompilerVersions handleSupportedCompilers(const char *ProgName,
                                                         E = Compilers.end();
        I != E; ++I) {
     llvm::StringRef Compiler, VersionStr;
-    std::tie(Compiler, VersionStr) = I->split('-');
+    llvm::tie(Compiler, VersionStr) = I->split('-');
     Version *V = llvm::StringSwitch<Version *>(Compiler)
         .Case("clang", &RequiredVersions.Clang)
         .Case("gcc", &RequiredVersions.Gcc).Case("icc", &RequiredVersions.Icc)
-        .Case("msvc", &RequiredVersions.Msvc).Default(nullptr);
+        .Case("msvc", &RequiredVersions.Msvc).Default(NULL);
 
-    if (V == nullptr) {
+    if (V == NULL) {
       llvm::errs() << ProgName << ": " << Compiler
                    << ": unsupported platform\n";
       Error = true;
@@ -248,15 +248,14 @@ static CompilerVersions handleSupportedCompilers(const char *ProgName,
   return RequiredVersions;
 }
 
-std::unique_ptr<CompilationDatabase>
-autoDetectCompilations(std::string &ErrorMessage) {
+CompilationDatabase *autoDetectCompilations(std::string &ErrorMessage) {
   // Auto-detect a compilation database from BuildPath.
   if (BuildPath.getNumOccurrences() > 0)
     return CompilationDatabase::autoDetectFromDirectory(BuildPath,
                                                         ErrorMessage);
   // Try to auto-detect a compilation database from the first source.
   if (!SourcePaths.empty()) {
-    if (std::unique_ptr<CompilationDatabase> Compilations =
+    if (CompilationDatabase *Compilations =
             CompilationDatabase::autoDetectFromSource(SourcePaths[0],
                                                       ErrorMessage)) {
       // FIXME: just pass SourcePaths[0] once getCompileCommands supports
@@ -276,11 +275,11 @@ autoDetectCompilations(std::string &ErrorMessage) {
     // If no compilation database can be detected from source then we create a
     // fixed compilation database with c++11 support.
     std::string CommandLine[] = { "-std=c++11" };
-    return llvm::make_unique<FixedCompilationDatabase>(".", CommandLine);
+    return new FixedCompilationDatabase(".", CommandLine);
   }
 
   ErrorMessage = "Could not determine sources to transform";
-  return nullptr;
+  return 0;
 }
 
 // Predicate definition for determining whether a file is not included.
@@ -324,7 +323,7 @@ int main(int argc, const char **argv) {
   cl::SetVersionPrinter(&printVersion);
 
   // Parse options and generate compilations.
-  std::unique_ptr<CompilationDatabase> Compilations(
+  OwningPtr<CompilationDatabase> Compilations(
       FixedCompilationDatabase::loadFromCommandLine(argc, argv));
   cl::ParseCommandLineOptions(argc, argv);
 
@@ -335,7 +334,7 @@ int main(int argc, const char **argv) {
 
   if (!Compilations) {
     std::string ErrorMessage;
-    Compilations = autoDetectCompilations(ErrorMessage);
+    Compilations.reset(autoDetectCompilations(ErrorMessage));
     if (!Compilations) {
       llvm::errs() << llvm::sys::path::filename(argv[0]) << ": " << ErrorMessage
                    << "\n";
@@ -396,7 +395,7 @@ int main(int argc, const char **argv) {
       new DiagnosticOptions());
   DiagnosticsEngine Diagnostics(
       llvm::IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
-      DiagOpts.get());
+      DiagOpts.getPtr());
 
   // FIXME: Make this DiagnosticsEngine available to all Transforms probably via
   // GlobalOptions.
@@ -470,7 +469,7 @@ int main(int argc, const char **argv) {
 
   if (FinalSyntaxCheck) {
     ClangTool SyntaxTool(*Compilations, SourcePaths);
-    if (SyntaxTool.run(newFrontendActionFactory<SyntaxOnlyAction>().get()) != 0)
+    if (SyntaxTool.run(newFrontendActionFactory<SyntaxOnlyAction>()) != 0)
       return 1;
   }
 

clang-tools-extra/clang-modernize/tool/Makefile

@@ -36,10 +36,9 @@ SOURCES += $(addprefix ../ReplaceAutoPtr/,$(notdir $(wildcard $(PROJ_SRC_DIR)/..
 BUILT_SOURCES += $(ObjDir)/../ReplaceAutoPtr/.objdir
 
 LINK_COMPONENTS := $(TARGETS_TO_BUILD) asmparser bitreader support mc mcparser option
-USEDLIBS = modernizeCore.a clangFormat.a \
-	   clangTooling.a clangToolingCore.a clangFrontend.a \
+USEDLIBS = modernizeCore.a clangFormat.a clangTooling.a clangFrontend.a \
 	   clangSerialization.a clangDriver.a clangRewriteFrontend.a \
-	   clangRewrite.a clangParse.a clangSema.a clangAnalysis.a \
+	   clangRewriteCore.a clangParse.a clangSema.a clangAnalysis.a \
 	   clangAST.a clangASTMatchers.a clangEdit.a clangLex.a clangBasic.a
 
 include $(CLANG_LEVEL)/Makefile

clang-tools-extra/clang-query/CMakeLists.txt

@@ -1,13 +1,8 @@
-set(LLVM_LINK_COMPONENTS
-  lineeditor
-  support
-  )
-
 add_clang_library(clangQuery
   Query.cpp
   QueryParser.cpp
-
-  LINK_LIBS
+  )
+target_link_libraries(clangQuery
   clangAST
   clangASTMatchers
   clangBasic

clang-tools-extra/clang-query/Makefile

@@ -11,6 +11,4 @@ CLANG_LEVEL := ../../..
 LIBRARYNAME := clangQuery
 include $(CLANG_LEVEL)/../../Makefile.config
 
-DIRS = tool
-
 include $(CLANG_LEVEL)/Makefile

clang-tools-extra/clang-query/Query.cpp

@@ -54,12 +54,15 @@ struct CollectBoundNodes : MatchFinder::MatchCallback {
   }
 };
 
-}  // namespace
+}
 
 bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   unsigned MatchCount = 0;
 
-  for (auto &AST : QS.ASTs) {
+  for (llvm::ArrayRef<ASTUnit *>::iterator I = QS.ASTs.begin(),
+                                           E = QS.ASTs.end();
+       I != E; ++I) {
+    ASTUnit *AST = *I;
     MatchFinder Finder;
     std::vector<BoundNodes> Matches;
     DynTypedMatcher MaybeBoundMatcher = Matcher;
@@ -92,8 +95,8 @@ bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
             TD.emitDiagnostic(
                 R.getBegin(), DiagnosticsEngine::Note,
                 "\"" + BI->first + "\" binds here",
-                CharSourceRange::getTokenRange(R),
-                None, &AST->getSourceManager());
+                ArrayRef<CharSourceRange>(CharSourceRange::getTokenRange(R)),
+                ArrayRef<FixItHint>(), &AST->getSourceManager());
           }
           break;
         }
@@ -121,15 +124,6 @@ bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   return true;
 }
 
-bool LetQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
-  if (Value) {
-    QS.NamedValues[Name] = Value;
-  } else {
-    QS.NamedValues.erase(Name);
-  }
-  return true;
-}
-
 #ifndef _MSC_VER
 const QueryKind SetQueryKind<bool>::value;
 const QueryKind SetQueryKind<OutputKind>::value;

clang-tools-extra/clang-query/Query.h

@@ -10,10 +10,10 @@
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_H
 
+#include <string>
 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
-#include <string>
 
 namespace clang {
 namespace query {
@@ -28,10 +28,9 @@ enum QueryKind {
   QK_Invalid,
   QK_NoOp,
   QK_Help,
-  QK_Let,
   QK_Match,
   QK_SetBool,
-  QK_SetOutputKind,
+  QK_SetOutputKind
 };
 
 class QuerySession;
@@ -53,7 +52,7 @@ typedef llvm::IntrusiveRefCntPtr<Query> QueryRef;
 /// Any query which resulted in a parse error.  The error message is in ErrStr.
 struct InvalidQuery : Query {
   InvalidQuery(const Twine &ErrStr) : Query(QK_Invalid), ErrStr(ErrStr.str()) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
+  bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE;
 
   std::string ErrStr;
 
@@ -63,7 +62,7 @@ struct InvalidQuery : Query {
 /// No-op query (i.e. a blank line).
 struct NoOpQuery : Query {
   NoOpQuery() : Query(QK_NoOp) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
+  bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE;
 
   static bool classof(const Query *Q) { return Q->Kind == QK_NoOp; }
 };
@@ -71,7 +70,7 @@ struct NoOpQuery : Query {
 /// Query for "help".
 struct HelpQuery : Query {
   HelpQuery() : Query(QK_Help) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
+  bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE;
 
   static bool classof(const Query *Q) { return Q->Kind == QK_Help; }
 };
@@ -80,24 +79,13 @@ struct HelpQuery : Query {
 struct MatchQuery : Query {
   MatchQuery(const ast_matchers::dynamic::DynTypedMatcher &Matcher)
       : Query(QK_Match), Matcher(Matcher) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
+  bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE;
 
   ast_matchers::dynamic::DynTypedMatcher Matcher;
 
   static bool classof(const Query *Q) { return Q->Kind == QK_Match; }
 };
 
-struct LetQuery : Query {
-  LetQuery(StringRef Name, const ast_matchers::dynamic::VariantValue &Value)
-      : Query(QK_Let), Name(Name), Value(Value) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
-
-  std::string Name;
-  ast_matchers::dynamic::VariantValue Value;
-
-  static bool classof(const Query *Q) { return Q->Kind == QK_Let; }
-};
-
 template <typename T> struct SetQueryKind {};
 
 template <> struct SetQueryKind<bool> {
@@ -112,7 +100,7 @@ template <> struct SetQueryKind<OutputKind> {
 template <typename T> struct SetQuery : Query {
   SetQuery(T QuerySession::*Var, T Value)
       : Query(SetQueryKind<T>::value), Var(Var), Value(Value) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override {
+  bool run(llvm::raw_ostream &OS, QuerySession &QS) const LLVM_OVERRIDE {
     QS.*Var = Value;
     return true;
   }

clang-tools-extra/clang-query/QueryParser.cpp

@@ -10,11 +10,10 @@
 #include "QueryParser.h"
 #include "Query.h"
 #include "QuerySession.h"
-#include "clang/ASTMatchers/Dynamic/Parser.h"
-#include "clang/Basic/CharInfo.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
-#include <set>
+#include "clang/ASTMatchers/Dynamic/Parser.h"
+#include "clang/Basic/CharInfo.h"
 
 using namespace llvm;
 using namespace clang::ast_matchers::dynamic;
@@ -26,10 +25,10 @@ namespace query {
 // non-whitespace characters) from the start of region [Begin,End).  If no word
 // is found before End, return StringRef().  Begin is adjusted to exclude the
 // lexed region.
-StringRef QueryParser::lexWord() {
+static StringRef LexWord(const char *&Begin, const char *End) {
   while (true) {
     if (Begin == End)
-      return StringRef(Begin, 0);
+      return StringRef();
 
     if (!isWhitespace(*Begin))
       break;
@@ -47,60 +46,8 @@ StringRef QueryParser::lexWord() {
   }
 }
 
-// This is the StringSwitch-alike used by lexOrCompleteWord below. See that
-// function for details.
-template <typename T> struct QueryParser::LexOrCompleteWord {
-  StringSwitch<T> Switch;
-
-  QueryParser *P;
-  StringRef Word;
-  // Set to the completion point offset in Word, or StringRef::npos if
-  // completion point not in Word.
-  size_t WordCompletionPos;
-
-  LexOrCompleteWord(QueryParser *P, StringRef Word, size_t WCP)
-      : Switch(Word), P(P), Word(Word), WordCompletionPos(WCP) {}
-
-  template <unsigned N>
-  LexOrCompleteWord &Case(const char (&S)[N], const T &Value,
-                          bool IsCompletion = true) {
-    StringRef CaseStr(S, N - 1);
-
-    if (WordCompletionPos == StringRef::npos)
-      Switch.Case(S, Value);
-    else if (N != 1 && IsCompletion && WordCompletionPos <= CaseStr.size() &&
-             CaseStr.substr(0, WordCompletionPos) ==
-                 Word.substr(0, WordCompletionPos))
-      P->Completions.push_back(LineEditor::Completion(
-          (CaseStr.substr(WordCompletionPos) + " ").str(), CaseStr));
-    return *this;
-  }
-
-  T Default(const T& Value) const {
-    return Switch.Default(Value);
-  }
-};
-
-// Lexes a word and stores it in Word. Returns a LexOrCompleteWord<T> object
-// that can be used like a llvm::StringSwitch<T>, but adds cases as possible
-// completions if the lexed word contains the completion point.
-template <typename T>
-QueryParser::LexOrCompleteWord<T>
-QueryParser::lexOrCompleteWord(StringRef &Word) {
-  Word = lexWord();
-  size_t WordCompletionPos = StringRef::npos;
-  if (CompletionPos && CompletionPos <= Word.data() + Word.size()) {
-    if (CompletionPos < Word.data())
-      WordCompletionPos = 0;
-    else
-      WordCompletionPos = CompletionPos - Word.data();
-  }
-  return LexOrCompleteWord<T>(this, Word, WordCompletionPos);
-}
-
-QueryRef QueryParser::parseSetBool(bool QuerySession::*Var) {
-  StringRef ValStr;
-  unsigned Value = lexOrCompleteWord<unsigned>(ValStr)
+static QueryRef ParseSetBool(bool QuerySession::*Var, StringRef ValStr) {
+  unsigned Value = StringSwitch<unsigned>(ValStr)
                       .Case("false", 0)
                       .Case("true", 1)
                       .Default(~0u);
@@ -110,9 +57,8 @@ QueryRef QueryParser::parseSetBool(bool QuerySession::*Var) {
   return new SetQuery<bool>(Var, Value);
 }
 
-QueryRef QueryParser::parseSetOutputKind() {
-  StringRef ValStr;
-  unsigned OutKind = lexOrCompleteWord<unsigned>(ValStr)
+static QueryRef ParseSetOutputKind(StringRef ValStr) {
+  unsigned OutKind = StringSwitch<unsigned>(ValStr)
                          .Case("diag", OK_Diag)
                          .Case("print", OK_Print)
                          .Case("dump", OK_Dump)
@@ -124,24 +70,20 @@ QueryRef QueryParser::parseSetOutputKind() {
   return new SetQuery<OutputKind>(&QuerySession::OutKind, OutputKind(OutKind));
 }
 
-QueryRef QueryParser::endQuery(QueryRef Q) {
+static QueryRef EndQuery(const char *Begin, const char *End, QueryRef Q) {
   const char *Extra = Begin;
-  if (!lexWord().empty())
+  if (!LexWord(Begin, End).empty())
     return new InvalidQuery("unexpected extra input: '" +
                             StringRef(Extra, End - Extra) + "'");
   return Q;
 }
 
-namespace {
-
 enum ParsedQueryKind {
   PQK_Invalid,
   PQK_NoOp,
   PQK_Help,
-  PQK_Let,
   PQK_Match,
-  PQK_Set,
-  PQK_Unlet,
+  PQK_Set
 };
 
 enum ParsedQueryVariable {
@@ -150,37 +92,17 @@ enum ParsedQueryVariable {
   PQV_BindRoot
 };
 
-QueryRef makeInvalidQueryFromDiagnostics(const Diagnostics &Diag) {
-  std::string ErrStr;
-  llvm::raw_string_ostream OS(ErrStr);
-  Diag.printToStreamFull(OS);
-  return new InvalidQuery(OS.str());
-}
+QueryRef ParseQuery(StringRef Line) {
+  const char *Begin = Line.data();
+  const char *End = Line.data() + Line.size();
 
-}  // namespace
-
-QueryRef QueryParser::completeMatcherExpression() {
-  std::vector<MatcherCompletion> Comps = Parser::completeExpression(
-      StringRef(Begin, End - Begin), CompletionPos - Begin, nullptr,
-      &QS.NamedValues);
-  for (std::vector<MatcherCompletion>::iterator I = Comps.begin(),
-                                                E = Comps.end();
-       I != E; ++I) {
-    Completions.push_back(LineEditor::Completion(I->TypedText, I->MatcherDecl));
-  }
-  return QueryRef();
-}
-
-QueryRef QueryParser::doParse() {
-  StringRef CommandStr;
-  ParsedQueryKind QKind = lexOrCompleteWord<ParsedQueryKind>(CommandStr)
+  StringRef CommandStr = LexWord(Begin, End);
+  ParsedQueryKind QKind = StringSwitch<ParsedQueryKind>(CommandStr)
                               .Case("", PQK_NoOp)
                               .Case("help", PQK_Help)
-                              .Case("m", PQK_Match, /*IsCompletion=*/false)
-                              .Case("let", PQK_Let)
+                              .Case("m", PQK_Match)
                               .Case("match", PQK_Match)
                               .Case("set", PQK_Set)
-                              .Case("unlet", PQK_Unlet)
                               .Default(PQK_Invalid);
 
   switch (QKind) {
@@ -188,73 +110,50 @@ QueryRef QueryParser::doParse() {
     return new NoOpQuery;
 
   case PQK_Help:
-    return endQuery(new HelpQuery);
-
-  case PQK_Let: {
-    StringRef Name = lexWord();
-
-    if (Name.empty())
-      return new InvalidQuery("expected variable name");
-
-    if (CompletionPos)
-      return completeMatcherExpression();
-
-    Diagnostics Diag;
-    ast_matchers::dynamic::VariantValue Value;
-    if (!Parser::parseExpression(StringRef(Begin, End - Begin), nullptr,
-                                 &QS.NamedValues, &Value, &Diag)) {
-      return makeInvalidQueryFromDiagnostics(Diag);
-    }
-
-    return new LetQuery(Name, Value);
-  }
+    return EndQuery(Begin, End, new HelpQuery);
 
   case PQK_Match: {
-    if (CompletionPos)
-      return completeMatcherExpression();
-
     Diagnostics Diag;
-    Optional<DynTypedMatcher> Matcher = Parser::parseMatcherExpression(
-        StringRef(Begin, End - Begin), nullptr, &QS.NamedValues, &Diag);
+    Optional<DynTypedMatcher> Matcher =
+        Parser::parseMatcherExpression(StringRef(Begin, End - Begin), &Diag);
     if (!Matcher) {
-      return makeInvalidQueryFromDiagnostics(Diag);
+      std::string ErrStr;
+      llvm::raw_string_ostream OS(ErrStr);
+      Diag.printToStreamFull(OS);
+      return new InvalidQuery(OS.str());
     }
     return new MatchQuery(*Matcher);
   }
 
   case PQK_Set: {
-    StringRef VarStr;
-    ParsedQueryVariable Var = lexOrCompleteWord<ParsedQueryVariable>(VarStr)
-                                  .Case("output", PQV_Output)
-                                  .Case("bind-root", PQV_BindRoot)
-                                  .Default(PQV_Invalid);
+    StringRef VarStr = LexWord(Begin, End);
     if (VarStr.empty())
       return new InvalidQuery("expected variable name");
+
+    ParsedQueryVariable Var = StringSwitch<ParsedQueryVariable>(VarStr)
+                .Case("output", PQV_Output)
+                .Case("bind-root", PQV_BindRoot)
+                .Default(PQV_Invalid);
     if (Var == PQV_Invalid)
       return new InvalidQuery("unknown variable: '" + VarStr + "'");
 
+    StringRef ValStr = LexWord(Begin, End);
+    if (ValStr.empty())
+      return new InvalidQuery("expected variable value");
+
     QueryRef Q;
     switch (Var) {
     case PQV_Output:
-      Q = parseSetOutputKind();
+      Q = ParseSetOutputKind(ValStr);
       break;
     case PQV_BindRoot:
-      Q = parseSetBool(&QuerySession::BindRoot);
+      Q = ParseSetBool(&QuerySession::BindRoot, ValStr);
       break;
     case PQV_Invalid:
       llvm_unreachable("Invalid query kind");
     }
 
-    return endQuery(Q);
-  }
-
-  case PQK_Unlet: {
-    StringRef Name = lexWord();
-
-    if (Name.empty())
-      return new InvalidQuery("expected variable name");
-
-    return endQuery(new LetQuery(Name, VariantValue()));
+    return EndQuery(Begin, End, Q);
   }
 
   case PQK_Invalid:
@@ -264,18 +163,5 @@ QueryRef QueryParser::doParse() {
   llvm_unreachable("Invalid query kind");
 }
 
-QueryRef QueryParser::parse(StringRef Line, const QuerySession &QS) {
-  return QueryParser(Line, QS).doParse();
-}
-
-std::vector<LineEditor::Completion>
-QueryParser::complete(StringRef Line, size_t Pos, const QuerySession &QS) {
-  QueryParser P(Line, QS);
-  P.CompletionPos = Line.data() + Pos;
-
-  P.doParse();
-  return P.Completions;
-}
-
 } // namespace query
 } // namespace clang

clang-tools-extra/clang-query/QueryParser.h

@@ -11,60 +11,15 @@
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_PARSER_H
 
 #include "Query.h"
-#include "QuerySession.h"
-#include "llvm/LineEditor/LineEditor.h"
-#include <stddef.h>
 
 namespace clang {
 namespace query {
 
-class QuerySession;
-
-class QueryParser {
-public:
-  /// Parse \a Line as a query.
-  ///
-  /// \return A QueryRef representing the query, which may be an InvalidQuery.
-  static QueryRef parse(StringRef Line, const QuerySession &QS);
-
-  /// Compute a list of completions for \a Line assuming a cursor at
-  /// \param Pos characters past the start of \a Line, ordered from most
-  /// likely to least likely.
-  ///
-  /// \return A vector of completions for \a Line.
-  static std::vector<llvm::LineEditor::Completion>
-  complete(StringRef Line, size_t Pos, const QuerySession &QS);
-
-private:
-  QueryParser(StringRef Line, const QuerySession &QS)
-      : Begin(Line.begin()), End(Line.end()),
-        CompletionPos(nullptr), QS(QS) {}
-
-  StringRef lexWord();
-
-  template <typename T> struct LexOrCompleteWord;
-  template <typename T> LexOrCompleteWord<T> lexOrCompleteWord(StringRef &Str);
-
-  QueryRef parseSetBool(bool QuerySession::*Var);
-  QueryRef parseSetOutputKind();
-  QueryRef completeMatcherExpression();
-
-  QueryRef endQuery(QueryRef Q);
-
-  /// \brief Parse [\p Begin,\p End).
-  ///
-  /// \return A reference to the parsed query object, which may be an
-  /// \c InvalidQuery if a parse error occurs.
-  QueryRef doParse();
-
-  const char *Begin;
-  const char *End;
-
-  const char *CompletionPos;
-  std::vector<llvm::LineEditor::Completion> Completions;
-
-  const QuerySession &QS;
-};
+/// \brief Parse \p Line.
+///
+/// \return A reference to the parsed query object, which may be an
+/// \c InvalidQuery if a parse error occurs.
+QueryRef ParseQuery(StringRef Line);
 
 } // namespace query
 } // namespace clang

clang-tools-extra/clang-query/QuerySession.h

@@ -10,10 +10,8 @@
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_SESSION_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_SESSION_H
 
-#include "Query.h"
-#include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringMap.h"
+#include "Query.h"
 
 namespace clang {
 
@@ -24,13 +22,12 @@ namespace query {
 /// Represents the state for a particular clang-query session.
 class QuerySession {
 public:
-  QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
+  QuerySession(llvm::ArrayRef<ASTUnit *> ASTs)
       : ASTs(ASTs), OutKind(OK_Diag), BindRoot(true) {}
 
-  llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
+  llvm::ArrayRef<ASTUnit *> ASTs;
   OutputKind OutKind;
   bool BindRoot;
-  llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
 };
 
 } // namespace query

clang-tools-extra/clang-query/tool/CMakeLists.txt

@@ -1,11 +1,11 @@
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+if(HAVE_LIBEDIT)
+  include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
 
-add_clang_executable(clang-query ClangQuery.cpp)
-target_link_libraries(clang-query
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangDynamicASTMatchers
-  clangQuery
-  clangTooling
-  )
+  add_clang_executable(clang-query ClangQuery.cpp)
+  target_link_libraries(clang-query
+    edit
+    clangFrontend
+    clangQuery
+    clangTooling
+    )
+endif()

clang-tools-extra/clang-query/tool/ClangQuery.cpp

@@ -27,18 +27,21 @@
 //===----------------------------------------------------------------------===//
 
 #include "Query.h"
-#include "QueryParser.h"
 #include "QuerySession.h"
+#include "QueryParser.h"
+
 #include "clang/Frontend/ASTUnit.h"
-#include "clang/Tooling/CommonOptionsParser.h"
+#include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/Tooling.h"
-#include "llvm/LineEditor/LineEditor.h"
+#include "llvm/ADT/OwningPtr.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
 #include <fstream>
 #include <string>
 
+#include <histedit.h>
+
 using namespace clang;
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::dynamic;
@@ -46,31 +49,51 @@ using namespace clang::query;
 using namespace clang::tooling;
 using namespace llvm;
 
-static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
-static cl::OptionCategory ClangQueryCategory("clang-query options");
+static cl::opt<std::string> BuildPath("b", cl::desc("Specify build path"),
+                                      cl::value_desc("<path>"));
 
 static cl::list<std::string> Commands("c", cl::desc("Specify command to run"),
-                                      cl::value_desc("command"),
-                                      cl::cat(ClangQueryCategory));
+                                      cl::value_desc("<command>"));
 
 static cl::list<std::string> CommandFiles("f",
                                           cl::desc("Read commands from file"),
-                                          cl::value_desc("file"),
-                                          cl::cat(ClangQueryCategory));
+                                          cl::value_desc("<file>"));
+
+static cl::list<std::string> SourcePaths(cl::Positional,
+                                         cl::desc("<source0> [... <sourceN>]"),
+                                         cl::OneOrMore);
+
+static char *ReturnPrompt(EditLine *EL) {
+  static char Prompt[] = "clang-query> ";
+  return Prompt;
+}
 
 int main(int argc, const char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal();
-
-  CommonOptionsParser OptionsParser(argc, argv, ClangQueryCategory);
+  cl::ParseCommandLineOptions(argc, argv);
 
   if (!Commands.empty() && !CommandFiles.empty()) {
     llvm::errs() << argv[0] << ": cannot specify both -c and -f\n";
     return 1;
   }
 
-  ClangTool Tool(OptionsParser.getCompilations(),
-                 OptionsParser.getSourcePathList());
-  std::vector<std::unique_ptr<ASTUnit>> ASTs;
+  llvm::OwningPtr<CompilationDatabase> Compilations(
+        FixedCompilationDatabase::loadFromCommandLine(argc, argv));
+  if (!Compilations) {  // Couldn't find a compilation DB from the command line
+    std::string ErrorMessage;
+    Compilations.reset(
+      !BuildPath.empty() ?
+        CompilationDatabase::autoDetectFromDirectory(BuildPath, ErrorMessage) :
+        CompilationDatabase::autoDetectFromSource(SourcePaths[0], ErrorMessage)
+      );
+
+    // Still no compilation DB? - bail.
+    if (!Compilations)
+      llvm::report_fatal_error(ErrorMessage);
+  }
+
+  ClangTool Tool(*Compilations, SourcePaths);
+  std::vector<ASTUnit *> ASTs;
   if (Tool.buildASTs(ASTs) != 0)
     return 1;
 
@@ -80,7 +103,7 @@ int main(int argc, const char **argv) {
     for (cl::list<std::string>::iterator I = Commands.begin(),
                                          E = Commands.end();
          I != E; ++I) {
-      QueryRef Q = QueryParser::parse(I->c_str(), QS);
+      QueryRef Q = ParseQuery(I->c_str());
       if (!Q->run(llvm::outs(), QS))
         return 1;
     }
@@ -97,22 +120,39 @@ int main(int argc, const char **argv) {
         std::string Line;
         std::getline(Input, Line);
 
-        QueryRef Q = QueryParser::parse(Line.c_str(), QS);
+        QueryRef Q = ParseQuery(Line.c_str());
         if (!Q->run(llvm::outs(), QS))
           return 1;
       }
     }
   } else {
-    LineEditor LE("clang-query");
-    LE.setListCompleter([&QS](StringRef Line, size_t Pos) {
-      return QueryParser::complete(Line, Pos, QS);
-    });
-    while (llvm::Optional<std::string> Line = LE.readLine()) {
-      QueryRef Q = QueryParser::parse(*Line, QS);
+    History *Hist = history_init();
+    HistEvent Event;
+    history(Hist, &Event, H_SETSIZE, 100);
+
+    EditLine *EL = el_init("clang-query", stdin, stdout, stderr);
+    el_set(EL, EL_PROMPT, ReturnPrompt);
+    el_set(EL, EL_EDITOR, "emacs");
+    el_set(EL, EL_HIST, history, Hist);
+
+    int Count;
+    while (const char *Line = el_gets(EL, &Count)) {
+      if (Count == 0)
+        break;
+
+      history(Hist, &Event, H_ENTER, Line);
+
+      QueryRef Q = ParseQuery(Line);
       Q->run(llvm::outs(), QS);
-      llvm::outs().flush();
     }
+
+    history_end(Hist);
+    el_end(EL);
+
+    llvm::outs() << "\n";
   }
 
+  llvm::DeleteContainerPointers(ASTs);
+
   return 0;
 }

clang-tools-extra/clang-query/tool/Makefile

@@ -1,39 +0,0 @@
-##===- tools/extra/clang-query/tool/Makefile ---------------*- Makefile -*-===##
-#
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-##===----------------------------------------------------------------------===##
-
-CLANG_LEVEL := ../../../..
-include $(CLANG_LEVEL)/../../Makefile.config
-
-TOOLNAME = clang-query
-
-# No plugins, optimize startup time.
-TOOL_NO_EXPORTS = 1
-
-SOURCES = ClangQuery.cpp
-
-LINK_COMPONENTS := $(TARGETS_TO_BUILD) asmparser bitreader support mc mcparser option
-USEDLIBS = clangQuery.a clangDynamicASTMatchers.a clangFormat.a clangTooling.a \
-	   clangFrontend.a clangSerialization.a clangDriver.a clangRewriteFrontend.a \
-	   LLVMLineEditor.a clangRewrite.a clangParse.a clangSema.a clangAnalysis.a \
-	   clangAST.a clangASTMatchers.a clangEdit.a clangLex.a clangBasic.a
-
-include $(CLANG_LEVEL)/Makefile
-
-CPP.Flags += -I$(PROJ_SRC_DIR)/..
-
-# BUILT_SOURCES gets used as a prereq for many top-level targets. However, at
-# the point those targets are defined, $(ObjDir) hasn't been defined and so the
-# directory to create becomes /<name>/ which is not what we want. So instead,
-# this .objdir recipe is defined at at point where $(ObjDir) is defined and
-# it's specialized to $(ObjDir) to ensure it only works on targets we want it
-# to.
-$(ObjDir)/%.objdir:
-	$(Verb) $(MKDIR) $(ObjDir)/$* > /dev/null
-	$(Verb) $(DOTDIR_TIMESTAMP_COMMAND) > $@
-

clang-tools-extra/clang-rename/CMakeLists.txt

@@ -1,16 +0,0 @@
-set(LLVM_LINK_COMPONENTS support)
-
-add_clang_library(clangRename
-  USRFinder.cpp
-  USRFindingAction.cpp
-  USRLocFinder.cpp
-  RenamingAction.cpp
-
-  LINK_LIBS
-  clangAST
-  clangBasic
-  clangIndex
-  clangToolingCore
-  )
-
-add_subdirectory(tool)

clang-tools-extra/clang-rename/Makefile

@@ -1,16 +0,0 @@
-##===- tools/extra/clang-rename/Makefile -------------------*- Makefile -*-===##
-#
-# The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-##===----------------------------------------------------------------------===##
-
-CLANG_LEVEL := ../../..
-LIBRARYNAME = clangRename
-include $(CLANG_LEVEL)/../../Makefile.config
-
-DIRS = tool
-
-include $(CLANG_LEVEL)/Makefile

clang-tools-extra/clang-rename/RenamingAction.cpp

@@ -1,90 +0,0 @@
-//===--- tools/extra/clang-rename/RenamingAction.cpp - Clang rename tool --===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Provides an action to rename every symbol at a point.
-///
-//===----------------------------------------------------------------------===//
-
-#include "RenamingAction.h"
-#include "USRLocFinder.h"
-#include "clang/AST/ASTConsumer.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/Basic/FileManager.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/FrontendAction.h"
-#include "clang/Lex/Lexer.h"
-#include "clang/Lex/Preprocessor.h"
-#include "clang/Tooling/CommonOptionsParser.h"
-#include "clang/Tooling/Refactoring.h"
-#include "clang/Tooling/Tooling.h"
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string>
-#include <vector>
-
-using namespace llvm;
-
-namespace clang {
-namespace rename {
-
-class RenamingASTConsumer : public ASTConsumer {
-public:
-  RenamingASTConsumer(const std::string &NewName,
-                      const std::string &PrevName,
-                      const std::vector<std::string> &USRs,
-                      tooling::Replacements &Replaces,
-                      bool PrintLocations)
-      : NewName(NewName), PrevName(PrevName), USRs(USRs), Replaces(Replaces),
-        PrintLocations(PrintLocations) {
-  }
-
-  void HandleTranslationUnit(ASTContext &Context) override {
-    const auto &SourceMgr = Context.getSourceManager();
-    std::vector<SourceLocation> RenamingCandidates;
-    std::vector<SourceLocation> NewCandidates;
-
-    for (const auto &USR : USRs) {
-      NewCandidates = getLocationsOfUSR(USR, Context.getTranslationUnitDecl());
-      RenamingCandidates.insert(RenamingCandidates.end(), NewCandidates.begin(),
-                                NewCandidates.end());
-      NewCandidates.clear();
-    }
-
-    auto PrevNameLen = PrevName.length();
-    if (PrintLocations)
-      for (const auto &Loc : RenamingCandidates) {
-        FullSourceLoc FullLoc(Loc, SourceMgr);
-        errs() << "clang-rename: renamed at: " << SourceMgr.getFilename(Loc)
-               << ":" << FullLoc.getSpellingLineNumber() << ":"
-               << FullLoc.getSpellingColumnNumber() << "\n";
-        Replaces.insert(tooling::Replacement(SourceMgr, Loc, PrevNameLen,
-                                             NewName));
-      }
-    else
-      for (const auto &Loc : RenamingCandidates)
-        Replaces.insert(tooling::Replacement(SourceMgr, Loc, PrevNameLen,
-                                             NewName));
-  }
-
-private:
-  const std::string &NewName, &PrevName;
-  const std::vector<std::string> &USRs;
-  tooling::Replacements &Replaces;
-  bool PrintLocations;
-};
-
-std::unique_ptr<ASTConsumer> RenamingAction::newASTConsumer() {
-  return llvm::make_unique<RenamingASTConsumer>(NewName, PrevName, USRs,
-                                                Replaces, PrintLocations);
-}
-
-}
-}

clang-tools-extra/clang-rename/RenamingAction.h

@@ -1,47 +0,0 @@
-//===--- tools/extra/clang-rename/RenamingAction.h - Clang rename tool ----===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Provides an action to rename every symbol at a point.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H_
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H_
-
-#include "clang/Tooling/Refactoring.h"
-
-namespace clang {
-class ASTConsumer;
-class CompilerInstance;
-
-namespace rename {
-
-class RenamingAction {
-public:
-  RenamingAction(const std::string &NewName, const std::string &PrevName,
-                 const std::vector<std::string> &USRs,
-                 tooling::Replacements &Replaces, bool PrintLocations = false)
-      : NewName(NewName), PrevName(PrevName), USRs(USRs), Replaces(Replaces),
-        PrintLocations(PrintLocations) {
-  }
-
-  std::unique_ptr<ASTConsumer> newASTConsumer();
-
-private:
-  const std::string &NewName, &PrevName;
-  const std::vector<std::string> &USRs;
-  tooling::Replacements &Replaces;
-  bool PrintLocations;
-};
-
-}
-}
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H_

clang-tools-extra/clang-rename/USRFinder.cpp

@@ -1,162 +0,0 @@
-//===--- tools/extra/clang-rename/USRFinder.cpp - Clang rename tool -------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file Implements a recursive AST visitor that finds the USR of a symbol at a
-/// point.
-///
-//===----------------------------------------------------------------------===//
-
-#include "USRFinder.h"
-#include "clang/AST/AST.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/RecursiveASTVisitor.h"
-#include "clang/Index/USRGeneration.h"
-#include "clang/Lex/Lexer.h"
-#include "llvm/ADT/SmallVector.h"
-
-using namespace llvm;
-
-namespace clang {
-namespace rename {
-
-// NamedDeclFindingASTVisitor recursively visits each AST node to find the
-// symbol underneath the cursor.
-// FIXME: move to seperate .h/.cc file if this gets too large.
-namespace {
-class NamedDeclFindingASTVisitor
-    : public clang::RecursiveASTVisitor<NamedDeclFindingASTVisitor> {
-public:
-  // \brief Finds the NamedDecl at a point in the source.
-  // \param Point the location in the source to search for the NamedDecl.
-  explicit NamedDeclFindingASTVisitor(const SourceManager &SourceMgr,
-                                      const SourceLocation Point)
-      : Result(nullptr), SourceMgr(SourceMgr),
-        Point(Point) {
-  }
-
-  // Declaration visitors:
-
-  // \brief Checks if the point falls within the NameDecl. This covers every
-  // declaration of a named entity that we may come across. Usually, just
-  // checking if the point lies within the length of the name of the declaration
-  // and the start location is sufficient.
-  bool VisitNamedDecl(const NamedDecl *Decl) {
-    return setResult(Decl, Decl->getLocation(),
-                     Decl->getNameAsString().length());
-  }
-
-  // Expression visitors:
-
-  bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
-    // Check the namespace specifier first.
-    if (!checkNestedNameSpecifierLoc(Expr->getQualifierLoc()))
-      return false;
-
-    const auto *Decl = Expr->getFoundDecl();
-    return setResult(Decl, Expr->getLocation(),
-                     Decl->getNameAsString().length());
-  }
-
-  bool VisitMemberExpr(const MemberExpr *Expr) {
-    const auto *Decl = Expr->getFoundDecl().getDecl();
-    return setResult(Decl, Expr->getMemberLoc(),
-                     Decl->getNameAsString().length());
-  }
-
-  // Other:
-
-  const NamedDecl *getNamedDecl() {
-    return Result;
-  }
-
-private:
-  // \brief Determines if a namespace qualifier contains the point.
-  // \returns false on success and sets Result.
-  bool checkNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
-    while (NameLoc) {
-      const auto *Decl = NameLoc.getNestedNameSpecifier()->getAsNamespace();
-      if (Decl && !setResult(Decl, NameLoc.getLocalBeginLoc(),
-                             Decl->getNameAsString().length()))
-        return false;
-      NameLoc = NameLoc.getPrefix();
-    }
-    return true;
-  }
-
-  // \brief Sets Result to Decl if the Point is within Start and End.
-  // \returns false on success.
-  bool setResult(const NamedDecl *Decl, SourceLocation Start,
-                 SourceLocation End) {
-    if (!Start.isValid() || !Start.isFileID() || !End.isValid() ||
-        !End.isFileID() || !isPointWithin(Start, End)) {
-      return true;
-    }
-    Result = Decl;
-    return false;
-  }
-
-  // \brief Sets Result to Decl if Point is within Loc and Loc + Offset.
-  // \returns false on success.
-  bool setResult(const NamedDecl *Decl, SourceLocation Loc,
-                 unsigned Offset) {
-    // FIXME: Add test for Offset == 0. Add test for Offset - 1 (vs -2 etc).
-    return Offset == 0 ||
-           setResult(Decl, Loc, Loc.getLocWithOffset(Offset - 1));
-  }
-
-  // \brief Determines if the Point is within Start and End.
-  bool isPointWithin(const SourceLocation Start, const SourceLocation End) {
-    // FIXME: Add tests for Point == End.
-    return Point == Start || Point == End ||
-           (SourceMgr.isBeforeInTranslationUnit(Start, Point) &&
-            SourceMgr.isBeforeInTranslationUnit(Point, End));
-  }
-
-  const NamedDecl *Result;
-  const SourceManager &SourceMgr;
-  const SourceLocation Point; // The location to find the NamedDecl.
-};
-}
-
-const NamedDecl *getNamedDeclAt(const ASTContext &Context,
-                                const SourceLocation Point) {
-  const auto &SourceMgr = Context.getSourceManager();
-  const auto SearchFile = SourceMgr.getFilename(Point);
-
-  NamedDeclFindingASTVisitor Visitor(SourceMgr, Point);
-
-  // We only want to search the decls that exist in the same file as the point.
-  auto Decls = Context.getTranslationUnitDecl()->decls();
-  for (auto &CurrDecl : Decls) {
-    const auto FileLoc = CurrDecl->getLocStart();
-    const auto FileName = SourceMgr.getFilename(FileLoc);
-    // FIXME: Add test.
-    if (FileName == SearchFile) {
-      Visitor.TraverseDecl(CurrDecl);
-      if (const NamedDecl *Result = Visitor.getNamedDecl()) {
-        return Result;
-      }
-    }
-  }
-
-  return nullptr;
-}
-
-std::string getUSRForDecl(const Decl *Decl) {
-  llvm::SmallVector<char, 128> Buff;
-
-  // FIXME: Add test for the nullptr case.
-  if (Decl == nullptr || index::generateUSRForDecl(Decl, Buff))
-    return "";
-
-  return std::string(Buff.data(), Buff.size());
-}
-
-} // namespace clang
-} // namespace rename

clang-tools-extra/clang-rename/USRFinder.h

@@ -1,39 +0,0 @@
-//===--- tools/extra/clang-rename/USRFinder.h - Clang rename tool ---------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Methods for determining the USR of a symbol at a location in source
-/// code.
-///
-//===----------------------------------------------------------------------===//
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDER_H
-
-#include <string>
-
-namespace clang {
-class ASTContext;
-class Decl;
-class SourceLocation;
-class NamedDecl;
-
-namespace rename {
-
-// Given an AST context and a point, returns a NamedDecl identifying the symbol
-// at the point. Returns null if nothing is found at the point.
-const NamedDecl *getNamedDeclAt(const ASTContext &Context,
-                                const SourceLocation Point);
-
-// Converts a Decl into a USR.
-std::string getUSRForDecl(const Decl *Decl);
-
-}
-}
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDER_H

clang-tools-extra/clang-rename/USRFindingAction.cpp

@@ -1,118 +0,0 @@
-//===--- tools/extra/clang-rename/USRFindingAction.cpp - Clang rename tool ===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Provides an action to rename every symbol at a point.
-///
-//===----------------------------------------------------------------------===//
-
-#include "USRFindingAction.h"
-#include "USRFinder.h"
-#include "clang/AST/AST.h"
-#include "clang/AST/ASTConsumer.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/Basic/FileManager.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/FrontendAction.h"
-#include "clang/Lex/Lexer.h"
-#include "clang/Lex/Preprocessor.h"
-#include "clang/Tooling/CommonOptionsParser.h"
-#include "clang/Tooling/Refactoring.h"
-#include "clang/Tooling/Tooling.h"
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string>
-#include <vector>
-
-using namespace llvm;
-
-namespace clang {
-namespace rename {
-
-// Get the USRs for the constructors of the class.
-static std::vector<std::string> getAllConstructorUSRs(
-    const CXXRecordDecl *Decl) {
-  std::vector<std::string> USRs;
-
-  // We need to get the definition of the record (as opposed to any forward
-  // declarations) in order to find the constructor and destructor.
-  const auto *RecordDecl = Decl->getDefinition();
-
-  // Iterate over all the constructors and add their USRs.
-  for (const auto &CtorDecl : RecordDecl->ctors())
-    USRs.push_back(getUSRForDecl(CtorDecl));
-
-  // Ignore destructors. GetLocationsOfUSR will find the declaration of and
-  // explicit calls to a destructor through TagTypeLoc (and it is better for the
-  // purpose of renaming).
-  //
-  // For example, in the following code segment,
-  //  1  class C {
-  //  2    ~C();
-  //  3  };
-  // At line 3, there is a NamedDecl starting from '~' and a TagTypeLoc starting
-  // from 'C'.
-
-  return USRs;
-}
-
-struct NamedDeclFindingConsumer : public ASTConsumer {
-  void HandleTranslationUnit(ASTContext &Context) override {
-    const auto &SourceMgr = Context.getSourceManager();
-    // The file we look for the USR in will always be the main source file.
-    const auto Point = SourceMgr.getLocForStartOfFile(
-        SourceMgr.getMainFileID()).getLocWithOffset(SymbolOffset);
-    if (!Point.isValid())
-      return;
-    const NamedDecl *FoundDecl = getNamedDeclAt(Context, Point);
-    if (FoundDecl == nullptr) {
-      FullSourceLoc FullLoc(Point, SourceMgr);
-      errs() << "clang-rename: could not find symbol at "
-             << SourceMgr.getFilename(Point) << ":"
-             << FullLoc.getSpellingLineNumber() << ":"
-             << FullLoc.getSpellingColumnNumber() << " (offset " << SymbolOffset
-             << ").\n";
-      return;
-    }
-
-    // If the decl is a constructor or destructor, we want to instead take the
-    // decl of the parent record.
-    if (const auto *CtorDecl = dyn_cast<CXXConstructorDecl>(FoundDecl))
-      FoundDecl = CtorDecl->getParent();
-    else if (const auto *DtorDecl = dyn_cast<CXXDestructorDecl>(FoundDecl))
-      FoundDecl = DtorDecl->getParent();
-
-    // If the decl is in any way relatedpp to a class, we want to make sure we
-    // search for the constructor and destructor as well as everything else.
-    if (const auto *Record = dyn_cast<CXXRecordDecl>(FoundDecl))
-      *USRs = getAllConstructorUSRs(Record);
-
-    USRs->push_back(getUSRForDecl(FoundDecl));
-    *SpellingName = FoundDecl->getNameAsString();
-  }
-
-  unsigned SymbolOffset;
-  std::string *SpellingName;
-  std::vector<std::string> *USRs;
-};
-
-std::unique_ptr<ASTConsumer>
-USRFindingAction::newASTConsumer() {
-  std::unique_ptr<NamedDeclFindingConsumer> Consumer(
-      new NamedDeclFindingConsumer);
-  SpellingName = "";
-  Consumer->SymbolOffset = SymbolOffset;
-  Consumer->USRs = &USRs;
-  Consumer->SpellingName = &SpellingName;
-  return std::move(Consumer);
-}
-
-} // namespace rename
-} // namespace clang

clang-tools-extra/clang-rename/USRFindingAction.h

@@ -1,50 +0,0 @@
-//===--- tools/extra/clang-rename/USRFindingAction.h - Clang rename tool --===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Provides an action to find all relevent USRs at a point.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDING_ACTION_H_
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDING_ACTION_H_
-
-#include "clang/Frontend/FrontendAction.h"
-
-namespace clang {
-class ASTConsumer;
-class CompilerInstance;
-class NamedDecl;
-
-namespace rename {
-
-struct USRFindingAction {
-  USRFindingAction(unsigned Offset) : SymbolOffset(Offset) {
-  }
-  std::unique_ptr<ASTConsumer> newASTConsumer();
-
-  // \brief get the spelling of the USR(s) as it would appear in source files.
-  const std::string &getUSRSpelling() {
-    return SpellingName;
-  }
-
-  const std::vector<std::string> &getUSRs() {
-    return USRs;
-  }
-
-private:
-  unsigned SymbolOffset;
-  std::string SpellingName;
-  std::vector<std::string> USRs;
-};
-
-}
-}
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDING_ACTION_H_

clang-tools-extra/clang-rename/USRLocFinder.cpp

@@ -1,103 +0,0 @@
-//===--- tools/extra/clang-rename/USRLocFinder.cpp - Clang rename tool ----===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Mehtods for finding all instances of a USR. Our strategy is very
-/// simple; we just compare the USR at every relevant AST node with the one
-/// provided.
-///
-//===----------------------------------------------------------------------===//
-
-#include "USRLocFinder.h"
-#include "USRFinder.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/RecursiveASTVisitor.h"
-#include "clang/Basic/SourceLocation.h"
-#include "clang/Index/USRGeneration.h"
-#include "llvm/ADT/SmallVector.h"
-
-using namespace llvm;
-
-namespace clang {
-namespace rename {
-
-namespace {
-// \brief This visitor recursively searches for all instances of a USR in a
-// translation unit and stores them for later usage.
-class USRLocFindingASTVisitor
-    : public clang::RecursiveASTVisitor<USRLocFindingASTVisitor> {
-public:
-  explicit USRLocFindingASTVisitor(const std::string USR) : USR(USR) {
-  }
-
-  // Declaration visitors:
-
-  bool VisitNamedDecl(const NamedDecl *Decl) {
-    if (getUSRForDecl(Decl) == USR) {
-      LocationsFound.push_back(Decl->getLocation());
-    }
-    return true;
-  }
-
-  // Expression visitors:
-
-  bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
-    const auto *Decl = Expr->getFoundDecl();
-
-    checkNestedNameSpecifierLoc(Expr->getQualifierLoc());
-    if (getUSRForDecl(Decl) == USR) {
-      LocationsFound.push_back(Expr->getLocation());
-    }
-
-    return true;
-  }
-
-  bool VisitMemberExpr(const MemberExpr *Expr) {
-    const auto *Decl = Expr->getFoundDecl().getDecl();
-    if (getUSRForDecl(Decl) == USR) {
-      LocationsFound.push_back(Expr->getMemberLoc());
-    }
-    return true;
-  }
-
-  // Non-visitors:
-
-  // \brief Returns a list of unique locations. Duplicate or overlapping
-  // locations are erroneous and should be reported!
-  const std::vector<clang::SourceLocation> &getLocationsFound() const {
-    return LocationsFound;
-  }
-
-private:
-  // Namespace traversal:
-  void checkNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
-    while (NameLoc) {
-      const auto *Decl = NameLoc.getNestedNameSpecifier()->getAsNamespace();
-      if (Decl && getUSRForDecl(Decl) == USR)
-        LocationsFound.push_back(NameLoc.getLocalBeginLoc());
-      NameLoc = NameLoc.getPrefix();
-    }
-  }
-
-  // All the locations of the USR were found.
-  const std::string USR;
-  std::vector<clang::SourceLocation> LocationsFound;
-};
-} // namespace
-
-std::vector<SourceLocation> getLocationsOfUSR(const std::string USR,
-                                              Decl *Decl) {
-  USRLocFindingASTVisitor visitor(USR);
-
-  visitor.TraverseDecl(Decl);
-  return visitor.getLocationsFound();
-}
-
-} // namespace rename
-} // namespace clang

clang-tools-extra/clang-rename/USRLocFinder.h

@@ -1,35 +0,0 @@
-//===--- tools/extra/clang-rename/USRLocFinder.h - Clang rename tool ------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Provides functionality for finding all instances of a USR in a given
-/// AST.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H
-
-#include <string>
-#include <vector>
-
-namespace clang {
-
-class Decl;
-class SourceLocation;
-
-namespace rename {
-
-// FIXME: make this an AST matcher. Wouldn't that be awesome??? I agree!
-std::vector<SourceLocation> getLocationsOfUSR(const std::string usr,
-                                              Decl *decl);
-}
-}
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H

clang-tools-extra/clang-rename/tool/CMakeLists.txt

@@ -1,11 +0,0 @@
-add_clang_executable(clang-rename ClangRename.cpp)
-
-target_link_libraries(clang-rename
-  clangBasic
-  clangFrontend
-  clangRename
-  clangRewrite
-  clangTooling
-  )
-
-install(TARGETS clang-rename RUNTIME DESTINATION bin)

clang-tools-extra/clang-rename/tool/ClangRename.cpp

@@ -1,151 +0,0 @@
-//===--- tools/extra/clang-rename/ClangRename.cpp - Clang rename tool -----===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief This file implements a clang-rename tool that automatically finds and
-/// renames symbols in C++ code.
-///
-//===----------------------------------------------------------------------===//
-
-#include "../USRFindingAction.h"
-#include "../RenamingAction.h"
-#include "clang/AST/ASTConsumer.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/Basic/FileManager.h"
-#include "clang/Basic/LangOptions.h"
-#include "clang/Basic/TargetInfo.h"
-#include "clang/Basic/TargetOptions.h"
-#include "clang/Frontend/CommandLineSourceLoc.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/FrontendAction.h"
-#include "clang/Frontend/TextDiagnosticPrinter.h"
-#include "clang/Lex/Lexer.h"
-#include "clang/Lex/Preprocessor.h"
-#include "clang/Parse/ParseAST.h"
-#include "clang/Parse/Parser.h"
-#include "clang/Rewrite/Core/Rewriter.h"
-#include "clang/Tooling/CommonOptionsParser.h"
-#include "clang/Tooling/Refactoring.h"
-#include "clang/Tooling/Tooling.h"
-#include "llvm/ADT/IntrusiveRefCntPtr.h"
-#include "llvm/Support/Host.h"
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string>
-#include <time.h>
-#include <vector>
-
-using namespace llvm;
-
-cl::OptionCategory ClangRenameCategory("Clang-rename options");
-
-static cl::opt<std::string>
-NewName(
-    "new-name",
-    cl::desc("The new name to change the symbol to."),
-    cl::cat(ClangRenameCategory));
-static cl::opt<unsigned>
-SymbolOffset(
-    "offset",
-    cl::desc("Locates the symbol by offset as opposed to <line>:<column>."),
-    cl::cat(ClangRenameCategory));
-static cl::opt<bool>
-Inplace(
-    "i",
-    cl::desc("Overwrite edited <file>s."),
-    cl::cat(ClangRenameCategory));
-static cl::opt<bool>
-PrintName(
-    "pn",
-    cl::desc("Print the found symbol's name prior to renaming to stderr."),
-    cl::cat(ClangRenameCategory));
-static cl::opt<bool>
-PrintLocations(
-    "pl",
-    cl::desc("Print the locations affected by renaming to stderr."),
-    cl::cat(ClangRenameCategory));
-
-#define CLANG_RENAME_VERSION "0.0.1"
-
-static void PrintVersion() {
-  outs() << "clang-rename version " << CLANG_RENAME_VERSION << "\n";
-}
-
-using namespace clang;
-
-const char RenameUsage[] = "A tool to rename symbols in C/C++ code.\n\
-clang-rename renames every occurrence of a symbol found at <offset> in\n\
-<source0>. If -i is specified, the edited files are overwritten to disk.\n\
-Otherwise, the results are written to stdout.\n";
-
-int main(int argc, const char **argv) {
-  cl::SetVersionPrinter(PrintVersion);
-  tooling::CommonOptionsParser OP(argc, argv, ClangRenameCategory, RenameUsage);
-
-  // Check the arguments for correctness.
-
-  if (NewName.empty()) {
-    errs() << "clang-rename: no new name provided.\n\n";
-    cl::PrintHelpMessage();
-    exit(1);
-  }
-
-  // Get the USRs.
-  auto Files = OP.getSourcePathList();
-  tooling::RefactoringTool Tool(OP.getCompilations(), Files);
-  rename::USRFindingAction USRAction(SymbolOffset);
-
-  // Find the USRs.
-  Tool.run(tooling::newFrontendActionFactory(&USRAction).get());
-  const auto &USRs = USRAction.getUSRs();
-  const auto &PrevName = USRAction.getUSRSpelling();
-
-  if (PrevName.empty())
-    // An error should have already been printed.
-    exit(1);
-
-  if (PrintName)
-    errs() << "clang-rename: found name: " << PrevName;
-
-  // Perform the renaming.
-  rename::RenamingAction RenameAction(NewName, PrevName, USRs,
-                                      Tool.getReplacements(), PrintLocations);
-  auto Factory = tooling::newFrontendActionFactory(&RenameAction);
-  int res;
-
-  if (Inplace) {
-    res = Tool.runAndSave(Factory.get());
-  } else {
-    res = Tool.run(Factory.get());
-
-    // Write every file to stdout. Right now we just barf the files without any
-    // indication of which files start where, other than that we print the files
-    // in the same order we see them.
-    LangOptions DefaultLangOptions;
-    IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts =
-        new DiagnosticOptions();
-    TextDiagnosticPrinter DiagnosticPrinter(errs(), &*DiagOpts);
-    DiagnosticsEngine Diagnostics(
-        IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
-        &*DiagOpts, &DiagnosticPrinter, false);
-    auto &FileMgr = Tool.getFiles();
-    SourceManager Sources(Diagnostics, FileMgr);
-    Rewriter Rewrite(Sources, DefaultLangOptions);
-
-    Tool.applyAllReplacements(Rewrite);
-    for (const auto &File : Files) {
-      const auto *Entry = FileMgr.getFile(File);
-      auto ID = Sources.translateFile(Entry);
-      Rewrite.getEditBuffer(ID).write(outs());
-    }
-  }
-
-  exit(res);
-}

clang-tools-extra/clang-rename/tool/Makefile

@@ -1,13 +0,0 @@
-CLANG_LEVEL := ../../../..
-TOOLNAME = clang-rename
-include $(CLANG_LEVEL)/../../Makefile.config
-LINK_COMPONENTS := $(TARGETS_TO_BUILD) asmparser bitreader support mc option
-USEDLIBS = clangRename.a clangFrontend.a clangSerialization.a clangDriver.a \
-           clangTooling.a clangToolingCore.a \
-	   clangParse.a clangSema.a clangIndex.a \
-           clangStaticAnalyzerFrontend.a clangStaticAnalyzerCheckers.a \
-           clangStaticAnalyzerCore.a clangAnalysis.a clangRewriteFrontend.a \
-           clangRewrite.a clangEdit.a clangAST.a clangLex.a clangBasic.a
-
-include $(CLANG_LEVEL)/Makefile
-

clang-tools-extra/clang-tidy/CMakeLists.txt

@@ -1,32 +1,23 @@
 set(LLVM_LINK_COMPONENTS
-  Support
+  ${LLVM_TARGETS_TO_BUILD}
+  asmparser
+  bitreader
+  support
+  mc
   )
 
 add_clang_library(clangTidy
   ClangTidy.cpp
   ClangTidyModule.cpp
-  ClangTidyDiagnosticConsumer.cpp
-  ClangTidyOptions.cpp
-
-  DEPENDS
-  ClangSACheckers
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangFrontend
-  clangRewrite
-  clangSema
-  clangStaticAnalyzerCore
-  clangStaticAnalyzerFrontend
+  )
+target_link_libraries(clangTidy
   clangTooling
-  clangToolingCore
+  clangBasic
+  clangRewriteFrontend
+  clangStaticAnalyzerFrontend
+  clangStaticAnalyzerCheckers
   )
 
 add_subdirectory(tool)
 add_subdirectory(llvm)
 add_subdirectory(google)
-add_subdirectory(misc)
-add_subdirectory(readability)
-add_subdirectory(utils)

clang-tools-extra/clang-tidy/ClangTidy.cpp

@@ -22,297 +22,194 @@
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Lex/PPCallbacks.h"
+#include "clang/Lex/Preprocessor.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
-#include "clang/Frontend/FrontendDiagnostic.h"
-#include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
-#include "clang/Lex/PPCallbacks.h"
-#include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Frontend/FixItRewriter.h"
 #include "clang/Rewrite/Frontend/FrontendActions.h"
-#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
-#include "clang/Tooling/Refactoring.h"
-#include "clang/Tooling/ReplacementsYaml.h"
+#include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
 #include "clang/Tooling/Tooling.h"
+#include "clang/Tooling/Refactoring.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
-#include <algorithm>
-#include <utility>
+#include <vector>
 
 using namespace clang::ast_matchers;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace llvm;
 
-template class llvm::Registry<clang::tidy::ClangTidyModule>;
-
 namespace clang {
 namespace tidy {
-
 namespace {
-static const char *AnalyzerCheckNamePrefix = "clang-analyzer-";
 
-static StringRef StaticAnalyzerChecks[] = {
+/// \brief A combined ASTConsumer that forwards calls to two different
+/// consumers.
+///
+/// FIXME: This currently forwards just enough methods for the static analyzer
+/// and the \c MatchFinder's consumer to work; expand this to all methods of
+/// ASTConsumer and put it into a common location.
+class CombiningASTConsumer : public ASTConsumer {
+public:
+  CombiningASTConsumer(ASTConsumer *Consumer1, ASTConsumer *Consumer2)
+      : Consumer1(Consumer1), Consumer2(Consumer2) {}
+
+  virtual void Initialize(ASTContext &Context) LLVM_OVERRIDE {
+    Consumer1->Initialize(Context);
+    Consumer2->Initialize(Context);
+  }
+  virtual bool HandleTopLevelDecl(DeclGroupRef D) LLVM_OVERRIDE {
+    return Consumer1->HandleTopLevelDecl(D) && Consumer2->HandleTopLevelDecl(D);
+  }
+  virtual void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) LLVM_OVERRIDE {
+    Consumer1->HandleTopLevelDeclInObjCContainer(D);
+    Consumer2->HandleTopLevelDeclInObjCContainer(D);
+  }
+  virtual void HandleTranslationUnit(ASTContext &Context) LLVM_OVERRIDE {
+    Consumer1->HandleTranslationUnit(Context);
+    Consumer2->HandleTranslationUnit(Context);
+  }
+
+private:
+  llvm::OwningPtr<ASTConsumer> Consumer1;
+  llvm::OwningPtr<ASTConsumer> Consumer2;
+};
+
+/// \brief Action that runs clang-tidy and static analyzer checks.
+///
+/// FIXME: Note that this inherits from \c AnalysisAction as this is the only
+/// way we can currently get to AnalysisAction::CreateASTConsumer. Ideally
+/// we'd want to build a more generic way to use \c FrontendAction based
+/// checkers in clang-tidy, but that needs some preparation work first.
+class ClangTidyAction : public ento::AnalysisAction {
+public:
+  ClangTidyAction(StringRef CheckRegexString,
+                  SmallVectorImpl<ClangTidyCheck *> &Checks,
+                  ClangTidyContext &Context, MatchFinder &Finder)
+      : CheckRegexString(CheckRegexString), Checks(Checks), Context(Context),
+        Finder(Finder) {}
+
+private:
+  clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &Compiler,
+                                        StringRef File) LLVM_OVERRIDE {
+    AnalyzerOptionsRef Options = Compiler.getAnalyzerOpts();
+    llvm::Regex CheckRegex(CheckRegexString);
+
+    // Always add all core checkers if any other static analyzer checks are
+    // enabled. This is currently necessary, as other path sensitive checks rely
+    // on the core checkers.
+    if (CheckRegex.match("clang-analyzer-"))
+      Options->CheckersControlList.push_back(std::make_pair("core", true));
+
+// Run our regex against all possible static analyzer checkers.
+// Note that debug checkers print values / run programs to visualize the CFG
+// and are thus not applicable to clang-tidy in general.
 #define GET_CHECKERS
 #define CHECKER(FULLNAME, CLASS, DESCFILE, HELPTEXT, GROUPINDEX, HIDDEN)       \
-  FULLNAME,
+  if (!StringRef(FULLNAME).startswith("core") &&                               \
+      !StringRef(FULLNAME).startswith("debug") &&                              \
+      CheckRegex.match("clang-analyzer-" FULLNAME))                            \
+    Options->CheckersControlList.push_back(std::make_pair(FULLNAME, true));
 #include "../../../lib/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS
-};
 
-class AnalyzerDiagnosticConsumer : public ento::PathDiagnosticConsumer {
-public:
-  AnalyzerDiagnosticConsumer(ClangTidyContext &Context) : Context(Context) {}
-
-  void FlushDiagnosticsImpl(std::vector<const ento::PathDiagnostic *> &Diags,
-                            FilesMade *filesMade) override {
-    for (const ento::PathDiagnostic *PD : Diags) {
-      SmallString<64> CheckName(AnalyzerCheckNamePrefix);
-      CheckName += PD->getCheckName();
-      Context.diag(CheckName, PD->getLocation().asLocation(),
-                   PD->getShortDescription())
-          << PD->path.back()->getRanges();
-
-      for (const auto &DiagPiece :
-           PD->path.flatten(/*ShouldFlattenMacros=*/true)) {
-        Context.diag(CheckName, DiagPiece->getLocation().asLocation(),
-                     DiagPiece->getString(), DiagnosticIDs::Note)
-            << DiagPiece->getRanges();
-      }
-    }
+    Options->AnalysisStoreOpt = RegionStoreModel;
+    Options->AnalysisDiagOpt = PD_TEXT;
+    Options->AnalyzeNestedBlocks = true;
+    Options->eagerlyAssumeBinOpBifurcation = true;
+    return new CombiningASTConsumer(
+        Finder.newASTConsumer(),
+        ento::AnalysisAction::CreateASTConsumer(Compiler, File));
   }
 
-  StringRef getName() const override { return "ClangTidyDiags"; }
-  bool supportsLogicalOpControlFlow() const override { return true; }
-  bool supportsCrossFileDiagnostics() const override { return true; }
+  virtual bool BeginSourceFileAction(CompilerInstance &Compiler,
+                                     llvm::StringRef Filename) LLVM_OVERRIDE {
+    if (!ento::AnalysisAction::BeginSourceFileAction(Compiler, Filename))
+      return false;
+    Context.setSourceManager(&Compiler.getSourceManager());
+    for (SmallVectorImpl<ClangTidyCheck *>::iterator I = Checks.begin(),
+                                                     E = Checks.end();
+         I != E; ++I)
+      (*I)->registerPPCallbacks(Compiler);
+    return true;
+  }
 
-private:
+  std::string CheckRegexString;
+  SmallVectorImpl<ClangTidyCheck *> &Checks;
   ClangTidyContext &Context;
+  MatchFinder &Finder;
 };
 
-class ErrorReporter {
+class ClangTidyActionFactory : public FrontendActionFactory {
 public:
-  ErrorReporter(bool ApplyFixes)
-      : Files(FileSystemOptions()), DiagOpts(new DiagnosticOptions()),
-        DiagPrinter(new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts)),
-        Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts,
-              DiagPrinter),
-        SourceMgr(Diags, Files), Rewrite(SourceMgr, LangOpts),
-        ApplyFixes(ApplyFixes), TotalFixes(0), AppliedFixes(0) {
-    DiagOpts->ShowColors = llvm::sys::Process::StandardOutHasColors();
-    DiagPrinter->BeginSourceFile(LangOpts);
+  ClangTidyActionFactory(StringRef CheckRegexString, ClangTidyContext &Context)
+      : CheckRegexString(CheckRegexString), Context(Context) {
+    ClangTidyCheckFactories CheckFactories;
+    for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
+                                           E = ClangTidyModuleRegistry::end();
+         I != E; ++I) {
+      OwningPtr<ClangTidyModule> Module(I->instantiate());
+      Module->addCheckFactories(CheckFactories);
+    }
+
+    SmallVector<ClangTidyCheck *, 16> Checks;
+    CheckFactories.createChecks(CheckRegexString, Checks);
+
+    for (SmallVectorImpl<ClangTidyCheck *>::iterator I = Checks.begin(),
+                                                     E = Checks.end();
+         I != E; ++I) {
+      (*I)->setContext(&Context);
+      (*I)->registerMatchers(&Finder);
+    }
   }
 
-  void reportDiagnostic(const ClangTidyError &Error) {
-    const ClangTidyMessage &Message = Error.Message;
-    SourceLocation Loc = getLocation(Message.FilePath, Message.FileOffset);
-    // Contains a pair for each attempted fix: location and whether the fix was
-    // applied successfully.
-    SmallVector<std::pair<SourceLocation, bool>, 4> FixLocations;
-    {
-      auto Level = static_cast<DiagnosticsEngine::Level>(Error.DiagLevel);
-      DiagnosticBuilder Diag =
-          Diags.Report(Loc, Diags.getCustomDiagID(Level, "%0 [%1]"))
-          << Message.Message << Error.CheckName;
-      for (const tooling::Replacement &Fix : Error.Fix) {
-        SourceLocation FixLoc = getLocation(Fix.getFilePath(), Fix.getOffset());
-        SourceLocation FixEndLoc = FixLoc.getLocWithOffset(Fix.getLength());
-        Diag << FixItHint::CreateReplacement(SourceRange(FixLoc, FixEndLoc),
-                                             Fix.getReplacementText());
-        ++TotalFixes;
-        if (ApplyFixes) {
-          bool Success = Fix.isApplicable() && Fix.apply(Rewrite);
-          if (Success)
-            ++AppliedFixes;
-          FixLocations.push_back(std::make_pair(FixLoc, Success));
-        }
-      }
-    }
-    for (auto Fix : FixLocations) {
-      Diags.Report(Fix.first, Fix.second ? diag::note_fixit_applied
-                                         : diag::note_fixit_failed);
-    }
-    for (const ClangTidyMessage &Note : Error.Notes)
-      reportNote(Note);
-  }
-
-  void Finish() {
-    // FIXME: Run clang-format on changes.
-    if (ApplyFixes && TotalFixes > 0) {
-      llvm::errs() << "clang-tidy applied " << AppliedFixes << " of "
-                   << TotalFixes << " suggested fixes.\n";
-      Rewrite.overwriteChangedFiles();
-    }
+  virtual FrontendAction *create() {
+    return new ClangTidyAction(CheckRegexString, Checks, Context, Finder);
   }
 
 private:
-  SourceLocation getLocation(StringRef FilePath, unsigned Offset) {
-    if (FilePath.empty())
-      return SourceLocation();
-
-    const FileEntry *File = SourceMgr.getFileManager().getFile(FilePath);
-    FileID ID = SourceMgr.createFileID(File, SourceLocation(), SrcMgr::C_User);
-    return SourceMgr.getLocForStartOfFile(ID).getLocWithOffset(Offset);
-  }
-
-  void reportNote(const ClangTidyMessage &Message) {
-    SourceLocation Loc = getLocation(Message.FilePath, Message.FileOffset);
-    DiagnosticBuilder Diag =
-        Diags.Report(Loc, Diags.getCustomDiagID(DiagnosticsEngine::Note, "%0"))
-        << Message.Message;
-  }
-
-  FileManager Files;
-  LangOptions LangOpts; // FIXME: use langopts from each original file
-  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
-  DiagnosticConsumer *DiagPrinter;
-  DiagnosticsEngine Diags;
-  SourceManager SourceMgr;
-  Rewriter Rewrite;
-  bool ApplyFixes;
-  unsigned TotalFixes;
-  unsigned AppliedFixes;
-};
-
-class ClangTidyASTConsumer : public MultiplexConsumer {
-public:
-  ClangTidyASTConsumer(std::vector<std::unique_ptr<ASTConsumer>> Consumers,
-                       std::unique_ptr<ast_matchers::MatchFinder> Finder,
-                       std::vector<std::unique_ptr<ClangTidyCheck>> Checks)
-      : MultiplexConsumer(std::move(Consumers)), Finder(std::move(Finder)),
-        Checks(std::move(Checks)) {}
-
-private:
-  std::unique_ptr<ast_matchers::MatchFinder> Finder;
-  std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
+  std::string CheckRegexString;
+  SmallVector<ClangTidyCheck *, 8> Checks;
+  ClangTidyContext &Context;
+  MatchFinder Finder;
 };
 
 } // namespace
 
-ClangTidyASTConsumerFactory::ClangTidyASTConsumerFactory(
-    ClangTidyContext &Context)
-    : Context(Context), CheckFactories(new ClangTidyCheckFactories) {
-  for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
-                                         E = ClangTidyModuleRegistry::end();
-       I != E; ++I) {
-    std::unique_ptr<ClangTidyModule> Module(I->instantiate());
-    Module->addCheckFactories(*CheckFactories);
-  }
+ClangTidyMessage::ClangTidyMessage(StringRef Message) : Message(Message) {}
+
+ClangTidyMessage::ClangTidyMessage(StringRef Message,
+                                   const SourceManager &Sources,
+                                   SourceLocation Loc)
+    : Message(Message) {
+  FilePath = Sources.getFilename(Loc);
+  FileOffset = Sources.getFileOffset(Loc);
 }
 
-std::unique_ptr<clang::ASTConsumer>
-ClangTidyASTConsumerFactory::CreateASTConsumer(
-    clang::CompilerInstance &Compiler, StringRef File) {
-  // FIXME: Move this to a separate method, so that CreateASTConsumer doesn't
-  // modify Compiler.
-  Context.setSourceManager(&Compiler.getSourceManager());
-  Context.setCurrentFile(File);
-  Context.setASTContext(&Compiler.getASTContext());
+ClangTidyError::ClangTidyError(const ClangTidyMessage &Message)
+    : Message(Message) {}
 
-  std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
-  CheckFactories->createChecks(&Context, Checks);
-
-  ast_matchers::MatchFinder::MatchFinderOptions FinderOptions;
-  if (auto *P = Context.getCheckProfileData())
-    FinderOptions.CheckProfiling.emplace(P->Records);
-
-  std::unique_ptr<ast_matchers::MatchFinder> Finder(
-      new ast_matchers::MatchFinder(std::move(FinderOptions)));
-
-  for (auto &Check : Checks) {
-    Check->registerMatchers(&*Finder);
-    Check->registerPPCallbacks(Compiler);
-  }
-
-  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
-  if (!Checks.empty())
-    Consumers.push_back(Finder->newASTConsumer());
-
-  AnalyzerOptionsRef AnalyzerOptions = Compiler.getAnalyzerOpts();
-  // FIXME: Remove this option once clang's cfg-temporary-dtors option defaults
-  // to true.
-  AnalyzerOptions->Config["cfg-temporary-dtors"] =
-      Context.getOptions().AnalyzeTemporaryDtors ? "true" : "false";
-
-  GlobList &Filter = Context.getChecksFilter();
-  AnalyzerOptions->CheckersControlList = getCheckersControlList(Filter);
-  if (!AnalyzerOptions->CheckersControlList.empty()) {
-    AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
-    AnalyzerOptions->AnalysisDiagOpt = PD_NONE;
-    AnalyzerOptions->AnalyzeNestedBlocks = true;
-    AnalyzerOptions->eagerlyAssumeBinOpBifurcation = true;
-    std::unique_ptr<ento::AnalysisASTConsumer> AnalysisConsumer =
-        ento::CreateAnalysisConsumer(Compiler);
-    AnalysisConsumer->AddDiagnosticConsumer(
-        new AnalyzerDiagnosticConsumer(Context));
-    Consumers.push_back(std::move(AnalysisConsumer));
-  }
-  return llvm::make_unique<ClangTidyASTConsumer>(
-      std::move(Consumers), std::move(Finder), std::move(Checks));
+DiagnosticBuilder ClangTidyContext::Diag(SourceLocation Loc,
+                                         StringRef Message) {
+  return DiagEngine->Report(
+      Loc, DiagEngine->getCustomDiagID(DiagnosticsEngine::Warning, Message));
 }
 
-std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
-  std::vector<std::string> CheckNames;
-  GlobList &Filter = Context.getChecksFilter();
-  for (const auto &CheckFactory : *CheckFactories) {
-    if (Filter.contains(CheckFactory.first))
-      CheckNames.push_back(CheckFactory.first);
-  }
-
-  for (const auto &AnalyzerCheck : getCheckersControlList(Filter))
-    CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);
-
-  std::sort(CheckNames.begin(), CheckNames.end());
-  return CheckNames;
+void ClangTidyContext::setDiagnosticsEngine(DiagnosticsEngine *Engine) {
+  DiagEngine = Engine;
 }
 
-ClangTidyOptions::OptionMap ClangTidyASTConsumerFactory::getCheckOptions() {
-  ClangTidyOptions::OptionMap Options;
-  std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
-  CheckFactories->createChecks(&Context, Checks);
-  for (const auto &Check : Checks)
-    Check->storeOptions(Options);
-  return Options;
+void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
+  DiagEngine->setSourceManager(SourceMgr);
 }
 
-ClangTidyASTConsumerFactory::CheckersList
-ClangTidyASTConsumerFactory::getCheckersControlList(GlobList &Filter) {
-  CheckersList List;
-
-  bool AnalyzerChecksEnabled = false;
-  for (StringRef CheckName : StaticAnalyzerChecks) {
-    std::string Checker((AnalyzerCheckNamePrefix + CheckName).str());
-    AnalyzerChecksEnabled =
-        AnalyzerChecksEnabled ||
-        (!CheckName.startswith("debug") && Filter.contains(Checker));
-  }
-
-  if (AnalyzerChecksEnabled) {
-    // Run our regex against all possible static analyzer checkers.  Note that
-    // debug checkers print values / run programs to visualize the CFG and are
-    // thus not applicable to clang-tidy in general.
-    //
-    // Always add all core checkers if any other static analyzer checks are
-    // enabled. This is currently necessary, as other path sensitive checks
-    // rely on the core checkers.
-    for (StringRef CheckName : StaticAnalyzerChecks) {
-      std::string Checker((AnalyzerCheckNamePrefix + CheckName).str());
-
-      if (CheckName.startswith("core") ||
-          (!CheckName.startswith("debug") && Filter.contains(Checker)))
-        List.push_back(std::make_pair(CheckName, true));
-    }
-  }
-  return List;
-}
-
-DiagnosticBuilder ClangTidyCheck::diag(SourceLocation Loc, StringRef Message,
-                                       DiagnosticIDs::Level Level) {
-  return Context->diag(CheckName, Loc, Message, Level);
+/// \brief Store a \c ClangTidyError.
+void ClangTidyContext::storeError(const ClangTidyError &Error) {
+  Errors->push_back(Error);
 }
 
 void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
@@ -320,100 +217,62 @@ void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
   check(Result);
 }
 
-OptionsView::OptionsView(StringRef CheckName,
-                         const ClangTidyOptions::OptionMap &CheckOptions)
-    : NamePrefix(CheckName.str() + "."), CheckOptions(CheckOptions) {}
-
-std::string OptionsView::get(StringRef LocalName, std::string Default) const {
-  const auto &Iter = CheckOptions.find(NamePrefix + LocalName.str());
-  if (Iter != CheckOptions.end())
-    return Iter->second;
-  return Default;
+FrontendActionFactory *createClangTidyActionFactory(StringRef CheckRegexString,
+                                                    ClangTidyContext &Context) {
+  return new ClangTidyActionFactory(CheckRegexString, Context);
 }
 
-void OptionsView::store(ClangTidyOptions::OptionMap &Options,
-                        StringRef LocalName, StringRef Value) const {
-  Options[NamePrefix + LocalName.str()] = Value;
-}
-
-void OptionsView::store(ClangTidyOptions::OptionMap &Options,
-                        StringRef LocalName, int64_t Value) const {
-  store(Options, LocalName, llvm::itostr(Value));
-}
-
-std::vector<std::string> getCheckNames(const ClangTidyOptions &Options) {
-  clang::tidy::ClangTidyContext Context(
-      llvm::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
-                                                Options));
-  ClangTidyASTConsumerFactory Factory(Context);
-  return Factory.getCheckNames();
-}
-
-ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options) {
-  clang::tidy::ClangTidyContext Context(
-      llvm::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
-                                                Options));
-  ClangTidyASTConsumerFactory Factory(Context);
-  return Factory.getCheckOptions();
-}
-
-ClangTidyStats
-runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
-             const tooling::CompilationDatabase &Compilations,
-             ArrayRef<std::string> InputFiles,
-             std::vector<ClangTidyError> *Errors, ProfileData *Profile) {
-  ClangTool Tool(Compilations, InputFiles);
-  clang::tidy::ClangTidyContext Context(std::move(OptionsProvider));
-  if (Profile)
-    Context.setCheckProfileData(Profile);
-
+void runClangTidy(StringRef CheckRegexString,
+                  const tooling::CompilationDatabase &Compilations,
+                  ArrayRef<std::string> Ranges,
+                  SmallVectorImpl<ClangTidyError> *Errors) {
+  // FIXME: Ranges are currently full files. Support selecting specific
+  // (line-)ranges.
+  ClangTool Tool(Compilations, Ranges);
+  clang::tidy::ClangTidyContext Context(Errors);
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
 
   Tool.setDiagnosticConsumer(&DiagConsumer);
-
-  class ActionFactory : public FrontendActionFactory {
-  public:
-    ActionFactory(ClangTidyContext &Context) : ConsumerFactory(Context) {}
-    FrontendAction *create() override { return new Action(&ConsumerFactory); }
-
-  private:
-    class Action : public ASTFrontendAction {
-    public:
-      Action(ClangTidyASTConsumerFactory *Factory) : Factory(Factory) {}
-      std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
-                                                     StringRef File) override {
-        return Factory->CreateASTConsumer(Compiler, File);
-      }
-
-    private:
-      ClangTidyASTConsumerFactory *Factory;
-    };
-
-    ClangTidyASTConsumerFactory ConsumerFactory;
-  };
-
-  ActionFactory Factory(Context);
-  Tool.run(&Factory);
-  *Errors = Context.getErrors();
-  return Context.getStats();
+  Tool.run(createClangTidyActionFactory(CheckRegexString, Context));
 }
 
-void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix) {
-  ErrorReporter Reporter(Fix);
-  for (const ClangTidyError &Error : Errors)
-    Reporter.reportDiagnostic(Error);
-  Reporter.Finish();
+static void reportDiagnostic(const ClangTidyMessage &Message,
+                             SourceManager &SourceMgr,
+                             DiagnosticsEngine::Level Level,
+                             DiagnosticsEngine &Diags) {
+  SourceLocation Loc;
+  if (!Message.FilePath.empty()) {
+    const FileEntry *File =
+        SourceMgr.getFileManager().getFile(Message.FilePath);
+    FileID ID = SourceMgr.createFileID(File, SourceLocation(), SrcMgr::C_User);
+    Loc = SourceMgr.getLocForStartOfFile(ID);
+    Loc = Loc.getLocWithOffset(Message.FileOffset);
+  }
+  Diags.Report(Loc, Diags.getCustomDiagID(Level, Message.Message));
 }
 
-void exportReplacements(const std::vector<ClangTidyError> &Errors,
-                        raw_ostream &OS) {
-  tooling::TranslationUnitReplacements TUR;
-  for (const ClangTidyError &Error : Errors)
-    TUR.Replacements.insert(TUR.Replacements.end(), Error.Fix.begin(),
-                            Error.Fix.end());
-
-  yaml::Output YAML(OS);
-  YAML << TUR;
+void handleErrors(SmallVectorImpl<ClangTidyError> &Errors, bool Fix) {
+  FileManager Files((FileSystemOptions()));
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  DiagnosticConsumer *DiagPrinter =
+      new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts);
+  DiagnosticsEngine Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
+                          &*DiagOpts, DiagPrinter);
+  DiagPrinter->BeginSourceFile(LangOptions());
+  SourceManager SourceMgr(Diags, Files);
+  Rewriter Rewrite(SourceMgr, LangOptions());
+  for (SmallVectorImpl<ClangTidyError>::iterator I = Errors.begin(),
+                                                 E = Errors.end();
+       I != E; ++I) {
+    reportDiagnostic(I->Message, SourceMgr, DiagnosticsEngine::Warning, Diags);
+    for (unsigned i = 0, e = I->Notes.size(); i != e; ++i) {
+      reportDiagnostic(I->Notes[i], SourceMgr, DiagnosticsEngine::Note, Diags);
+    }
+    tooling::applyAllReplacements(I->Fix, Rewrite);
+  }
+  // FIXME: Run clang-format on changes.
+  if (Fix)
+    Rewrite.overwriteChangedFiles();
 }
 
 } // namespace tidy

clang-tools-extra/clang-tidy/ClangTidy.h

@@ -10,76 +10,24 @@
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_H
 
-#include "ClangTidyDiagnosticConsumer.h"
-#include "ClangTidyOptions.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Refactoring.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/raw_ostream.h"
-#include <memory>
-#include <type_traits>
-#include <vector>
+#include "ClangTidyDiagnosticConsumer.h"
 
 namespace clang {
 
 class CompilerInstance;
+namespace ast_matchers {
+class MatchFinder;
+}
 namespace tooling {
 class CompilationDatabase;
 }
 
 namespace tidy {
 
-/// \brief Provides access to the \c ClangTidyCheck options via check-local
-/// names.
-///
-/// Methods of this class prepend <tt>CheckName + "."</tt> to translate
-/// check-local option names to global option names.
-class OptionsView {
-public:
-  /// \brief Initializes the instance using \p CheckName + "." as a prefix.
-  OptionsView(StringRef CheckName,
-              const ClangTidyOptions::OptionMap &CheckOptions);
-
-  /// \brief Read a named option from the \c Context.
-  ///
-  /// Reads the option with the check-local name \p LocalName from the
-  /// \c CheckOptions. If the corresponding key is not present, returns
-  /// \p Default.
-  std::string get(StringRef LocalName, std::string Default) const;
-
-  /// \brief Read a named option from the \c Context and parse it as an integral
-  /// type \c T.
-  ///
-  /// Reads the option with the check-local name \p LocalName from the
-  /// \c CheckOptions. If the corresponding key is not present, returns
-  /// \p Default.
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, T>::type
-  get(StringRef LocalName, T Default) const {
-    std::string Value = get(LocalName, "");
-    T Result = Default;
-    if (!Value.empty())
-      StringRef(Value).getAsInteger(10, Result);
-    return Result;
-  }
-
-  /// \brief Stores an option with the check-local name \p LocalName with string
-  /// value \p Value to \p Options.
-  void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
-             StringRef Value) const;
-
-  /// \brief Stores an option with the check-local name \p LocalName with
-  /// \c int64_t value \p Value to \p Options.
-  void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
-             int64_t Value) const;
-
-private:
-  std::string NamePrefix;
-  const ClangTidyOptions::OptionMap &CheckOptions;
-};
-
 /// \brief Base class for all clang-tidy checks.
 ///
 /// To implement a \c ClangTidyCheck, write a subclass and overwrite some of the
@@ -101,18 +49,6 @@ private:
 /// useful/necessary.
 class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
 public:
-  /// \brief Initializes the check with \p CheckName and \p Context.
-  ///
-  /// Derived classes must implement the constructor with this signature or
-  /// delegate it. If a check needs to read options, it can do this in the
-  /// constructor using the Options.get() methods below.
-  ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context)
-      : CheckName(CheckName), Context(Context),
-        Options(CheckName, Context->getOptions().CheckOptions) {
-    assert(Context != nullptr);
-    assert(!CheckName.empty());
-  }
-
   virtual ~ClangTidyCheck() {}
 
   /// \brief Overwrite this to register \c PPCallbacks with \c Compiler.
@@ -139,85 +75,33 @@ public:
   /// work in here.
   virtual void check(const ast_matchers::MatchFinder::MatchResult &Result) {}
 
-  /// \brief Add a diagnostic with the check's name.
-  DiagnosticBuilder diag(SourceLocation Loc, StringRef Description,
-                         DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
-
-  /// \brief Should store all options supported by this check with their
-  /// current values or default values for options that haven't been overridden.
-  ///
-  /// The check should use \c Options.store() to store each option it supports
-  /// whether it has the default value or it has been overridden.
-  virtual void storeOptions(ClangTidyOptions::OptionMap &Options) {}
-
-private:
-  void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  StringRef getID() const override { return CheckName; }
-  std::string CheckName;
-  ClangTidyContext *Context;
+  /// \brief The infrastructure sets the context to \p Ctx with this function.
+  void setContext(ClangTidyContext *Ctx) { Context = Ctx; }
 
 protected:
-  OptionsView Options;
-};
-
-class ClangTidyCheckFactories;
-
-class ClangTidyASTConsumerFactory {
-public:
-  ClangTidyASTConsumerFactory(ClangTidyContext &Context);
-
-  /// \brief Returns an ASTConsumer that runs the specified clang-tidy checks.
-  std::unique_ptr<clang::ASTConsumer>
-  CreateASTConsumer(clang::CompilerInstance &Compiler, StringRef File);
-
-  /// \brief Get the list of enabled checks.
-  std::vector<std::string> getCheckNames();
-
-  /// \brief Get the union of options from all checks.
-  ClangTidyOptions::OptionMap getCheckOptions();
+  ClangTidyContext *Context;
 
 private:
-  typedef std::vector<std::pair<std::string, bool>> CheckersList;
-  CheckersList getCheckersControlList(GlobList &Filter);
-
-  ClangTidyContext &Context;
-  std::unique_ptr<ClangTidyCheckFactories> CheckFactories;
+  virtual void run(const ast_matchers::MatchFinder::MatchResult &Result);
 };
 
-/// \brief Fills the list of check names that are enabled when the provided
-/// filters are applied.
-std::vector<std::string> getCheckNames(const ClangTidyOptions &Options);
-
-/// \brief Returns the effective check-specific options.
-///
-/// The method configures ClangTidy with the specified \p Options and collects
-/// effective options from all created checks. The returned set of options
-/// includes default check-specific options for all keys not overridden by \p
-/// Options.
-ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options);
+/// \brief Returns an action factory that runs the specified clang-tidy checks.
+tooling::FrontendActionFactory *
+createClangTidyActionFactory(StringRef CheckRegexString,
+                             ClangTidyContext &Context);
 
 /// \brief Run a set of clang-tidy checks on a set of files.
-///
-/// \param Profile if provided, it enables check profile collection in
-/// MatchFinder, and will contain the result of the profile.
-ClangTidyStats
-runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
-             const tooling::CompilationDatabase &Compilations,
-             ArrayRef<std::string> InputFiles,
-             std::vector<ClangTidyError> *Errors,
-             ProfileData *Profile = nullptr);
+void runClangTidy(StringRef CheckRegexString,
+                  const tooling::CompilationDatabase &Compilations,
+                  ArrayRef<std::string> Ranges,
+                  SmallVectorImpl<ClangTidyError> *Errors);
 
 // FIXME: This interface will need to be significantly extended to be useful.
 // FIXME: Implement confidence levels for displaying/fixing errors.
 //
 /// \brief Displays the found \p Errors to the users. If \p Fix is true, \p
 /// Errors containing fixes are automatically applied.
-void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix);
-
-/// \brief Serializes replacements into YAML and writes them to the specified
-/// output stream.
-void exportReplacements(const std::vector<ClangTidyError> &Errors,
-                        raw_ostream &OS);
+void handleErrors(SmallVectorImpl<ClangTidyError> &Errors, bool Fix);
 
 } // end namespace tidy
 } // end namespace clang

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

@@ -1,425 +0,0 @@
-//===--- tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp ----------=== //
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-///  \file This file implements ClangTidyDiagnosticConsumer, ClangTidyMessage,
-///  ClangTidyContext and ClangTidyError classes.
-///
-///  This tool uses the Clang Tooling infrastructure, see
-///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
-///  for details on setting it up with LLVM source tree.
-///
-//===----------------------------------------------------------------------===//
-
-#include "ClangTidyDiagnosticConsumer.h"
-#include "ClangTidyOptions.h"
-#include "clang/AST/ASTDiagnostic.h"
-#include "clang/Basic/DiagnosticOptions.h"
-#include "clang/Frontend/DiagnosticRenderer.h"
-#include "llvm/ADT/SmallString.h"
-#include <set>
-#include <tuple>
-using namespace clang;
-using namespace tidy;
-
-namespace {
-class ClangTidyDiagnosticRenderer : public DiagnosticRenderer {
-public:
-  ClangTidyDiagnosticRenderer(const LangOptions &LangOpts,
-                              DiagnosticOptions *DiagOpts,
-                              ClangTidyError &Error)
-      : DiagnosticRenderer(LangOpts, DiagOpts), Error(Error) {}
-
-protected:
-  void emitDiagnosticMessage(SourceLocation Loc, PresumedLoc PLoc,
-                             DiagnosticsEngine::Level Level, StringRef Message,
-                             ArrayRef<CharSourceRange> Ranges,
-                             const SourceManager *SM,
-                             DiagOrStoredDiag Info) override {
-    // Remove check name from the message.
-    // FIXME: Remove this once there's a better way to pass check names than
-    // appending the check name to the message in ClangTidyContext::diag and
-    // using getCustomDiagID.
-    std::string CheckNameInMessage = " [" + Error.CheckName + "]";
-    if (Message.endswith(CheckNameInMessage))
-      Message = Message.substr(0, Message.size() - CheckNameInMessage.size());
-
-    ClangTidyMessage TidyMessage = Loc.isValid()
-                                       ? ClangTidyMessage(Message, *SM, Loc)
-                                       : ClangTidyMessage(Message);
-    if (Level == DiagnosticsEngine::Note) {
-      Error.Notes.push_back(TidyMessage);
-      return;
-    }
-    assert(Error.Message.Message.empty() &&
-           "Overwriting a diagnostic message");
-    Error.Message = TidyMessage;
-  }
-
-  void emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc,
-                         DiagnosticsEngine::Level Level,
-                         ArrayRef<CharSourceRange> Ranges,
-                         const SourceManager &SM) override {}
-
-  void emitCodeContext(SourceLocation Loc, DiagnosticsEngine::Level Level,
-                       SmallVectorImpl<CharSourceRange> &Ranges,
-                       ArrayRef<FixItHint> Hints,
-                       const SourceManager &SM) override {
-    assert(Loc.isValid());
-    for (const auto &FixIt : Hints) {
-      CharSourceRange Range = FixIt.RemoveRange;
-      assert(Range.getBegin().isValid() && Range.getEnd().isValid() &&
-             "Invalid range in the fix-it hint.");
-      assert(Range.getBegin().isFileID() && Range.getEnd().isFileID() &&
-             "Only file locations supported in fix-it hints.");
-
-      Error.Fix.insert(tooling::Replacement(SM, Range, FixIt.CodeToInsert));
-    }
-  }
-
-  void emitIncludeLocation(SourceLocation Loc, PresumedLoc PLoc,
-                           const SourceManager &SM) override {}
-
-  void emitImportLocation(SourceLocation Loc, PresumedLoc PLoc,
-                          StringRef ModuleName,
-                          const SourceManager &SM) override {}
-
-  void emitBuildingModuleLocation(SourceLocation Loc, PresumedLoc PLoc,
-                                  StringRef ModuleName,
-                                  const SourceManager &SM) override {}
-
-  void endDiagnostic(DiagOrStoredDiag D,
-                     DiagnosticsEngine::Level Level) override {
-    assert(!Error.Message.Message.empty() && "Message has not been set");
-  }
-
-private:
-  ClangTidyError &Error;
-};
-} // end anonymous namespace
-
-ClangTidyMessage::ClangTidyMessage(StringRef Message)
-    : Message(Message), FileOffset(0) {}
-
-ClangTidyMessage::ClangTidyMessage(StringRef Message,
-                                   const SourceManager &Sources,
-                                   SourceLocation Loc)
-    : Message(Message) {
-  assert(Loc.isValid() && Loc.isFileID());
-  FilePath = Sources.getFilename(Loc);
-  FileOffset = Sources.getFileOffset(Loc);
-}
-
-ClangTidyError::ClangTidyError(StringRef CheckName,
-                               ClangTidyError::Level DiagLevel)
-    : CheckName(CheckName), DiagLevel(DiagLevel) {}
-
-// Returns true if GlobList starts with the negative indicator ('-'), removes it
-// from the GlobList.
-static bool ConsumeNegativeIndicator(StringRef &GlobList) {
-  if (GlobList.startswith("-")) {
-    GlobList = GlobList.substr(1);
-    return true;
-  }
-  return false;
-}
-// Converts first glob from the comma-separated list of globs to Regex and
-// removes it and the trailing comma from the GlobList.
-static llvm::Regex ConsumeGlob(StringRef &GlobList) {
-  StringRef Glob = GlobList.substr(0, GlobList.find(','));
-  GlobList = GlobList.substr(Glob.size() + 1);
-  llvm::SmallString<128> RegexText("^");
-  StringRef MetaChars("()^$|*+?.[]\\{}");
-  for (char C : Glob) {
-    if (C == '*')
-      RegexText.push_back('.');
-    else if (MetaChars.find(C) != StringRef::npos)
-      RegexText.push_back('\\');
-    RegexText.push_back(C);
-  }
-  RegexText.push_back('$');
-  return llvm::Regex(RegexText);
-}
-
-GlobList::GlobList(StringRef Globs)
-    : Positive(!ConsumeNegativeIndicator(Globs)),
-      Regex(ConsumeGlob(Globs)),
-      NextGlob(Globs.empty() ? nullptr : new GlobList(Globs)) {}
-
-bool GlobList::contains(StringRef S, bool Contains) {
-  if (Regex.match(S))
-    Contains = Positive;
-
-  if (NextGlob)
-    Contains = NextGlob->contains(S, Contains);
-  return Contains;
-}
-
-ClangTidyContext::ClangTidyContext(
-    std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider)
-    : DiagEngine(nullptr), OptionsProvider(std::move(OptionsProvider)),
-      Profile(nullptr) {
-  // Before the first translation unit we can get errors related to command-line
-  // parsing, use empty string for the file name in this case.
-  setCurrentFile("");
-}
-
-DiagnosticBuilder ClangTidyContext::diag(
-    StringRef CheckName, SourceLocation Loc, StringRef Description,
-    DiagnosticIDs::Level Level /* = DiagnosticIDs::Warning*/) {
-  assert(Loc.isValid());
-  bool Invalid;
-  const char *CharacterData =
-      DiagEngine->getSourceManager().getCharacterData(Loc, &Invalid);
-  if (!Invalid) {
-    const char *P = CharacterData;
-    while (*P != '\0' && *P != '\r' && *P != '\n')
-      ++P;
-    StringRef RestOfLine(CharacterData, P - CharacterData + 1);
-    // FIXME: Handle /\bNOLINT\b(\([^)]*\))?/ as cpplint.py does.
-    if (RestOfLine.find("NOLINT") != StringRef::npos) {
-      Level = DiagnosticIDs::Ignored;
-      ++Stats.ErrorsIgnoredNOLINT;
-    }
-  }
-  unsigned ID = DiagEngine->getDiagnosticIDs()->getCustomDiagID(
-      Level, (Description + " [" + CheckName + "]").str());
-  if (CheckNamesByDiagnosticID.count(ID) == 0)
-    CheckNamesByDiagnosticID.insert(std::make_pair(ID, CheckName.str()));
-  return DiagEngine->Report(Loc, ID);
-}
-
-void ClangTidyContext::setDiagnosticsEngine(DiagnosticsEngine *Engine) {
-  DiagEngine = Engine;
-}
-
-void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
-  DiagEngine->setSourceManager(SourceMgr);
-}
-
-void ClangTidyContext::setCurrentFile(StringRef File) {
-  CurrentFile = File;
-  // Safeguard against options with unset values.
-  CurrentOptions = ClangTidyOptions::getDefaults().mergeWith(
-      OptionsProvider->getOptions(CurrentFile));
-  CheckFilter.reset(new GlobList(*getOptions().Checks));
-}
-
-void ClangTidyContext::setASTContext(ASTContext *Context) {
-  DiagEngine->SetArgToStringFn(&FormatASTNodeDiagnosticArgument, Context);
-}
-
-const ClangTidyGlobalOptions &ClangTidyContext::getGlobalOptions() const {
-  return OptionsProvider->getGlobalOptions();
-}
-
-const ClangTidyOptions &ClangTidyContext::getOptions() const {
-  return CurrentOptions;
-}
-
-void ClangTidyContext::setCheckProfileData(ProfileData *P) {
-  Profile = P;
-}
-
-GlobList &ClangTidyContext::getChecksFilter() {
-  assert(CheckFilter != nullptr);
-  return *CheckFilter;
-}
-
-/// \brief Store a \c ClangTidyError.
-void ClangTidyContext::storeError(const ClangTidyError &Error) {
-  Errors.push_back(Error);
-}
-
-StringRef ClangTidyContext::getCheckName(unsigned DiagnosticID) const {
-  llvm::DenseMap<unsigned, std::string>::const_iterator I =
-      CheckNamesByDiagnosticID.find(DiagnosticID);
-  if (I != CheckNamesByDiagnosticID.end())
-    return I->second;
-  return "";
-}
-
-ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx)
-    : Context(Ctx), LastErrorRelatesToUserCode(false),
-      LastErrorPassesLineFilter(false) {
-  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-  Diags.reset(new DiagnosticsEngine(
-      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
-      /*ShouldOwnClient=*/false));
-  Context.setDiagnosticsEngine(Diags.get());
-}
-
-void ClangTidyDiagnosticConsumer::finalizeLastError() {
-  if (!Errors.empty()) {
-    ClangTidyError &Error = Errors.back();
-    if (!Context.getChecksFilter().contains(Error.CheckName) &&
-        Error.DiagLevel != ClangTidyError::Error) {
-      ++Context.Stats.ErrorsIgnoredCheckFilter;
-      Errors.pop_back();
-    } else if (!LastErrorRelatesToUserCode) {
-      ++Context.Stats.ErrorsIgnoredNonUserCode;
-      Errors.pop_back();
-    } else if (!LastErrorPassesLineFilter) {
-      ++Context.Stats.ErrorsIgnoredLineFilter;
-      Errors.pop_back();
-    } else {
-      ++Context.Stats.ErrorsDisplayed;
-    }
-  }
-  LastErrorRelatesToUserCode = false;
-  LastErrorPassesLineFilter = false;
-}
-
-void ClangTidyDiagnosticConsumer::HandleDiagnostic(
-    DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
-  // Count warnings/errors.
-  DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
-
-  if (DiagLevel == DiagnosticsEngine::Note) {
-    assert(!Errors.empty() &&
-           "A diagnostic note can only be appended to a message.");
-  } else {
-    finalizeLastError();
-    StringRef WarningOption =
-        Context.DiagEngine->getDiagnosticIDs()->getWarningOptionForDiag(
-            Info.getID());
-    std::string CheckName = !WarningOption.empty()
-                                ? ("clang-diagnostic-" + WarningOption).str()
-                                : Context.getCheckName(Info.getID()).str();
-
-    if (CheckName.empty()) {
-      // This is a compiler diagnostic without a warning option. Assign check
-      // name based on its level.
-      switch (DiagLevel) {
-        case DiagnosticsEngine::Error:
-        case DiagnosticsEngine::Fatal:
-          CheckName = "clang-diagnostic-error";
-          break;
-        case DiagnosticsEngine::Warning:
-          CheckName = "clang-diagnostic-warning";
-          break;
-        default:
-          CheckName = "clang-diagnostic-unknown";
-          break;
-      }
-    }
-
-    ClangTidyError::Level Level = ClangTidyError::Warning;
-    if (DiagLevel == DiagnosticsEngine::Error ||
-        DiagLevel == DiagnosticsEngine::Fatal) {
-      // Force reporting of Clang errors regardless of filters and non-user
-      // code.
-      Level = ClangTidyError::Error;
-      LastErrorRelatesToUserCode = true;
-      LastErrorPassesLineFilter = true;
-    }
-    Errors.push_back(ClangTidyError(CheckName, Level));
-  }
-
-  // FIXME: Provide correct LangOptions for each file.
-  LangOptions LangOpts;
-  ClangTidyDiagnosticRenderer Converter(
-      LangOpts, &Context.DiagEngine->getDiagnosticOptions(), Errors.back());
-  SmallString<100> Message;
-  Info.FormatDiagnostic(Message);
-  SourceManager *Sources = nullptr;
-  if (Info.hasSourceManager())
-    Sources = &Info.getSourceManager();
-  Converter.emitDiagnostic(Info.getLocation(), DiagLevel, Message,
-                           Info.getRanges(), Info.getFixItHints(), Sources);
-
-  checkFilters(Info.getLocation());
-}
-
-void ClangTidyDiagnosticConsumer::BeginSourceFile(const LangOptions &LangOpts,
-                                                  const Preprocessor *PP) {
-  // Before the first translation unit we don't need HeaderFilter, as we
-  // shouldn't get valid source locations in diagnostics.
-  HeaderFilter.reset(new llvm::Regex(*Context.getOptions().HeaderFilterRegex));
-}
-
-bool ClangTidyDiagnosticConsumer::passesLineFilter(StringRef FileName,
-                                                   unsigned LineNumber) const {
-  if (Context.getGlobalOptions().LineFilter.empty())
-    return true;
-  for (const FileFilter& Filter : Context.getGlobalOptions().LineFilter) {
-    if (FileName.endswith(Filter.Name)) {
-      if (Filter.LineRanges.empty())
-        return true;
-      for (const FileFilter::LineRange &Range : Filter.LineRanges) {
-        if (Range.first <= LineNumber && LineNumber <= Range.second)
-          return true;
-      }
-      return false;
-    }
-  }
-  return false;
-}
-
-void ClangTidyDiagnosticConsumer::checkFilters(SourceLocation Location) {
-  // Invalid location may mean a diagnostic in a command line, don't skip these.
-  if (!Location.isValid()) {
-    LastErrorRelatesToUserCode = true;
-    LastErrorPassesLineFilter = true;
-    return;
-  }
-
-  const SourceManager &Sources = Diags->getSourceManager();
-  if (!*Context.getOptions().SystemHeaders &&
-      Sources.isInSystemHeader(Location))
-    return;
-
-  // FIXME: We start with a conservative approach here, but the actual type of
-  // location needed depends on the check (in particular, where this check wants
-  // to apply fixes).
-  FileID FID = Sources.getDecomposedExpansionLoc(Location).first;
-  const FileEntry *File = Sources.getFileEntryForID(FID);
-
-  // -DMACRO definitions on the command line have locations in a virtual buffer
-  // that doesn't have a FileEntry. Don't skip these as well.
-  if (!File) {
-    LastErrorRelatesToUserCode = true;
-    LastErrorPassesLineFilter = true;
-    return;
-  }
-
-  StringRef FileName(File->getName());
-  assert(LastErrorRelatesToUserCode || Sources.isInMainFile(Location) ||
-         HeaderFilter != nullptr);
-  LastErrorRelatesToUserCode = LastErrorRelatesToUserCode ||
-                               Sources.isInMainFile(Location) ||
-                               HeaderFilter->match(FileName);
-
-  unsigned LineNumber = Sources.getExpansionLineNumber(Location);
-  LastErrorPassesLineFilter =
-      LastErrorPassesLineFilter || passesLineFilter(FileName, LineNumber);
-}
-
-namespace {
-struct LessClangTidyError {
-  bool operator()(const ClangTidyError *LHS, const ClangTidyError *RHS) const {
-    const ClangTidyMessage &M1 = LHS->Message;
-    const ClangTidyMessage &M2 = RHS->Message;
-
-    return std::tie(M1.FilePath, M1.FileOffset, M1.Message) <
-           std::tie(M2.FilePath, M2.FileOffset, M2.Message);
-  }
-};
-} // end anonymous namespace
-
-// Flushes the internal diagnostics buffer to the ClangTidyContext.
-void ClangTidyDiagnosticConsumer::finish() {
-  finalizeLastError();
-  std::set<const ClangTidyError*, LessClangTidyError> UniqueErrors;
-  for (const ClangTidyError &Error : Errors)
-    UniqueErrors.insert(&Error);
-
-  for (const ClangTidyError *Error : UniqueErrors)
-    Context.storeError(*Error);
-  Errors.clear();
-}

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

@@ -10,18 +10,13 @@
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_DIAGNOSTIC_CONSUMER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_DIAGNOSTIC_CONSUMER_H
 
-#include "ClangTidyOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Refactoring.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/Support/Regex.h"
-#include "llvm/Support/Timer.h"
+#include "llvm/ADT/SmallString.h"
 
 namespace clang {
 
-class ASTContext;
 class CompilerInstance;
 namespace ast_matchers {
 class MatchFinder;
@@ -52,67 +47,14 @@ struct ClangTidyMessage {
 ///
 /// FIXME: Make Diagnostics flexible enough to support this directly.
 struct ClangTidyError {
-  enum Level {
-    Warning = DiagnosticsEngine::Warning,
-    Error = DiagnosticsEngine::Error
-  };
+  ClangTidyError(const ClangTidyMessage &Message);
 
-  ClangTidyError(StringRef CheckName, Level DiagLevel);
-
-  std::string CheckName;
   ClangTidyMessage Message;
   tooling::Replacements Fix;
   SmallVector<ClangTidyMessage, 1> Notes;
-
-  Level DiagLevel;
 };
 
-/// \brief Read-only set of strings represented as a list of positive and
-/// negative globs. Positive globs add all matched strings to the set, negative
-/// globs remove them in the order of appearance in the list.
-class GlobList {
-public:
-  /// \brief \p GlobList is a comma-separated list of globs (only '*'
-  /// metacharacter is supported) with optional '-' prefix to denote exclusion.
-  GlobList(StringRef Globs);
-
-  /// \brief Returns \c true if the pattern matches \p S. The result is the last
-  /// matching glob's Positive flag.
-  bool contains(StringRef S) { return contains(S, false); }
-
-private:
-  bool contains(StringRef S, bool Contains);
-
-  bool Positive;
-  llvm::Regex Regex;
-  std::unique_ptr<GlobList> NextGlob;
-};
-
-/// \brief Contains displayed and ignored diagnostic counters for a ClangTidy
-/// run.
-struct ClangTidyStats {
-  ClangTidyStats()
-      : ErrorsDisplayed(0), ErrorsIgnoredCheckFilter(0), ErrorsIgnoredNOLINT(0),
-        ErrorsIgnoredNonUserCode(0), ErrorsIgnoredLineFilter(0) {}
-
-  unsigned ErrorsDisplayed;
-  unsigned ErrorsIgnoredCheckFilter;
-  unsigned ErrorsIgnoredNOLINT;
-  unsigned ErrorsIgnoredNonUserCode;
-  unsigned ErrorsIgnoredLineFilter;
-
-  unsigned errorsIgnored() const {
-    return ErrorsIgnoredNOLINT + ErrorsIgnoredCheckFilter +
-           ErrorsIgnoredNonUserCode + ErrorsIgnoredLineFilter;
-  }
-};
-
-/// \brief Container for clang-tidy profiling data.
-struct ProfileData {
-  llvm::StringMap<llvm::TimeRecord> Records;
-};
-
-/// \brief Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
+/// \brief Every \c ClangTidyCheck reports errors through a \c DiagnosticEngine
 /// provided by this context.
 ///
 /// A \c ClangTidyCheck always has access to the active context to report
@@ -123,83 +65,34 @@ struct ProfileData {
 /// \endcode
 class ClangTidyContext {
 public:
-  /// \brief Initializes \c ClangTidyContext instance.
-  ClangTidyContext(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider);
+  ClangTidyContext(SmallVectorImpl<ClangTidyError> *Errors) : Errors(Errors) {}
 
   /// \brief Report any errors detected using this method.
   ///
   /// This is still under heavy development and will likely change towards using
   /// tablegen'd diagnostic IDs.
   /// FIXME: Figure out a way to manage ID spaces.
-  DiagnosticBuilder diag(StringRef CheckName, SourceLocation Loc,
-                         StringRef Message,
-                         DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
+  DiagnosticBuilder Diag(SourceLocation Loc, StringRef Message);
+
+  /// \brief Sets the \c DiagnosticsEngine so that Diagnostics can be generated
+  /// correctly.
+  ///
+  /// This is called from the \c ClangTidyCheck base class.
+  void setDiagnosticsEngine(DiagnosticsEngine *Engine);
 
   /// \brief Sets the \c SourceManager of the used \c DiagnosticsEngine.
   ///
   /// This is called from the \c ClangTidyCheck base class.
   void setSourceManager(SourceManager *SourceMgr);
 
-  /// \brief Should be called when starting to process new translation unit.
-  void setCurrentFile(StringRef File);
-
-  /// \brief Sets ASTContext for the current translation unit.
-  void setASTContext(ASTContext *Context);
-
-  /// \brief Returns the name of the clang-tidy check which produced this
-  /// diagnostic ID.
-  StringRef getCheckName(unsigned DiagnosticID) const;
-
-  /// \brief Returns check filter for the \c CurrentFile.
-  GlobList &getChecksFilter();
-
-  /// \brief Returns global options.
-  const ClangTidyGlobalOptions &getGlobalOptions() const;
-
-  /// \brief Returns options for \c CurrentFile.
-  const ClangTidyOptions &getOptions() const;
-
-  /// \brief Returns \c ClangTidyStats containing issued and ignored diagnostic
-  /// counters.
-  const ClangTidyStats &getStats() const { return Stats; }
-
-  /// \brief Returns all collected errors.
-  const std::vector<ClangTidyError> &getErrors() const { return Errors; }
-
-  /// \brief Clears collected errors.
-  void clearErrors() { Errors.clear(); }
-
-  /// \brief Set the output struct for profile data.
-  ///
-  /// Setting a non-null pointer here will enable profile collection in
-  /// clang-tidy.
-  void setCheckProfileData(ProfileData* Profile);
-  ProfileData* getCheckProfileData() const { return Profile; }
-
 private:
-  // Calls setDiagnosticsEngine() and storeError().
-  friend class ClangTidyDiagnosticConsumer;
+  friend class ClangTidyDiagnosticConsumer; // Calls storeError().
 
-  /// \brief Sets the \c DiagnosticsEngine so that Diagnostics can be generated
-  /// correctly.
-  void setDiagnosticsEngine(DiagnosticsEngine *Engine);
-
-  /// \brief Store an \p Error.
+  /// \brief Store a \c ClangTidyError.
   void storeError(const ClangTidyError &Error);
 
-  std::vector<ClangTidyError> Errors;
+  SmallVectorImpl<ClangTidyError> *Errors;
   DiagnosticsEngine *DiagEngine;
-  std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
-
-  std::string CurrentFile;
-  ClangTidyOptions CurrentOptions;
-  std::unique_ptr<GlobList> CheckFilter;
-
-  ClangTidyStats Stats;
-
-  llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
-
-  ProfileData *Profile;
 };
 
 /// \brief A diagnostic consumer that turns each \c Diagnostic into a
@@ -209,35 +102,59 @@ private:
 // implementation file.
 class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {
 public:
-  ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx);
+  ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx) : Context(Ctx) {
+    IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+    Diags.reset(new DiagnosticsEngine(
+        IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
+        /*ShouldOwnClient=*/false));
+    Context.setDiagnosticsEngine(Diags.get());
+  }
 
   // FIXME: The concept of converting between FixItHints and Replacements is
   // more generic and should be pulled out into a more useful Diagnostics
   // library.
-  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
-                        const Diagnostic &Info) override;
+  virtual void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
+                                const Diagnostic &Info) {
+    if (DiagLevel != DiagnosticsEngine::Note) {
+      Errors.push_back(ClangTidyError(getMessage(Info)));
+    } else {
+      Errors.back().Notes.push_back(getMessage(Info));
+    }
+    addFixes(Info, Errors.back());
+  }
 
-  /// \brief Sets \c HeaderFilter to the value configured for this file.
-  void BeginSourceFile(const LangOptions &LangOpts,
-                       const Preprocessor *PP) override;
-
-  /// \brief Flushes the internal diagnostics buffer to the ClangTidyContext.
-  void finish() override;
+  virtual void finish() {
+    for (unsigned i = 0, e = Errors.size(); i != e; ++i) {
+      Context.storeError(Errors[i]);
+    }
+  }
 
 private:
-  void finalizeLastError();
+  void addFixes(const Diagnostic &Info, ClangTidyError &Error) {
+    if (!Info.hasSourceManager())
+      return;
+    SourceManager &SourceMgr = Info.getSourceManager();
+    tooling::Replacements Replacements;
+    for (unsigned i = 0, e = Info.getNumFixItHints(); i != e; ++i) {
+      Error.Fix.insert(tooling::Replacement(
+          SourceMgr, Info.getFixItHint(i).RemoveRange.getBegin(), 0,
+          Info.getFixItHint(i).CodeToInsert));
+    }
+  }
 
-  /// \brief Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
-  /// according to the diagnostic \p Location.
-  void checkFilters(SourceLocation Location);
-  bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
+  ClangTidyMessage getMessage(const Diagnostic &Info) const {
+    SmallString<100> Buf;
+    Info.FormatDiagnostic(Buf);
+    if (!Info.hasSourceManager()) {
+      return ClangTidyMessage(Buf.str());
+    }
+    return ClangTidyMessage(Buf.str(), Info.getSourceManager(),
+                            Info.getLocation());
+  }
 
   ClangTidyContext &Context;
-  std::unique_ptr<DiagnosticsEngine> Diags;
+  OwningPtr<DiagnosticsEngine> Diags;
   SmallVector<ClangTidyError, 8> Errors;
-  std::unique_ptr<llvm::Regex> HeaderFilter;
-  bool LastErrorRelatesToUserCode;
-  bool LastErrorPassesLineFilter;
 };
 
 } // end namespace tidy

clang-tools-extra/clang-tidy/ClangTidyModule.cpp

@@ -12,28 +12,38 @@
 //===----------------------------------------------------------------------===//
 
 #include "ClangTidyModule.h"
+#include "llvm/Support/Regex.h"
 
 namespace clang {
 namespace tidy {
 
-void ClangTidyCheckFactories::registerCheckFactory(StringRef Name,
-                                                   CheckFactory Factory) {
+CheckFactoryBase::~CheckFactoryBase() {}
+
+ClangTidyCheckFactories::~ClangTidyCheckFactories() {
+  for (std::map<std::string, CheckFactoryBase *>::iterator
+           I = Factories.begin(),
+           E = Factories.end();
+       I != E; ++I) {
+    delete I->second;
+  }
+}
+void ClangTidyCheckFactories::addCheckFactory(StringRef Name,
+                                              CheckFactoryBase *Factory) {
+
   Factories[Name] = Factory;
 }
 
 void ClangTidyCheckFactories::createChecks(
-    ClangTidyContext *Context,
-    std::vector<std::unique_ptr<ClangTidyCheck>> &Checks) {
-  GlobList &Filter = Context->getChecksFilter();
-  for (const auto &Factory : Factories) {
-    if (Filter.contains(Factory.first))
-      Checks.emplace_back(Factory.second(Factory.first, Context));
+    StringRef CheckRegexString, SmallVectorImpl<ClangTidyCheck *> &Checks) {
+  llvm::Regex CheckRegex(CheckRegexString);
+  for (std::map<std::string, CheckFactoryBase *>::iterator
+           I = Factories.begin(),
+           E = Factories.end();
+       I != E; ++I) {
+    if (CheckRegex.match(I->first))
+      Checks.push_back(I->second->createCheck());
   }
 }
 
-ClangTidyOptions ClangTidyModule::getModuleOptions() {
-  return ClangTidyOptions();
-}
-
 } // namespace tidy
 } // namespace clang

clang-tools-extra/clang-tidy/ClangTidyModule.h

@@ -11,73 +11,50 @@
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_MODULE_H
 
 #include "ClangTidy.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include <functional>
-#include <map>
-#include <string>
 #include <utility>
 
 namespace clang {
 namespace tidy {
 
-/// \brief A collection of \c ClangTidyCheckFactory instances.
+/// \brief A factory, that can instantiate a specific clang-tidy check for
+/// processing a translation unit.
 ///
-/// All clang-tidy modules register their check factories with an instance of
-/// this object.
-class ClangTidyCheckFactories {
+/// In order to register your check with the \c ClangTidyModule, create a
+/// subclass of \c CheckFactoryBase and implement \c createCheck(). Then, use
+/// this subclass in \c ClangTidyModule::addCheckFactories().
+class CheckFactoryBase {
 public:
-  typedef std::function<ClangTidyCheck *(
-      StringRef Name, ClangTidyContext *Context)> CheckFactory;
-
-  /// \brief Registers check \p Factory with name \p Name.
-  ///
-  /// For all checks that have default constructors, use \c registerCheck.
-  void registerCheckFactory(StringRef Name, CheckFactory Factory);
-
-  /// \brief Registers the \c CheckType with the name \p Name.
-  ///
-  /// This method should be used for all \c ClangTidyChecks that don't require
-  /// constructor parameters.
-  ///
-  /// For example, if have a clang-tidy check like:
-  /// \code
-  /// class MyTidyCheck : public ClangTidyCheck {
-  ///   void registerMatchers(ast_matchers::MatchFinder *Finder) override {
-  ///     ..
-  ///   }
-  /// };
-  /// \endcode
-  /// you can register it with:
-  /// \code
-  /// class MyModule : public ClangTidyModule {
-  ///   void addCheckFactories(ClangTidyCheckFactories &Factories) override {
-  ///     Factories.registerCheck<MyTidyCheck>("myproject-my-check");
-  ///   }
-  /// };
-  /// \endcode
-  template <typename CheckType> void registerCheck(StringRef CheckName) {
-    registerCheckFactory(CheckName,
-                         [](StringRef Name, ClangTidyContext *Context) {
-      return new CheckType(Name, Context);
-    });
-  }
-
-  /// \brief Create instances of all checks matching \p CheckRegexString and
-  /// store them in \p Checks.
-  ///
-  /// The caller takes ownership of the return \c ClangTidyChecks.
-  void createChecks(ClangTidyContext *Context,
-                    std::vector<std::unique_ptr<ClangTidyCheck>> &Checks);
-
-  typedef std::map<std::string, CheckFactory> FactoryMap;
-  FactoryMap::const_iterator begin() const { return Factories.begin(); }
-  FactoryMap::const_iterator end() const { return Factories.end(); }
-  bool empty() const { return Factories.empty(); }
-
-private:
-  FactoryMap Factories;
+  virtual ~CheckFactoryBase();
+  virtual ClangTidyCheck *createCheck() = 0;
 };
 
+/// \brief A subclass of \c CheckFactoryBase that should be used for all
+/// \c ClangTidyChecks that don't require constructor parameters.
+///
+/// For example, if have a clang-tidy check like:
+/// \code
+/// class MyTidyCheck : public ClangTidyCheck {
+///   virtual void registerMatchers(ast_matchers::MatchFinder *Finder) { .. }
+/// };
+/// \endcode
+/// you can register it with:
+/// \code
+/// class MyModule : public ClangTidyModule {
+///   virtual void addCheckFactories(ClangTidyCheckFactories &CheckFactories) {
+///     CheckFactories.addCheckFactory(
+///         "myproject-my-check", new ClangTidyCheckFactory<MyTidyCheck>());
+///   }
+/// };
+/// \endcode
+template <typename T> class ClangTidyCheckFactory : public CheckFactoryBase {
+public:
+  virtual ClangTidyCheck *createCheck() { return new T; }
+};
+
+class ClangTidyCheckFactories;
+
 /// \brief A clang-tidy module groups a number of \c ClangTidyChecks and gives
 /// them a prefixed name.
 class ClangTidyModule {
@@ -87,9 +64,32 @@ public:
   /// \brief Implement this function in order to register all \c CheckFactories
   /// belonging to this module.
   virtual void addCheckFactories(ClangTidyCheckFactories &CheckFactories) = 0;
+};
 
-  /// \brief Gets default options for checks defined in this module.
-  virtual ClangTidyOptions getModuleOptions();
+/// \brief A collection of \c ClangTidyCheckFactory instances.
+///
+/// All clang-tidy modules register their check factories with an instance of
+/// this object.
+class ClangTidyCheckFactories {
+public:
+  ClangTidyCheckFactories() {}
+  ~ClangTidyCheckFactories();
+
+  /// \brief Register \p Factory with the name \p Name.
+  ///
+  /// The \c ClangTidyCheckFactories object takes ownership of the \p Factory.
+  void addCheckFactory(StringRef Name, CheckFactoryBase *Factory);
+
+  /// \brief Create instances of all checks matching \p CheckRegexString and
+  /// store them in \p Checks.
+  ///
+  /// The caller takes ownership of the return \c ClangTidyChecks.
+  void createChecks(StringRef CheckRegexString,
+                    SmallVectorImpl<ClangTidyCheck *> &Checks);
+
+private:
+  StringRef FilterRegex;
+  std::map<std::string, CheckFactoryBase *> Factories;
 };
 
 } // end namespace tidy

clang-tools-extra/clang-tidy/ClangTidyModuleRegistry.h

@@ -13,8 +13,6 @@
 #include "ClangTidyModule.h"
 #include "llvm/Support/Registry.h"
 
-extern template class llvm::Registry<clang::tidy::ClangTidyModule>;
-
 namespace clang {
 namespace tidy {
 

clang-tools-extra/clang-tidy/ClangTidyOptions.cpp

@@ -1,281 +0,0 @@
-//===--- ClangTidyOptions.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 "ClangTidyOptions.h"
-#include "ClangTidyModuleRegistry.h"
-#include "clang/Basic/LLVM.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/Errc.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/YAMLTraits.h"
-#include "llvm/Support/raw_ostream.h"
-#include <utility>
-
-#define DEBUG_TYPE "clang-tidy-options"
-
-using clang::tidy::ClangTidyOptions;
-using clang::tidy::FileFilter;
-
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
-LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
-LLVM_YAML_IS_SEQUENCE_VECTOR(ClangTidyOptions::StringPair)
-
-namespace llvm {
-namespace yaml {
-
-// Map std::pair<int, int> to a JSON array of size 2.
-template <> struct SequenceTraits<FileFilter::LineRange> {
-  static size_t size(IO &IO, FileFilter::LineRange &Range) {
-    return Range.first == 0 ? 0 : Range.second == 0 ? 1 : 2;
-  }
-  static unsigned &element(IO &IO, FileFilter::LineRange &Range, size_t Index) {
-    if (Index > 1)
-      IO.setError("Too many elements in line range.");
-    return Index == 0 ? Range.first : Range.second;
-  }
-};
-
-template <> struct MappingTraits<FileFilter> {
-  static void mapping(IO &IO, FileFilter &File) {
-    IO.mapRequired("name", File.Name);
-    IO.mapOptional("lines", File.LineRanges);
-  }
-  static StringRef validate(IO &io, FileFilter &File) {
-    if (File.Name.empty())
-      return "No file name specified";
-    for (const FileFilter::LineRange &Range : File.LineRanges) {
-      if (Range.first <= 0 || Range.second <= 0)
-        return "Invalid line range";
-    }
-    return StringRef();
-  }
-};
-
-template <> struct MappingTraits<ClangTidyOptions::StringPair> {
-  static void mapping(IO &IO, ClangTidyOptions::StringPair &KeyValue) {
-    IO.mapRequired("key", KeyValue.first);
-    IO.mapRequired("value", KeyValue.second);
-  }
-};
-
-struct NOptionMap {
-  NOptionMap(IO &) {}
-  NOptionMap(IO &, const ClangTidyOptions::OptionMap &OptionMap)
-      : Options(OptionMap.begin(), OptionMap.end()) {}
-  ClangTidyOptions::OptionMap denormalize(IO &) {
-    ClangTidyOptions::OptionMap Map;
-    for (const auto &KeyValue : Options)
-      Map[KeyValue.first] = KeyValue.second;
-    return Map;
-  }
-  std::vector<ClangTidyOptions::StringPair> Options;
-};
-
-template <> struct MappingTraits<ClangTidyOptions> {
-  static void mapping(IO &IO, ClangTidyOptions &Options) {
-    MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
-        IO, Options.CheckOptions);
-    IO.mapOptional("Checks", Options.Checks);
-    IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
-    IO.mapOptional("AnalyzeTemporaryDtors", Options.AnalyzeTemporaryDtors);
-    IO.mapOptional("User", Options.User);
-    IO.mapOptional("CheckOptions", NOpts->Options);
-  }
-};
-
-} // namespace yaml
-} // namespace llvm
-
-namespace clang {
-namespace tidy {
-
-ClangTidyOptions ClangTidyOptions::getDefaults() {
-  ClangTidyOptions Options;
-  Options.Checks = "";
-  Options.HeaderFilterRegex = "";
-  Options.SystemHeaders = false;
-  Options.AnalyzeTemporaryDtors = false;
-  Options.User = llvm::None;
-  for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
-                                         E = ClangTidyModuleRegistry::end();
-       I != E; ++I)
-    Options = Options.mergeWith(I->instantiate()->getModuleOptions());
-  return Options;
-}
-
-ClangTidyOptions
-ClangTidyOptions::mergeWith(const ClangTidyOptions &Other) const {
-  ClangTidyOptions Result = *this;
-
-  // Merge comma-separated glob lists by appending the new value after a comma.
-  if (Other.Checks)
-    Result.Checks =
-        (Result.Checks && !Result.Checks->empty() ? *Result.Checks + "," : "") +
-        *Other.Checks;
-
-  if (Other.HeaderFilterRegex)
-    Result.HeaderFilterRegex = Other.HeaderFilterRegex;
-  if (Other.SystemHeaders)
-    Result.SystemHeaders = Other.SystemHeaders;
-  if (Other.AnalyzeTemporaryDtors)
-    Result.AnalyzeTemporaryDtors = Other.AnalyzeTemporaryDtors;
-  if (Other.User)
-    Result.User = Other.User;
-
-  for (const auto &KeyValue : Other.CheckOptions)
-    Result.CheckOptions[KeyValue.first] = KeyValue.second;
-
-  return Result;
-}
-
-FileOptionsProvider::FileOptionsProvider(
-    const ClangTidyGlobalOptions &GlobalOptions,
-    const ClangTidyOptions &DefaultOptions,
-    const ClangTidyOptions &OverrideOptions)
-    : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
-      OverrideOptions(OverrideOptions) {
-  ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
-  CachedOptions[""] = DefaultOptions.mergeWith(OverrideOptions);
-}
-
-FileOptionsProvider::FileOptionsProvider(
-    const ClangTidyGlobalOptions &GlobalOptions,
-    const ClangTidyOptions &DefaultOptions,
-    const ClangTidyOptions &OverrideOptions,
-    const FileOptionsProvider::ConfigFileHandlers &ConfigHandlers)
-    : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
-      OverrideOptions(OverrideOptions), ConfigHandlers(ConfigHandlers) {
-  CachedOptions[""] = DefaultOptions.mergeWith(OverrideOptions);
-}
-
-// FIXME: This method has some common logic with clang::format::getStyle().
-// Consider pulling out common bits to a findParentFileWithName function or
-// similar.
-const ClangTidyOptions &FileOptionsProvider::getOptions(StringRef FileName) {
-  DEBUG(llvm::dbgs() << "Getting options for file " << FileName << "...\n");
-  SmallString<256> FilePath(FileName);
-
-  if (std::error_code EC = llvm::sys::fs::make_absolute(FilePath)) {
-    llvm::errs() << "Can't make absolute path from " << FileName << ": "
-                 << EC.message() << "\n";
-    // FIXME: Figure out what to do.
-  } else {
-    FileName = FilePath;
-  }
-
-  // Look for a suitable configuration file in all parent directories of the
-  // file. Start with the immediate parent directory and move up.
-  StringRef Path = llvm::sys::path::parent_path(FileName);
-  for (StringRef CurrentPath = Path;;
-       CurrentPath = llvm::sys::path::parent_path(CurrentPath)) {
-    llvm::Optional<ClangTidyOptions> Result;
-
-    auto Iter = CachedOptions.find(CurrentPath);
-    if (Iter != CachedOptions.end())
-      Result = Iter->second;
-
-    if (!Result)
-      Result = TryReadConfigFile(CurrentPath);
-
-    if (Result) {
-      // Store cached value for all intermediate directories.
-      while (Path != CurrentPath) {
-        DEBUG(llvm::dbgs() << "Caching configuration for path " << Path
-                           << ".\n");
-        CachedOptions[Path] = *Result;
-        Path = llvm::sys::path::parent_path(Path);
-      }
-      return CachedOptions[Path] = *Result;
-    }
-  }
-}
-
-llvm::Optional<ClangTidyOptions>
-FileOptionsProvider::TryReadConfigFile(StringRef Directory) {
-  assert(!Directory.empty());
-
-  if (!llvm::sys::fs::is_directory(Directory)) {
-    llvm::errs() << "Error reading configuration from " << Directory
-                 << ": directory doesn't exist.\n";
-    return llvm::None;
-  }
-
-  for (const ConfigFileHandler &ConfigHandler : ConfigHandlers) {
-    SmallString<128> ConfigFile(Directory);
-    llvm::sys::path::append(ConfigFile, ConfigHandler.first);
-    DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
-
-    bool IsFile = false;
-    // Ignore errors from is_regular_file: we only need to know if we can read
-    // the file or not.
-    llvm::sys::fs::is_regular_file(Twine(ConfigFile), IsFile);
-    if (!IsFile)
-      continue;
-
-    llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
-        llvm::MemoryBuffer::getFile(ConfigFile.c_str());
-    if (std::error_code EC = Text.getError()) {
-      llvm::errs() << "Can't read " << ConfigFile << ": " << EC.message()
-                   << "\n";
-      continue;
-    }
-
-    // Skip empty files, e.g. files opened for writing via shell output
-    // redirection.
-    if ((*Text)->getBuffer().empty())
-      continue;
-    llvm::ErrorOr<ClangTidyOptions> ParsedOptions =
-        ConfigHandler.second((*Text)->getBuffer());
-    if (!ParsedOptions) {
-      if (ParsedOptions.getError())
-        llvm::errs() << "Error parsing " << ConfigFile << ": "
-                     << ParsedOptions.getError().message() << "\n";
-      continue;
-    }
-
-    ClangTidyOptions Defaults = DefaultOptionsProvider::getOptions(Directory);
-    // Only use checks from the config file.
-    Defaults.Checks = None;
-    return Defaults.mergeWith(*ParsedOptions).mergeWith(OverrideOptions);
-  }
-  return llvm::None;
-}
-
-/// \brief Parses -line-filter option and stores it to the \c Options.
-std::error_code parseLineFilter(StringRef LineFilter,
-                                clang::tidy::ClangTidyGlobalOptions &Options) {
-  llvm::yaml::Input Input(LineFilter);
-  Input >> Options.LineFilter;
-  return Input.error();
-}
-
-llvm::ErrorOr<ClangTidyOptions> parseConfiguration(StringRef Config) {
-  llvm::yaml::Input Input(Config);
-  ClangTidyOptions Options;
-  Input >> Options;
-  if (Input.error())
-    return Input.error();
-  return Options;
-}
-
-std::string configurationAsText(const ClangTidyOptions &Options) {
-  std::string Text;
-  llvm::raw_string_ostream Stream(Text);
-  llvm::yaml::Output Output(Stream);
-  // We use the same mapping method for input and output, so we need a non-const
-  // reference here.
-  ClangTidyOptions NonConstValue = Options;
-  Output << NonConstValue;
-  return Stream.str();
-}
-
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/ClangTidyOptions.h

@@ -1,216 +0,0 @@
-//===--- ClangTidyOptions.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_CLANG_TIDY_OPTIONS_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_OPTIONS_H
-
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/ErrorOr.h"
-#include <functional>
-#include <map>
-#include <string>
-#include <system_error>
-#include <utility>
-#include <vector>
-
-namespace clang {
-namespace tidy {
-
-/// \brief Contains a list of line ranges in a single file.
-struct FileFilter {
-  /// \brief File name.
-  std::string Name;
-
-  /// \brief LineRange is a pair<start, end> (inclusive).
-  typedef std::pair<unsigned, unsigned> LineRange;
-
-  /// \brief A list of line ranges in this file, for which we show warnings.
-  std::vector<LineRange> LineRanges;
-};
-
-/// \brief Global options. These options are neither stored nor read from
-/// configuration files.
-struct ClangTidyGlobalOptions {
-  /// \brief Output warnings from certain line ranges of certain files only.
-  /// If empty, no warnings will be filtered.
-  std::vector<FileFilter> LineFilter;
-};
-
-/// \brief Contains options for clang-tidy. These options may be read from
-/// configuration files, and may be different for different translation units.
-struct ClangTidyOptions {
-  /// \brief These options are used for all settings that haven't been
-  /// overridden by the \c OptionsProvider.
-  ///
-  /// Allow no checks and no headers by default. This method initializes
-  /// check-specific options by calling \c ClangTidyModule::getModuleOptions()
-  /// of each registered \c ClangTidyModule.
-  static ClangTidyOptions getDefaults();
-
-  /// \brief Creates a new \c ClangTidyOptions instance combined from all fields
-  /// of this instance overridden by the fields of \p Other that have a value.
-  ClangTidyOptions mergeWith(const ClangTidyOptions &Other) const;
-
-  /// \brief Checks filter.
-  llvm::Optional<std::string> Checks;
-
-  /// \brief Output warnings from headers matching this filter. Warnings from
-  /// main files will always be displayed.
-  llvm::Optional<std::string> HeaderFilterRegex;
-
-  /// \brief Output warnings from system headers matching \c HeaderFilterRegex.
-  llvm::Optional<bool> SystemHeaders;
-
-  /// \brief Turns on temporary destructor-based analysis.
-  llvm::Optional<bool> AnalyzeTemporaryDtors;
-
-  /// \brief Specifies the name or e-mail of the user running clang-tidy.
-  ///
-  /// This option is used, for example, to place the correct user name in TODO()
-  /// comments in the relevant check.
-  llvm::Optional<std::string> User;
-
-  typedef std::pair<std::string, std::string> StringPair;
-  typedef std::map<std::string, std::string> OptionMap;
-
-  /// \brief Key-value mapping used to store check-specific options.
-  OptionMap CheckOptions;
-};
-
-/// \brief Abstract interface for retrieving various ClangTidy options.
-class ClangTidyOptionsProvider {
-public:
-  virtual ~ClangTidyOptionsProvider() {}
-
-  /// \brief Returns global options, which are independent of the file.
-  virtual const ClangTidyGlobalOptions &getGlobalOptions() = 0;
-
-  /// \brief Returns options applying to a specific translation unit with the
-  /// specified \p FileName.
-  virtual const ClangTidyOptions &getOptions(llvm::StringRef FileName) = 0;
-};
-
-/// \brief Implementation of the \c ClangTidyOptionsProvider interface, which
-/// returns the same options for all files.
-class DefaultOptionsProvider : public ClangTidyOptionsProvider {
-public:
-  DefaultOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
-                         const ClangTidyOptions &Options)
-      : GlobalOptions(GlobalOptions), DefaultOptions(Options) {}
-  const ClangTidyGlobalOptions &getGlobalOptions() override {
-    return GlobalOptions;
-  }
-  const ClangTidyOptions &getOptions(llvm::StringRef /*FileName*/) override {
-    return DefaultOptions;
-  }
-
-private:
-  ClangTidyGlobalOptions GlobalOptions;
-  ClangTidyOptions DefaultOptions;
-};
-
-/// \brief Implementation of the \c ClangTidyOptionsProvider interface, which
-/// tries to find a configuration file in the closest parent directory of each
-/// source file.
-///
-/// By default, files named ".clang-tidy" will be considered, and the
-/// \c clang::tidy::parseConfiguration function will be used for parsing, but a
-/// custom set of configuration file names and parsing functions can be
-/// specified using the appropriate constructor.
-class FileOptionsProvider : public DefaultOptionsProvider {
-public:
-  // \brief A pair of configuration file base name and a function parsing
-  // configuration from text in the corresponding format.
-  typedef std::pair<std::string, std::function<llvm::ErrorOr<ClangTidyOptions>(
-                                     llvm::StringRef)>> ConfigFileHandler;
-
-  /// \brief Configuration file handlers listed in the order of priority.
-  ///
-  /// Custom configuration file formats can be supported by constructing the
-  /// list of handlers and passing it to the appropriate \c FileOptionsProvider
-  /// constructor. E.g. initialization of a \c FileOptionsProvider with support
-  /// of a custom configuration file format for files named ".my-tidy-config"
-  /// could look similar to this:
-  /// \code
-  /// FileOptionsProvider::ConfigFileHandlers ConfigHandlers;
-  /// ConfigHandlers.emplace_back(".my-tidy-config", parseMyConfigFormat);
-  /// ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
-  /// return llvm::make_unique<FileOptionsProvider>(
-  ///     GlobalOptions, DefaultOptions, OverrideOptions, ConfigHandlers);
-  /// \endcode
-  ///
-  /// With the order of handlers shown above, the ".my-tidy-config" file would
-  /// take precedence over ".clang-tidy" if both reside in the same directory.
-  typedef std::vector<ConfigFileHandler> ConfigFileHandlers;
-
-  /// \brief Initializes the \c FileOptionsProvider instance.
-  ///
-  /// \param GlobalOptions are just stored and returned to the caller of
-  /// \c getGlobalOptions.
-  ///
-  /// \param DefaultOptions are used for all settings not specified in a
-  /// configuration file.
-  ///
-  /// If any of the \param OverrideOptions fields are set, they will override
-  /// whatever options are read from the configuration file.
-  FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
-                      const ClangTidyOptions &DefaultOptions,
-                      const ClangTidyOptions &OverrideOptions);
-
-  /// \brief Initializes the \c FileOptionsProvider instance with a custom set
-  /// of configuration file handlers.
-  ///
-  /// \param GlobalOptions are just stored and returned to the caller of
-  /// \c getGlobalOptions.
-  ///
-  /// \param DefaultOptions are used for all settings not specified in a
-  /// configuration file.
-  ///
-  /// If any of the \param OverrideOptions fields are set, they will override
-  /// whatever options are read from the configuration file.
-  ///
-  /// \param ConfigHandlers specifies a custom set of configuration file
-  /// handlers. Each handler is a pair of configuration file name and a function
-  /// that can parse configuration from this file type. The configuration files
-  /// in each directory are searched for in the order of appearance in
-  /// \p ConfigHandlers.
-  FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
-                      const ClangTidyOptions &DefaultOptions,
-                      const ClangTidyOptions &OverrideOptions,
-                      const ConfigFileHandlers &ConfigHandlers);
-
-  const ClangTidyOptions &getOptions(llvm::StringRef FileName) override;
-
-private:
-  /// \brief Try to read configuration files from \p Directory using registered
-  /// \c ConfigHandlers.
-  llvm::Optional<ClangTidyOptions> TryReadConfigFile(llvm::StringRef Directory);
-
-  llvm::StringMap<ClangTidyOptions> CachedOptions;
-  ClangTidyOptions OverrideOptions;
-  ConfigFileHandlers ConfigHandlers;
-};
-
-/// \brief Parses LineFilter from JSON and stores it to the \p Options.
-std::error_code parseLineFilter(llvm::StringRef LineFilter,
-                                ClangTidyGlobalOptions &Options);
-
-/// \brief Parses configuration from JSON and returns \c ClangTidyOptions or an
-/// error.
-llvm::ErrorOr<ClangTidyOptions> parseConfiguration(llvm::StringRef Config);
-
-/// \brief Serializes configuration to a YAML-encoded string.
-std::string configurationAsText(const ClangTidyOptions &Options);
-
-} // end namespace tidy
-} // end namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_OPTIONS_H

clang-tools-extra/clang-tidy/Makefile

@@ -11,6 +11,6 @@ CLANG_LEVEL := ../../..
 LIBRARYNAME := clangTidy
 include $(CLANG_LEVEL)/../../Makefile.config
 
-DIRS = utils readability llvm google misc tool
+DIRS = llvm google tool
 
 include $(CLANG_LEVEL)/Makefile

clang-tools-extra/clang-tidy/add_new_check.py

@@ -1,225 +0,0 @@
-#!/usr/bin/env python
-#
-#===- add_new_check.py - clang-tidy check generator ----------*- python -*--===#
-#
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-#===------------------------------------------------------------------------===#
-
-import os
-import re
-import sys
-
-
-# Adapts the module's CMakelist file. Returns 'True' if it could add a new entry
-# and 'False' if the entry already existed.
-def adapt_cmake(module_path, check_name_camel):
-  filename = os.path.join(module_path, 'CMakeLists.txt')
-  with open(filename, 'r') as f:
-    lines = f.read().split('\n')
-  # .split with separator returns one more element. Ignore it.
-  lines = lines[:-1]
-
-  cpp_file = check_name_camel + '.cpp'
-
-  # Figure out whether this check already exists.
-  for line in lines:
-    if line.strip() == cpp_file:
-      return False
-
-  with open(filename, 'w') as f:
-    cpp_found = False
-    file_added = False
-    for line in lines:
-      if not file_added and (line.endswith('.cpp') or cpp_found):
-        cpp_found = True
-        if line.strip() > cpp_file:
-          f.write('  ' + cpp_file + '\n')
-          file_added = True
-      f.write(line + '\n')
-
-  return True
-
-
-# Adds a header for the new check.
-def write_header(module_path, module, check_name, check_name_camel):
-  filename = os.path.join(module_path, check_name_camel) + '.h'
-  with open(filename, 'w') as f:
-    header_guard = ('LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_' + module.upper() +
-                    '_' + check_name.upper().replace('-', '_') + '_H')
-    f.write('//===--- ')
-    f.write(os.path.basename(filename))
-    f.write(' - clang-tidy')
-    f.write('-' * max(0, 43 - len(os.path.basename(filename))))
-    f.write('*- C++ -*-===//')
-    f.write("""
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef %(header_guard)s
-#define %(header_guard)s
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-
-class %(check_name)s : public ClangTidyCheck {
-public:
-  %(check_name)s(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace tidy
-} // namespace clang
-
-#endif // %(header_guard)s
-
-""" % {'header_guard': header_guard,
-       'check_name': check_name_camel})
-
-
-# Adds the implementation of the new check.
-def write_implementation(module_path, check_name_camel):
-  filename = os.path.join(module_path, check_name_camel) + '.cpp'
-  with open(filename, 'w') as f:
-    f.write('//===--- ')
-    f.write(os.path.basename(filename))
-    f.write(' - clang-tidy')
-    f.write('-' * max(0, 52 - len(os.path.basename(filename))))
-    f.write('-===//')
-    f.write("""
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "%(check_name)s.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-
-void %(check_name)s::registerMatchers(MatchFinder *Finder) {
-  // FIXME: Add matchers.
-  Finder->addMatcher(functionDecl().bind("x"), this);
-}
-
-void %(check_name)s::check(const MatchFinder::MatchResult &Result) {
-  // FIXME: Add callback implementation.
-  const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("x");
-  if (MatchedDecl->getName().startswith("awesome_"))
-    return;
-  diag(MatchedDecl->getLocation(), "function '%%0' is insufficiently awesome")
-      << MatchedDecl->getName()
-      << FixItHint::CreateInsertion(MatchedDecl->getLocation(), "awesome_");
-}
-
-} // namespace tidy
-} // namespace clang
-
-""" % {'check_name': check_name_camel})
-
-
-# Modifies the module to include the new check.
-def adapt_module(module_path, module, check_name, check_name_camel):
-  filename = os.path.join(module_path, module.capitalize() + 'TidyModule.cpp')
-  with open(filename, 'r') as f:
-    lines = f.read().split('\n')
-  # .split with separator returns one more element. Ignore it.
-  lines = lines[:-1]
-
-  with open(filename, 'w') as f:
-    header_added = False
-    header_found = False
-    check_added = False
-    check_decl = ('    CheckFactories.registerCheck<' + check_name_camel +
-                  '>(\n        "' + module + '-' + check_name + '");\n')
-
-    for line in lines:
-      if not header_added:
-        match = re.search('#include "(.*)"', line)
-        if match:
-          header_found = True
-          if match.group(1) > check_name_camel:
-            header_added = True
-            f.write('#include "' + check_name_camel + '.h"\n')
-        elif header_found:
-          header_added = True
-          f.write('#include "' + check_name_camel + '.h"\n')
-
-      if not check_added:
-        if line.strip() == '}':
-          check_added = True
-          f.write(check_decl)
-        else:
-          match = re.search('registerCheck<(.*)>', line)
-          if match and match.group(1) > check_name_camel:
-            check_added = True
-            f.write(check_decl)
-      f.write(line + '\n')
-
-
-# Adds a test for the check.
-def write_test(module_path, module, check_name):
-  check_name_dashes = module + '-' + check_name
-  filename = os.path.join(module_path, '../../test/clang-tidy',
-                          check_name_dashes + '.cpp')
-  with open(filename, 'w') as f:
-    f.write(
-"""// RUN: $(dirname %%s)/check_clang_tidy.sh %%s %(check_name_dashes)s %%t
-// REQUIRES: shell
-
-// FIXME: Add something that triggers the check here.
-void f();
-// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'f' is insufficiently awesome [%(check_name_dashes)s]
-
-// FIXME: Verify the applied fix.
-//   * Make the CHECK patterns specific enough and try to make verified lines
-//     unique to avoid incorrect matches.
-//   * Use {{}} for regular expressions.
-// CHECK-FIXES: {{^}}void awesome_f();{{$}}
-
-// FIXME: Add something that doesn't trigger the check here.
-void awesome_f2();
-""" % {"check_name_dashes" : check_name_dashes})
-
-def main():
-  if len(sys.argv) != 3:
-    print 'Usage: add_new_check.py <module> <check>, e.g.\n'
-    print 'add_new_check.py misc awesome-functions\n'
-    return
-
-  module = sys.argv[1]
-  check_name = sys.argv[2]
-  check_name_camel = ''.join(map(lambda elem: elem.capitalize(),
-                                 check_name.split('-'))) + 'Check'
-  clang_tidy_path = os.path.dirname(sys.argv[0])
-  module_path = os.path.join(clang_tidy_path, module)
-
-  if not adapt_cmake(module_path, check_name_camel):
-    return
-  write_header(module_path, module, check_name, check_name_camel)
-  write_implementation(module_path, check_name_camel)
-  adapt_module(module_path, module, check_name, check_name_camel)
-  write_test(module_path, module, check_name)
-
-
-if __name__ == '__main__':
-  main()

clang-tools-extra/clang-tidy/google/AvoidCStyleCastsCheck.cpp

@@ -1,153 +0,0 @@
-//===--- AvoidCStyleCastsCheck.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 "AvoidCStyleCastsCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace readability {
-
-void
-AvoidCStyleCastsCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
-  Finder->addMatcher(
-      cStyleCastExpr(
-          // Filter out (EnumType)IntegerLiteral construct, which is generated
-          // for non-type template arguments of enum types.
-          // FIXME: Remove this once this is fixed in the AST.
-          unless(hasParent(substNonTypeTemplateParmExpr())),
-          // Avoid matches in template instantiations.
-          unless(isInTemplateInstantiation())).bind("cast"),
-      this);
-}
-
-bool needsConstCast(QualType SourceType, QualType DestType) {
-  SourceType = SourceType.getNonReferenceType();
-  DestType = DestType.getNonReferenceType();
-  while (SourceType->isPointerType() && DestType->isPointerType()) {
-    SourceType = SourceType->getPointeeType();
-    DestType = DestType->getPointeeType();
-    if (SourceType.isConstQualified() && !DestType.isConstQualified())
-      return true;
-  }
-  return false;
-}
-
-bool pointedTypesAreEqual(QualType SourceType, QualType DestType) {
-  SourceType = SourceType.getNonReferenceType();
-  DestType = DestType.getNonReferenceType();
-  while (SourceType->isPointerType() && DestType->isPointerType()) {
-    SourceType = SourceType->getPointeeType();
-    DestType = DestType->getPointeeType();
-  }
-  return SourceType.getUnqualifiedType() == DestType.getUnqualifiedType();
-}
-
-void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *CastExpr = Result.Nodes.getNodeAs<CStyleCastExpr>("cast");
-
-  auto ParenRange = CharSourceRange::getTokenRange(CastExpr->getLParenLoc(),
-                                                   CastExpr->getRParenLoc());
-  // Ignore casts in macros.
-  if (ParenRange.getBegin().isMacroID() || ParenRange.getEnd().isMacroID())
-    return;
-
-  // Casting to void is an idiomatic way to mute "unused variable" and similar
-  // warnings.
-  if (CastExpr->getTypeAsWritten()->isVoidType())
-    return;
-
-  QualType SourceType =
-      CastExpr->getSubExprAsWritten()->getType().getCanonicalType();
-  QualType DestType = CastExpr->getTypeAsWritten().getCanonicalType();
-
-  if (SourceType == DestType) {
-    diag(CastExpr->getLocStart(), "Redundant cast to the same type.")
-        << FixItHint::CreateRemoval(ParenRange);
-    return;
-  }
-
-  // The rest of this check is only relevant to C++.
-  if (!Result.Context->getLangOpts().CPlusPlus)
-    return;
-
-  // Leave type spelling exactly as it was (unlike
-  // getTypeAsWritten().getAsString() which would spell enum types 'enum X').
-  StringRef DestTypeString = Lexer::getSourceText(
-      CharSourceRange::getTokenRange(
-          CastExpr->getLParenLoc().getLocWithOffset(1),
-          CastExpr->getRParenLoc().getLocWithOffset(-1)),
-      *Result.SourceManager, Result.Context->getLangOpts());
-
-  auto diag_builder =
-      diag(CastExpr->getLocStart(), "C-style casts are discouraged. %0");
-
-  auto ReplaceWithCast = [&](StringRef CastType) {
-    diag_builder << ("Use " + CastType + ".").str();
-
-    const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts();
-    std::string CastText = (CastType + "<" + DestTypeString + ">").str();
-    if (!isa<ParenExpr>(SubExpr)) {
-      CastText.push_back('(');
-      diag_builder << FixItHint::CreateInsertion(
-          Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0,
-                                     *Result.SourceManager,
-                                     Result.Context->getLangOpts()),
-          ")");
-    }
-    diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
-  };
-  // Suggest appropriate C++ cast. See [expr.cast] for cast notation semantics.
-  switch (CastExpr->getCastKind()) {
-  case CK_NoOp:
-    if (needsConstCast(SourceType, DestType) &&
-        pointedTypesAreEqual(SourceType, DestType)) {
-      ReplaceWithCast("const_cast");
-      return;
-    }
-    if (DestType->isReferenceType() &&
-        (SourceType.getNonReferenceType() ==
-             DestType.getNonReferenceType().withConst() ||
-         SourceType.getNonReferenceType() == DestType.getNonReferenceType())) {
-      ReplaceWithCast("const_cast");
-      return;
-    }
-    // FALLTHROUGH
-  case clang::CK_IntegralCast:
-    // Convert integral and no-op casts between builtin types and enums to
-    // static_cast. A cast from enum to integer may be unnecessary, but it's
-    // still retained.
-    if ((SourceType->isBuiltinType() || SourceType->isEnumeralType()) &&
-        (DestType->isBuiltinType() || DestType->isEnumeralType())) {
-      ReplaceWithCast("static_cast");
-      return;
-    }
-    break;
-  case CK_BitCast:
-    // FIXME: Suggest const_cast<...>(reinterpret_cast<...>(...)) replacement.
-    if (!needsConstCast(SourceType, DestType)) {
-      ReplaceWithCast("reinterpret_cast");
-      return;
-    }
-    break;
-  default:
-    break;
-  }
-
-  diag_builder << "Use static_cast/const_cast/reinterpret_cast.";
-}
-
-} // namespace readability
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/google/AvoidCStyleCastsCheck.h

@@ -1,39 +0,0 @@
-//===--- AvoidCStyleCastsCheck.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_GOOGLE_AVOID_C_STYLE_CASTS_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOID_C_STYLE_CASTS_CHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace readability {
-
-/// \brief Finds usages of C-style casts.
-///
-/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Casting#Casting
-/// Corresponding cpplint.py check name: 'readability/casting'.
-///
-/// This check is similar to -Wold-style-cast, but it will suggest automated
-/// fixes eventually. The reported locations should not be different from the
-/// ones generated by -Wold-style-cast.
-class AvoidCStyleCastsCheck : public ClangTidyCheck {
-public:
-  AvoidCStyleCastsCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace readability
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOID_C_STYLE_CASTS_CHECK_H

clang-tools-extra/clang-tidy/google/CMakeLists.txt

@@ -1,24 +1,11 @@
 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyGoogleModule
-  AvoidCStyleCastsCheck.cpp
-  ExplicitConstructorCheck.cpp
-  ExplicitMakePairCheck.cpp
   GoogleTidyModule.cpp
-  IntegerTypesCheck.cpp
-  MemsetZeroLengthCheck.cpp
-  NamedParameterCheck.cpp
-  OverloadedUnaryAndCheck.cpp
-  StringReferenceMemberCheck.cpp
-  TodoCommentCheck.cpp
-  UnnamedNamespaceInHeaderCheck.cpp
-  UsingNamespaceDirectiveCheck.cpp
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangLex
-  clangTidy
-  clangTidyReadabilityModule
+  )
+target_link_libraries(clangTidyGoogleModule
+  clangTidy
+  clangTooling
+  clangBasic
+  clangASTMatchers
   )

clang-tools-extra/clang-tidy/google/ExplicitConstructorCheck.cpp

@@ -1,114 +0,0 @@
-//===--- ExplicitConstructorCheck.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 "ExplicitConstructorCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-
-void ExplicitConstructorCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(constructorDecl(unless(isInstantiated())).bind("ctor"),
-                     this);
-}
-
-// Looks for the token matching the predicate and returns the range of the found
-// token including trailing whitespace.
-SourceRange FindToken(const SourceManager &Sources, LangOptions LangOpts,
-                      SourceLocation StartLoc, SourceLocation EndLoc,
-                      bool (*Pred)(const Token &)) {
-  if (StartLoc.isMacroID() || EndLoc.isMacroID())
-    return SourceRange();
-  FileID File = Sources.getFileID(Sources.getSpellingLoc(StartLoc));
-  StringRef Buf = Sources.getBufferData(File);
-  const char *StartChar = Sources.getCharacterData(StartLoc);
-  Lexer Lex(StartLoc, LangOpts, StartChar, StartChar, Buf.end());
-  Lex.SetCommentRetentionState(true);
-  Token Tok;
-  do {
-    Lex.LexFromRawLexer(Tok);
-    if (Pred(Tok)) {
-      Token NextTok;
-      Lex.LexFromRawLexer(NextTok);
-      return SourceRange(Tok.getLocation(), NextTok.getLocation());
-    }
-  } while (Tok.isNot(tok::eof) && Tok.getLocation() < EndLoc);
-
-  return SourceRange();
-}
-
-bool isStdInitializerList(QualType Type) {
-  if (const RecordType *RT = Type.getCanonicalType()->getAs<RecordType>()) {
-    if (ClassTemplateSpecializationDecl *Specialization =
-            dyn_cast<ClassTemplateSpecializationDecl>(RT->getDecl())) {
-      ClassTemplateDecl *Template = Specialization->getSpecializedTemplate();
-      // First use the fast getName() method to avoid unnecessary calls to the
-      // slow getQualifiedNameAsString().
-      return Template->getName() == "initializer_list" &&
-             Template->getQualifiedNameAsString() == "std::initializer_list";
-    }
-  }
-  return false;
-}
-
-void ExplicitConstructorCheck::check(const MatchFinder::MatchResult &Result) {
-  const CXXConstructorDecl *Ctor =
-      Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
-  // Do not be confused: isExplicit means 'explicit' keyword is present,
-  // isImplicit means that it's a compiler-generated constructor.
-  if (Ctor->isOutOfLine() || Ctor->isImplicit() || Ctor->isDeleted() ||
-      Ctor->getNumParams() == 0 || Ctor->getMinRequiredArguments() > 1)
-    return;
-
-  bool takesInitializerList = isStdInitializerList(
-      Ctor->getParamDecl(0)->getType().getNonReferenceType());
-  if (Ctor->isExplicit() &&
-      (Ctor->isCopyOrMoveConstructor() || takesInitializerList)) {
-    auto isKWExplicit = [](const Token &Tok) {
-      return Tok.is(tok::raw_identifier) &&
-             Tok.getRawIdentifier() == "explicit";
-    };
-    SourceRange ExplicitTokenRange =
-        FindToken(*Result.SourceManager, Result.Context->getLangOpts(),
-                  Ctor->getOuterLocStart(), Ctor->getLocEnd(), isKWExplicit);
-    StringRef ConstructorDescription;
-    if (Ctor->isMoveConstructor())
-      ConstructorDescription = "move";
-    else if (Ctor->isCopyConstructor())
-      ConstructorDescription = "copy";
-    else
-      ConstructorDescription = "initializer-list";
-
-    DiagnosticBuilder Diag =
-        diag(Ctor->getLocation(),
-             "%0 constructor should not be declared explicit")
-        << ConstructorDescription;
-    if (ExplicitTokenRange.isValid()) {
-      Diag << FixItHint::CreateRemoval(
-          CharSourceRange::getCharRange(ExplicitTokenRange));
-    }
-    return;
-  }
-
-  if (Ctor->isExplicit() || Ctor->isCopyOrMoveConstructor() ||
-      takesInitializerList)
-    return;
-
-  SourceLocation Loc = Ctor->getLocation();
-  diag(Loc, "single-argument constructors must be explicit")
-      << FixItHint::CreateInsertion(Loc, "explicit ");
-}
-
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/google/ExplicitConstructorCheck.h

@@ -1,33 +0,0 @@
-//===--- ExplicitConstructorCheck.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_GOOGLE_EXPLICIT_CONSTRUCTOR_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_CONSTRUCTOR_CHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-
-/// \brief Checks that all single-argument constructors are explicit.
-///
-/// see:
-/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Explicit_Constructors
-class ExplicitConstructorCheck : public ClangTidyCheck {
-public:
-  ExplicitConstructorCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_CONSTRUCTOR_CHECK_H

clang-tools-extra/clang-tidy/google/ExplicitMakePairCheck.cpp

@@ -1,71 +0,0 @@
-//===--- ExplicitMakePairCheck.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 "ExplicitMakePairCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-
-namespace ast_matchers {
-AST_MATCHER(DeclRefExpr, hasExplicitTemplateArgs) {
-  return Node.hasExplicitTemplateArgs();
-}
-} // namespace ast_matchers
-
-namespace tidy {
-namespace build {
-
-void
-ExplicitMakePairCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
-  // Look for std::make_pair with explicit template args. Ignore calls in
-  // templates.
-  Finder->addMatcher(
-      callExpr(unless(isInTemplateInstantiation()),
-               callee(expr(ignoringParenImpCasts(
-                   declRefExpr(hasExplicitTemplateArgs(),
-                               to(functionDecl(hasName("::std::make_pair"))))
-                       .bind("declref"))))).bind("call"),
-      this);
-}
-
-void ExplicitMakePairCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
-  const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declref");
-
-  // Sanity check: The use might have overriden ::std::make_pair.
-  if (Call->getNumArgs() != 2)
-    return;
-
-  const Expr *Arg0 = Call->getArg(0)->IgnoreParenImpCasts();
-  const Expr *Arg1 = Call->getArg(1)->IgnoreParenImpCasts();
-
-  // If types don't match, we suggest replacing with std::pair and explicit
-  // template arguments. Otherwise just remove the template arguments from
-  // make_pair.
-  if (Arg0->getType() != Call->getArg(0)->getType() ||
-      Arg1->getType() != Call->getArg(1)->getType()) {
-    diag(Call->getLocStart(), "for C++11-compatibility, use pair directly")
-        << FixItHint::CreateReplacement(
-            SourceRange(DeclRef->getLocStart(), DeclRef->getLAngleLoc()),
-            "std::pair<");
-  } else {
-    diag(Call->getLocStart(),
-         "for C++11-compatibility, omit template arguments from make_pair")
-        << FixItHint::CreateRemoval(
-            SourceRange(DeclRef->getLAngleLoc(), DeclRef->getRAngleLoc()));
-  }
-}
-
-} // namespace build
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/google/ExplicitMakePairCheck.h

@@ -1,37 +0,0 @@
-//===--- ExplicitMakePairCheck.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_GOOGLE_EXPLICIT_MAKE_PAIR_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_MAKE_PAIR_CHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace build {
-
-/// \brief Check that make_pair's template arguments are deduced.
-///
-/// G++ 4.6 in C++11 mode fails badly if make_pair's template arguments are
-/// specified explicitly, and such use isn't intended in any case.
-///
-/// Corresponding cpplint.py check name: 'build/explicit_make_pair'.
-class ExplicitMakePairCheck : public ClangTidyCheck {
-public:
-  ExplicitMakePairCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace build
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICIT_MAKE_PAIR_CHECK_H

clang-tools-extra/clang-tidy/google/GoogleTidyModule.cpp

@@ -7,74 +7,45 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "GoogleTidyModule.h"
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
-#include "../readability/BracesAroundStatementsCheck.h"
-#include "../readability/FunctionSize.h"
-#include "../readability/NamespaceCommentCheck.h"
-#include "../readability/RedundantSmartptrGet.h"
-#include "AvoidCStyleCastsCheck.h"
-#include "ExplicitConstructorCheck.h"
-#include "ExplicitMakePairCheck.h"
-#include "IntegerTypesCheck.h"
-#include "MemsetZeroLengthCheck.h"
-#include "NamedParameterCheck.h"
-#include "OverloadedUnaryAndCheck.h"
-#include "StringReferenceMemberCheck.h"
-#include "TodoCommentCheck.h"
-#include "UnnamedNamespaceInHeaderCheck.h"
-#include "UsingNamespaceDirectiveCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Lex/PPCallbacks.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 
+void
+ExplicitConstructorCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
+  Finder->addMatcher(constructorDecl().bind("construct"), this);
+}
+
+void ExplicitConstructorCheck::check(const MatchFinder::MatchResult &Result) {
+  const CXXConstructorDecl *Ctor =
+      Result.Nodes.getNodeAs<CXXConstructorDecl>("construct");
+  if (!Ctor->isExplicit() && !Ctor->isImplicit() && Ctor->getNumParams() >= 1 &&
+      Ctor->getMinRequiredArguments() <= 1) {
+    SourceLocation Loc = Ctor->getLocation();
+    Context->Diag(Loc, "Single-argument constructors must be explicit")
+        << FixItHint::CreateInsertion(Loc, "explicit ");
+  }
+}
+
 class GoogleModule : public ClangTidyModule {
 public:
-  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    CheckFactories.registerCheck<build::ExplicitMakePairCheck>(
-        "google-build-explicit-make-pair");
-    CheckFactories.registerCheck<build::UnnamedNamespaceInHeaderCheck>(
-        "google-build-namespaces");
-    CheckFactories.registerCheck<build::UsingNamespaceDirectiveCheck>(
-        "google-build-using-namespace");
-    CheckFactories.registerCheck<ExplicitConstructorCheck>(
-        "google-explicit-constructor");
-    CheckFactories.registerCheck<runtime::IntegerTypesCheck>(
-        "google-runtime-int");
-    CheckFactories.registerCheck<runtime::OverloadedUnaryAndCheck>(
-        "google-runtime-operator");
-    CheckFactories.registerCheck<runtime::StringReferenceMemberCheck>(
-        "google-runtime-member-string-references");
-    CheckFactories.registerCheck<runtime::MemsetZeroLengthCheck>(
-        "google-runtime-memset");
-    CheckFactories.registerCheck<readability::AvoidCStyleCastsCheck>(
-        "google-readability-casting");
-    CheckFactories.registerCheck<readability::NamedParameterCheck>(
-        "google-readability-function");
-    CheckFactories.registerCheck<readability::TodoCommentCheck>(
-        "google-readability-todo");
-    CheckFactories.registerCheck<readability::BracesAroundStatementsCheck>(
-        "google-readability-braces-around-statements");
-    CheckFactories.registerCheck<readability::FunctionSizeCheck>(
-        "google-readability-function-size");
-    CheckFactories.registerCheck<readability::NamespaceCommentCheck>(
-        "google-readability-namespace-comments");
-    CheckFactories.registerCheck<readability::RedundantSmartptrGet>(
-        "google-readability-redundant-smartptr-get");
-  }
-
-  ClangTidyOptions getModuleOptions() override {
-    ClangTidyOptions Options;
-    auto &Opts = Options.CheckOptions;
-    Opts["google-readability-braces-around-statements.ShortStatementLines"] =
-        "1";
-    Opts["google-readability-function-size.StatementThreshold"] = "800";
-    Opts["google-readability-namespace-comments.ShortNamespaceLines"] = "10";
-    Opts["google-readability-namespace-comments.SpacesBeforeComments"] = "2";
-    return Options;
+  virtual void addCheckFactories(ClangTidyCheckFactories &CheckFactories) {
+    CheckFactories.addCheckFactory(
+        "google-explicit-constructor",
+        new ClangTidyCheckFactory<ExplicitConstructorCheck>());
   }
 };
 

clang-tools-extra/clang-tidy/google/GoogleTidyModule.h

@@ -0,0 +1,31 @@
+//===--- GoogleTidyModule.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_GOOGLE_GOOGLE_TIDY_MODULE_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GOOGLE_TIDY_MODULE_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+
+/// \brief Checks that all single-argument constructors are explicit.
+///
+/// see:
+/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Explicit_Constructors
+class ExplicitConstructorCheck : public ClangTidyCheck {
+public:
+  virtual void registerMatchers(ast_matchers::MatchFinder *Finder);
+  virtual void check(const ast_matchers::MatchFinder::MatchResult &Result);
+};
+
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GOOGLE_TIDY_MODULE_H

clang-tools-extra/clang-tidy/google/IntegerTypesCheck.cpp

@@ -1,102 +0,0 @@
-//===--- IntegerTypesCheck.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 "IntegerTypesCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Basic/CharInfo.h"
-#include "clang/Basic/TargetInfo.h"
-
-namespace clang {
-namespace tidy {
-namespace runtime {
-
-using namespace ast_matchers;
-
-void IntegerTypesCheck::registerMatchers(MatchFinder *Finder) {
-  // Find all TypeLocs.
-  Finder->addMatcher(typeLoc().bind("tl"), this);
-}
-
-void IntegerTypesCheck::check(const MatchFinder::MatchResult &Result) {
-  // The relevant Style Guide rule only applies to C++.
-  if (!Result.Context->getLangOpts().CPlusPlus)
-    return;
-
-  auto TL = *Result.Nodes.getNodeAs<TypeLoc>("tl");
-  SourceLocation Loc = TL.getLocStart();
-
-  if (Loc.isInvalid() || Loc.isMacroID())
-    return;
-
-  // Look through qualification.
-  if (auto QualLoc = TL.getAs<QualifiedTypeLoc>())
-    TL = QualLoc.getUnqualifiedLoc();
-
-  auto BuiltinLoc = TL.getAs<BuiltinTypeLoc>();
-  if (!BuiltinLoc)
-    return;
-
-  bool IsSigned;
-  unsigned Width;
-  const TargetInfo &TargetInfo = Result.Context->getTargetInfo();
-
-  // Look for uses of short, long, long long and their unsigned versions.
-  switch (BuiltinLoc.getTypePtr()->getKind()) {
-  case BuiltinType::Short:
-    Width = TargetInfo.getShortWidth();
-    IsSigned = true;
-    break;
-  case BuiltinType::Long:
-    Width = TargetInfo.getLongWidth();
-    IsSigned = true;
-    break;
-  case BuiltinType::LongLong:
-    Width = TargetInfo.getLongLongWidth();
-    IsSigned = true;
-    break;
-  case BuiltinType::UShort:
-    Width = TargetInfo.getShortWidth();
-    IsSigned = false;
-    break;
-  case BuiltinType::ULong:
-    Width = TargetInfo.getLongWidth();
-    IsSigned = false;
-    break;
-  case BuiltinType::ULongLong:
-    Width = TargetInfo.getLongLongWidth();
-    IsSigned = false;
-    break;
-  default:
-    return;
-  }
-
-  // We allow "unsigned short port" as that's reasonably common and required by
-  // the sockets API.
-  const StringRef Port = "unsigned short port";
-  const char *Data = Result.SourceManager->getCharacterData(Loc);
-  if (!std::strncmp(Data, Port.data(), Port.size()) &&
-      !isIdentifierBody(Data[Port.size()]))
-    return;
-
-  std::string Replacement =
-      ((IsSigned ? SignedTypePrefix : UnsignedTypePrefix) + Twine(Width) +
-       (AddUnderscoreT ? "_t" : "")).str();
-
-  // We don't add a fix-it as changing the type can easily break code,
-  // e.g. when a function requires a 'long' argument on all platforms.
-  // QualTypes are printed with implicit quotes.
-  diag(Loc, "consider replacing %0 with '%1'") << BuiltinLoc.getType()
-                                               << Replacement;
-}
-
-} // namespace runtime
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/google/IntegerTypesCheck.h

@@ -1,40 +0,0 @@
-//===--- IntegerTypesCheck.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_GOOGLE_INTEGERTYPESCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_INTEGERTYPESCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace runtime {
-
-/// \brief Finds uses of short, long and long long and suggest replacing them
-/// with u?intXX(_t)?.
-/// Correspondig cpplint.py check: runtime/int.
-class IntegerTypesCheck : public ClangTidyCheck {
-public:
-  IntegerTypesCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context), UnsignedTypePrefix("uint"),
-        SignedTypePrefix("int"), AddUnderscoreT(false) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-
-private:
-  const StringRef UnsignedTypePrefix;
-  const StringRef SignedTypePrefix;
-  const bool AddUnderscoreT;
-};
-
-} // namespace runtime
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_INTEGERTYPESCHECK_H

clang-tools-extra/clang-tidy/google/MemsetZeroLengthCheck.cpp

@@ -1,89 +0,0 @@
-//===--- MemsetZeroLengthCheck.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 "MemsetZeroLengthCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace runtime {
-
-void
-MemsetZeroLengthCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
-  // Look for memset(x, y, 0) as those is most likely an argument swap.
-  // TODO: Also handle other standard functions that suffer from the same
-  //       problem, e.g. memchr.
-  Finder->addMatcher(
-      callExpr(callee(functionDecl(hasName("::memset"))), argumentCountIs(3),
-               unless(isInTemplateInstantiation())).bind("decl"),
-      this);
-}
-
-/// \brief Get a StringRef representing a SourceRange.
-static StringRef getAsString(const MatchFinder::MatchResult &Result,
-                             SourceRange R) {
-  const SourceManager &SM = *Result.SourceManager;
-  // Don't even try to resolve macro or include contraptions. Not worth emitting
-  // a fixit for.
-  if (R.getBegin().isMacroID() ||
-      !SM.isWrittenInSameFile(R.getBegin(), R.getEnd()))
-    return StringRef();
-
-  const char *Begin = SM.getCharacterData(R.getBegin());
-  const char *End = SM.getCharacterData(Lexer::getLocForEndOfToken(
-      R.getEnd(), 0, SM, Result.Context->getLangOpts()));
-
-  return StringRef(Begin, End - Begin);
-}
-
-void MemsetZeroLengthCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Call = Result.Nodes.getNodeAs<CallExpr>("decl");
-
-  const Expr *Arg1 = Call->getArg(1);
-  const Expr *Arg2 = Call->getArg(2);
-
-  // Try to evaluate the second argument so we can also find values that are not
-  // just literals.
-  llvm::APSInt Value1, Value2;
-  if (Arg2->isValueDependent() ||
-      !Arg2->EvaluateAsInt(Value2, *Result.Context) || Value2 != 0)
-    return;
-
-  // If both arguments evaluate to zero emit a warning without fix suggestions.
-  if (!Arg1->isValueDependent() &&
-      Arg1->EvaluateAsInt(Value1, *Result.Context) &&
-      (Value1 == 0 || Value1.isNegative())) {
-    diag(Call->getLocStart(), "memset of size zero");
-    return;
-  }
-
-  // Emit a warning and fix-its to swap the arguments.
-  auto D = diag(Call->getLocStart(),
-                "memset of size zero, potentially swapped arguments");
-  SourceRange LHSRange = Arg1->getSourceRange();
-  SourceRange RHSRange = Arg2->getSourceRange();
-  StringRef RHSString = getAsString(Result, RHSRange);
-  StringRef LHSString = getAsString(Result, LHSRange);
-  if (LHSString.empty() || RHSString.empty())
-    return;
-
-  D << FixItHint::CreateReplacement(CharSourceRange::getTokenRange(LHSRange),
-                                    RHSString)
-    << FixItHint::CreateReplacement(CharSourceRange::getTokenRange(RHSRange),
-                                    LHSString);
-}
-
-} // namespace runtime
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/google/MemsetZeroLengthCheck.h

@@ -1,37 +0,0 @@
-//===--- MemsetZeroLengthCheck.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_GOOGLE_MEMSET_ZERO_LENGTH_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_MEMSET_ZERO_LENGTH_CHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace runtime {
-
-/// \brief Finds calls to memset with a literal zero in the length argument.
-///
-/// This is most likely unintended and the length and value arguments are
-/// swapped.
-///
-/// Corresponding cpplint.py check name: 'runtime/memset'.
-class MemsetZeroLengthCheck : public ClangTidyCheck {
-public:
-  MemsetZeroLengthCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace runtime
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_MEMSET_ZERO_LENGTH_CHECK_H

clang-tools-extra/clang-tidy/google/NamedParameterCheck.cpp

@@ -1,125 +0,0 @@
-//===--- NamedParameterCheck.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 "NamedParameterCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace readability {
-
-void NamedParameterCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
-  Finder->addMatcher(functionDecl(unless(isInstantiated())).bind("decl"), this);
-}
-
-void NamedParameterCheck::check(const MatchFinder::MatchResult &Result) {
-  const SourceManager &SM = *Result.SourceManager;
-  const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("decl");
-  SmallVector<std::pair<const FunctionDecl *, unsigned>, 4> UnnamedParams;
-
-  // Ignore implicitly generated members.
-  if (Function->isImplicit())
-    return;
-
-  // Ignore declarations without a definition if we're not dealing with an
-  // overriden method.
-  const FunctionDecl *Definition = nullptr;
-  if ((!Function->isDefined(Definition) || Function->isDefaulted() ||
-       Function->isDeleted()) &&
-      (!isa<CXXMethodDecl>(Function) ||
-       cast<CXXMethodDecl>(Function)->size_overridden_methods() == 0))
-    return;
-
-  // TODO: Handle overloads.
-  // TODO: We could check that all redeclarations use the same name for
-  //       arguments in the same position.
-  for (unsigned I = 0, E = Function->getNumParams(); I != E; ++I) {
-    const ParmVarDecl *Parm = Function->getParamDecl(I);
-    // Look for unnamed parameters.
-    if (!Parm->getName().empty())
-      continue;
-
-    // Don't warn on the dummy argument on post-inc and post-dec operators.
-    if ((Function->getOverloadedOperator() == OO_PlusPlus ||
-         Function->getOverloadedOperator() == OO_MinusMinus) &&
-        Parm->getType()->isSpecificBuiltinType(BuiltinType::Int))
-      continue;
-
-    // Sanity check the source locations.
-    if (!Parm->getLocation().isValid() || Parm->getLocation().isMacroID() ||
-        !SM.isWrittenInSameFile(Parm->getLocStart(), Parm->getLocation()))
-      continue;
-
-    // Skip gmock testing::Unused parameters.
-    if (auto Typedef = Parm->getType()->getAs<clang::TypedefType>())
-      if (Typedef->getDecl()->getQualifiedNameAsString() == "testing::Unused")
-        continue;
-
-    // Skip std::nullptr_t.
-    if (Parm->getType().getCanonicalType()->isNullPtrType())
-      continue;
-
-    // Look for comments. We explicitly want to allow idioms like
-    // void foo(int /*unused*/)
-    const char *Begin = SM.getCharacterData(Parm->getLocStart());
-    const char *End = SM.getCharacterData(Parm->getLocation());
-    StringRef Data(Begin, End - Begin);
-    if (Data.find("/*") != StringRef::npos)
-      continue;
-
-    UnnamedParams.push_back(std::make_pair(Function, I));
-  }
-
-  // Emit only one warning per function but fixits for all unnamed parameters.
-  if (!UnnamedParams.empty()) {
-    const ParmVarDecl *FirstParm =
-        UnnamedParams.front().first->getParamDecl(UnnamedParams.front().second);
-    auto D = diag(FirstParm->getLocation(),
-                  "all parameters should be named in a function");
-
-    for (auto P : UnnamedParams) {
-      // Fallback to an unused marker.
-      StringRef NewName = "unused";
-
-      // If the method is overridden, try to copy the name from the base method
-      // into the overrider.
-      const auto *M = dyn_cast<CXXMethodDecl>(P.first);
-      if (M && M->size_overridden_methods() > 0) {
-        const ParmVarDecl *OtherParm =
-            (*M->begin_overridden_methods())->getParamDecl(P.second);
-        StringRef Name = OtherParm->getName();
-        if (!Name.empty())
-          NewName = Name;
-      }
-
-      // If the definition has a named parameter use that name.
-      if (Definition) {
-        const ParmVarDecl *DefParm = Definition->getParamDecl(P.second);
-        StringRef Name = DefParm->getName();
-        if (!Name.empty())
-          NewName = Name;
-      }
-
-      // Now insert the comment. Note that getLocation() points to the place
-      // where the name would be, this allows us to also get complex cases like
-      // function pointers right.
-      const ParmVarDecl *Parm = P.first->getParamDecl(P.second);
-      D << FixItHint::CreateInsertion(Parm->getLocation(),
-                                      " /*" + NewName.str() + "*/");
-    }
-  }
-}
-
-} // namespace readability
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/google/NamedParameterCheck.h

@@ -1,35 +0,0 @@
-//===--- NamedParameterCheck.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_GOOGLE_NAMED_PARAMETER_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_NAMED_PARAMETER_CHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace readability {
-
-/// \brief Find functions with unnamed arguments.
-///
-/// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Function_Declarations_and_Definitions#Function_Declarations_and_Definitions
-/// Corresponding cpplint.py check name: 'readability/function'.
-class NamedParameterCheck : public ClangTidyCheck {
-public:
-  NamedParameterCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace readability
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_NAMED_PARAMETER_CHECK_H