Merging r300267:

------------------------------------------------------------------------
r300267 | tejohnson | 2017-04-13 17:51:49 -0400 (Thu, 13 Apr 2017) | 11 lines

[Support] Fix ErrorOr assertion when /proc/cpuinfo doesn't exist.

The ErrorOr should not be dereferenced on the error path.

Patch by Jacob Young

Reviewers: tejohnson

Subscribers: llvm-commits

Differential Revision: https://reviews.llvm.org/D32032
------------------------------------------------------------------------

llvm-svn: 305264

clang-tools-extra/.arcconfig

@@ -1,4 +1,4 @@
 {
-  "repository.callsign" : "CTE",
+  "project_id" : "clang-tools-extra",
   "conduit_uri" : "https://reviews.llvm.org/"
 }

clang-tools-extra/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_subdirectory(clang-apply-replacements)
+add_subdirectory(clang-rename)
 add_subdirectory(clang-reorder-fields)
 add_subdirectory(modularize)
 if(CLANG_ENABLE_STATIC_ANALYZER)
@@ -9,13 +10,13 @@ endif()
 add_subdirectory(change-namespace)
 add_subdirectory(clang-query)
 add_subdirectory(clang-move)
-add_subdirectory(clangd)
 add_subdirectory(include-fixer)
 add_subdirectory(pp-trace)
 add_subdirectory(tool-template)
 
 # Add the common testsuite after all the tools.
-if(CLANG_INCLUDE_TESTS)
+# TODO: Support tests with more granularity when features are off?
+if(CLANG_ENABLE_STATIC_ANALYZER AND CLANG_INCLUDE_TESTS)
 add_subdirectory(test)
 add_subdirectory(unittests)
 endif()

clang-tools-extra/LICENSE.TXT

@@ -60,4 +60,3 @@ licenses, and/or restrictions:
 Program             Directory
 -------             ---------
 clang-tidy          clang-tidy/cert
-clang-tidy          clang-tidy/hicpp

clang-tools-extra/change-namespace/ChangeNamespace.cpp

@@ -28,14 +28,6 @@ joinNamespaces(const llvm::SmallVectorImpl<StringRef> &Namespaces) {
   return Result;
 }
 
-// Given "a::b::c", returns {"a", "b", "c"}.
-llvm::SmallVector<llvm::StringRef, 4> splitSymbolName(llvm::StringRef Name) {
-  llvm::SmallVector<llvm::StringRef, 4> Splitted;
-  Name.split(Splitted, "::", /*MaxSplit=*/-1,
-             /*KeepEmpty=*/false);
-  return Splitted;
-}
-
 SourceLocation startLocationForType(TypeLoc TLoc) {
   // For elaborated types (e.g. `struct a::A`) we want the portion after the
   // `struct` but including the namespace qualifier, `a::`.
@@ -76,7 +68,9 @@ const NamespaceDecl *getOuterNamespace(const NamespaceDecl *InnerNs,
     return nullptr;
   const auto *CurrentContext = llvm::cast<DeclContext>(InnerNs);
   const auto *CurrentNs = InnerNs;
-  auto PartialNsNameSplitted = splitSymbolName(PartialNsName);
+  llvm::SmallVector<llvm::StringRef, 4> PartialNsNameSplitted;
+  PartialNsName.split(PartialNsNameSplitted, "::", /*MaxSplit=*/-1,
+                      /*KeepEmpty=*/false);
   while (!PartialNsNameSplitted.empty()) {
     // Get the inner-most namespace in CurrentContext.
     while (CurrentContext && !llvm::isa<NamespaceDecl>(CurrentContext))
@@ -202,8 +196,6 @@ tooling::Replacement createInsertion(SourceLocation Loc,
 // Returns the shortest qualified name for declaration `DeclName` in the
 // namespace `NsName`. For example, if `DeclName` is "a::b::X" and `NsName`
 // is "a::c::d", then "b::X" will be returned.
-// Note that if `DeclName` is `::b::X` and `NsName` is `::a::b`, this returns
-// "::b::X" instead of "b::X" since there will be a name conflict otherwise.
 // \param DeclName A fully qualified name, "::a::b::X" or "a::b::X".
 // \param NsName A fully qualified name, "::a::b" or "a::b". Global namespace
 //        will have empty name.
@@ -214,44 +206,22 @@ std::string getShortestQualifiedNameInNamespace(llvm::StringRef DeclName,
   if (DeclName.find(':') == llvm::StringRef::npos)
     return DeclName;
 
-  auto NsNameSplitted = splitSymbolName(NsName);
-  auto DeclNsSplitted = splitSymbolName(DeclName);
-  llvm::StringRef UnqualifiedDeclName = DeclNsSplitted.pop_back_val();
-  // If the Decl is in global namespace, there is no need to shorten it.
-  if (DeclNsSplitted.empty())
-    return UnqualifiedDeclName;
-  // If NsName is the global namespace, we can simply use the DeclName sans
-  // leading "::".
-  if (NsNameSplitted.empty())
-    return DeclName;
-
-  if (NsNameSplitted.front() != DeclNsSplitted.front()) {
-    // The DeclName must be fully-qualified, but we still need to decide if a
-    // leading "::" is necessary. For example, if `NsName` is "a::b::c" and the
-    // `DeclName` is "b::X", then the reference must be qualified as "::b::X"
-    // to avoid conflict.
-    if (llvm::is_contained(NsNameSplitted, DeclNsSplitted.front()))
-      return ("::" + DeclName).str();
-    return DeclName;
+  while (!DeclName.consume_front((NsName + "::").str())) {
+    const auto Pos = NsName.find_last_of(':');
+    if (Pos == llvm::StringRef::npos)
+      return DeclName;
+    assert(Pos > 0);
+    NsName = NsName.substr(0, Pos - 1);
   }
-  // Since there is already an overlap namespace, we know that `DeclName` can be
-  // shortened, so we reduce the longest common prefix.
-  auto DeclI = DeclNsSplitted.begin();
-  auto DeclE = DeclNsSplitted.end();
-  auto NsI = NsNameSplitted.begin();
-  auto NsE = NsNameSplitted.end();
-  for (; DeclI != DeclE && NsI != NsE && *DeclI == *NsI; ++DeclI, ++NsI) {
-  }
-  return (DeclI == DeclE)
-             ? UnqualifiedDeclName.str()
-             : (llvm::join(DeclI, DeclE, "::") + "::" + UnqualifiedDeclName)
-                   .str();
+  return DeclName;
 }
 
 std::string wrapCodeInNamespace(StringRef NestedNs, std::string Code) {
   if (Code.back() != '\n')
     Code += "\n";
-  auto NsSplitted = splitSymbolName(NestedNs);
+  llvm::SmallVector<StringRef, 4> NsSplitted;
+  NestedNs.split(NsSplitted, "::", /*MaxSplit=*/-1,
+                 /*KeepEmpty=*/false);
   while (!NsSplitted.empty()) {
     // FIXME: consider code style for comments.
     Code = ("namespace " + NsSplitted.back() + " {\n" + Code +
@@ -275,61 +245,27 @@ bool isNestedDeclContext(const DeclContext *D, const DeclContext *Context) {
 // Returns true if \p D is visible at \p Loc with DeclContext \p DeclCtx.
 bool isDeclVisibleAtLocation(const SourceManager &SM, const Decl *D,
                              const DeclContext *DeclCtx, SourceLocation Loc) {
-  SourceLocation DeclLoc = SM.getSpellingLoc(D->getLocStart());
+  SourceLocation DeclLoc = SM.getSpellingLoc(D->getLocation());
   Loc = SM.getSpellingLoc(Loc);
   return SM.isBeforeInTranslationUnit(DeclLoc, Loc) &&
          (SM.getFileID(DeclLoc) == SM.getFileID(Loc) &&
           isNestedDeclContext(DeclCtx, D->getDeclContext()));
 }
 
-// Given a qualified symbol name, returns true if the symbol will be
-// incorrectly qualified without leading "::".
-bool conflictInNamespace(llvm::StringRef QualifiedSymbol,
-                         llvm::StringRef Namespace) {
-  auto SymbolSplitted = splitSymbolName(QualifiedSymbol.trim(":"));
-  assert(!SymbolSplitted.empty());
-  SymbolSplitted.pop_back();  // We are only interested in namespaces.
-
-  if (SymbolSplitted.size() > 1 && !Namespace.empty()) {
-    auto NsSplitted = splitSymbolName(Namespace.trim(":"));
-    assert(!NsSplitted.empty());
-    // We do not check the outermost namespace since it would not be a conflict
-    // if it equals to the symbol's outermost namespace and the symbol name
-    // would have been shortened.
-    for (auto I = NsSplitted.begin() + 1, E = NsSplitted.end(); I != E; ++I) {
-      if (*I == SymbolSplitted.front())
-        return true;
-    }
-  }
-  return false;
-}
-
-AST_MATCHER(EnumDecl, isScoped) {
-    return Node.isScoped();
-}
-
-bool isTemplateParameter(TypeLoc Type) {
-  while (!Type.isNull()) {
-    if (Type.getTypeLocClass() == TypeLoc::SubstTemplateTypeParm)
-      return true;
-    Type = Type.getNextTypeLoc();
-  }
-  return false;
-}
-
 } // anonymous namespace
 
 ChangeNamespaceTool::ChangeNamespaceTool(
     llvm::StringRef OldNs, llvm::StringRef NewNs, llvm::StringRef FilePattern,
-    llvm::ArrayRef<std::string> WhiteListedSymbolPatterns,
     std::map<std::string, tooling::Replacements> *FileToReplacements,
     llvm::StringRef FallbackStyle)
     : FallbackStyle(FallbackStyle), FileToReplacements(*FileToReplacements),
       OldNamespace(OldNs.ltrim(':')), NewNamespace(NewNs.ltrim(':')),
       FilePattern(FilePattern), FilePatternRE(FilePattern) {
   FileToReplacements->clear();
-  auto OldNsSplitted = splitSymbolName(OldNamespace);
-  auto NewNsSplitted = splitSymbolName(NewNamespace);
+  llvm::SmallVector<llvm::StringRef, 4> OldNsSplitted;
+  llvm::SmallVector<llvm::StringRef, 4> NewNsSplitted;
+  llvm::StringRef(OldNamespace).split(OldNsSplitted, "::");
+  llvm::StringRef(NewNamespace).split(NewNsSplitted, "::");
   // Calculates `DiffOldNamespace` and `DiffNewNamespace`.
   while (!OldNsSplitted.empty() && !NewNsSplitted.empty() &&
          OldNsSplitted.front() == NewNsSplitted.front()) {
@@ -338,9 +274,6 @@ ChangeNamespaceTool::ChangeNamespaceTool(
   }
   DiffOldNamespace = joinNamespaces(OldNsSplitted);
   DiffNewNamespace = joinNamespaces(NewNsSplitted);
-
-  for (const auto &Pattern : WhiteListedSymbolPatterns)
-    WhiteListedSymbolRegexes.emplace_back(Pattern);
 }
 
 void ChangeNamespaceTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
@@ -427,8 +360,7 @@ void ChangeNamespaceTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
                                      unless(templateSpecializationType())))))),
                            hasParent(nestedNameSpecifierLoc()),
                            hasAncestor(isImplicit()),
-                           hasAncestor(UsingShadowDeclInClass),
-                           hasAncestor(functionDecl(isDefaulted())))),
+                           hasAncestor(UsingShadowDeclInClass))),
               hasAncestor(decl().bind("dc")))
           .bind("type"),
       this);
@@ -452,7 +384,6 @@ void ChangeNamespaceTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
               specifiesType(hasDeclaration(DeclMatcher.bind("from_decl"))))),
           unless(anyOf(hasAncestor(isImplicit()),
                        hasAncestor(UsingShadowDeclInClass),
-                       hasAncestor(functionDecl(isDefaulted())),
                        hasAncestor(typeLoc(loc(qualType(hasDeclaration(
                            decl(equalsBoundNode("from_decl"))))))))))
           .bind("nested_specifier_loc"),
@@ -493,17 +424,6 @@ void ChangeNamespaceTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
                                  to(GlobalVarMatcher.bind("var_decl")))
                          .bind("var_ref"),
                      this);
-
-  // Handle unscoped enum constant.
-  auto UnscopedEnumMatcher = enumConstantDecl(hasParent(enumDecl(
-      hasParent(namespaceDecl()),
-      unless(anyOf(isScoped(), IsInMovedNs, hasAncestor(cxxRecordDecl()),
-                   hasAncestor(namespaceDecl(isAnonymous())))))));
-  Finder->addMatcher(
-      declRefExpr(IsInMovedNs, hasAncestor(decl().bind("dc")),
-                  to(UnscopedEnumMatcher.bind("enum_const_decl")))
-          .bind("enum_const_ref"),
-      this);
 }
 
 void ChangeNamespaceTool::run(
@@ -552,10 +472,6 @@ void ChangeNamespaceTool::run(
     if (Loc.getTypeLocClass() == TypeLoc::Elaborated) {
       NestedNameSpecifierLoc NestedNameSpecifier =
           Loc.castAs<ElaboratedTypeLoc>().getQualifierLoc();
-      // This happens for friend declaration of a base class with injected class
-      // name.
-      if (!NestedNameSpecifier.getNestedNameSpecifier())
-        return;
       const Type *SpecifierType =
           NestedNameSpecifier.getNestedNameSpecifier()->getAsType();
       if (SpecifierType && SpecifierType->isRecordType())
@@ -572,23 +488,6 @@ void ChangeNamespaceTool::run(
     assert(Context && "Empty decl context.");
     fixDeclRefExpr(Result, Context->getDeclContext(),
                    llvm::cast<NamedDecl>(Var), VarRef);
-  } else if (const auto *EnumConstRef =
-                 Result.Nodes.getNodeAs<DeclRefExpr>("enum_const_ref")) {
-    // Do not rename the reference if it is already scoped by the EnumDecl name.
-    if (EnumConstRef->hasQualifier() &&
-        EnumConstRef->getQualifier()->getKind() ==
-            NestedNameSpecifier::SpecifierKind::TypeSpec &&
-        EnumConstRef->getQualifier()->getAsType()->isEnumeralType())
-      return;
-    const auto *EnumConstDecl =
-        Result.Nodes.getNodeAs<EnumConstantDecl>("enum_const_decl");
-    assert(EnumConstDecl);
-    const auto *Context = Result.Nodes.getNodeAs<Decl>("dc");
-    assert(Context && "Empty decl context.");
-    // FIXME: this would qualify "ns::VALUE" as "ns::EnumValue::VALUE". Fix it
-    // if it turns out to be an issue.
-    fixDeclRefExpr(Result, Context->getDeclContext(),
-                   llvm::cast<NamedDecl>(EnumConstDecl), EnumConstRef);
   } else if (const auto *FuncRef =
                  Result.Nodes.getNodeAs<DeclRefExpr>("func_ref")) {
     // If this reference has been processed as a function call, we do not
@@ -711,18 +610,19 @@ void ChangeNamespaceTool::moveClassForwardDeclaration(
     const NamedDecl *FwdDecl) {
   SourceLocation Start = FwdDecl->getLocStart();
   SourceLocation End = FwdDecl->getLocEnd();
-  const SourceManager &SM = *Result.SourceManager;
   SourceLocation AfterSemi = Lexer::findLocationAfterToken(
-      End, tok::semi, SM, Result.Context->getLangOpts(),
+      End, tok::semi, *Result.SourceManager, Result.Context->getLangOpts(),
       /*SkipTrailingWhitespaceAndNewLine=*/true);
   if (AfterSemi.isValid())
     End = AfterSemi.getLocWithOffset(-1);
   // Delete the forward declaration from the code to be moved.
-  addReplacementOrDie(Start, End, "", SM, &FileToReplacements);
+  addReplacementOrDie(Start, End, "", *Result.SourceManager,
+                      &FileToReplacements);
   llvm::StringRef Code = Lexer::getSourceText(
-      CharSourceRange::getTokenRange(SM.getSpellingLoc(Start),
-                                     SM.getSpellingLoc(End)),
-      SM, Result.Context->getLangOpts());
+      CharSourceRange::getTokenRange(
+          Result.SourceManager->getSpellingLoc(Start),
+          Result.SourceManager->getSpellingLoc(End)),
+      *Result.SourceManager, Result.Context->getLangOpts());
   // Insert the forward declaration back into the old namespace after moving the
   // code from old namespace to new namespace.
   // Insertion information is stored in `InsertFwdDecls` and actual
@@ -731,9 +631,8 @@ void ChangeNamespaceTool::moveClassForwardDeclaration(
   const auto *NsDecl = Result.Nodes.getNodeAs<NamespaceDecl>("ns_decl");
   // The namespace contains the forward declaration, so it must not be empty.
   assert(!NsDecl->decls_empty());
-  const auto Insertion = createInsertion(
-      getLocAfterNamespaceLBrace(NsDecl, SM, Result.Context->getLangOpts()),
-      Code, SM);
+  const auto Insertion = createInsertion(NsDecl->decls_begin()->getLocStart(),
+                                         Code, *Result.SourceManager);
   InsertForwardDeclaration InsertFwd;
   InsertFwd.InsertionOffset = Insertion.getOffset();
   InsertFwd.ForwardDeclText = Insertion.getReplacementText().str();
@@ -774,10 +673,10 @@ void ChangeNamespaceTool::replaceQualifiedSymbolInDeclContext(
           Result.SourceManager->getSpellingLoc(Start),
           Result.SourceManager->getSpellingLoc(End)),
       *Result.SourceManager, Result.Context->getLangOpts());
+  // If the symbol is already fully qualified, no change needs to be make.
+  if (NestedName.startswith("::"))
+    return;
   std::string FromDeclName = FromDecl->getQualifiedNameAsString();
-  for (llvm::Regex &RE : WhiteListedSymbolRegexes)
-    if (RE.match(FromDeclName))
-      return;
   std::string ReplaceName =
       getShortestQualifiedNameInNamespace(FromDeclName, NewNs);
   // Checks if there is any using namespace declarations that can shorten the
@@ -835,8 +734,7 @@ void ChangeNamespaceTool::replaceQualifiedSymbolInDeclContext(
     if (isDeclVisibleAtLocation(*Result.SourceManager, Using, DeclCtx, Start)) {
       for (const auto *UsingShadow : Using->shadows()) {
         const auto *TargetDecl = UsingShadow->getTargetDecl();
-        if (TargetDecl->getQualifiedNameAsString() ==
-            FromDecl->getQualifiedNameAsString()) {
+        if (TargetDecl == FromDecl) {
           ReplaceName = FromDecl->getNameAsString();
           Matched = true;
           break;
@@ -846,13 +744,11 @@ void ChangeNamespaceTool::replaceQualifiedSymbolInDeclContext(
   }
   // If the new nested name in the new namespace is the same as it was in the
   // old namespace, we don't create replacement.
-  if (NestedName == ReplaceName ||
-      (NestedName.startswith("::") && NestedName.drop_front(2) == ReplaceName))
+  if (NestedName == ReplaceName)
     return;
   // If the reference need to be fully-qualified, add a leading "::" unless
   // NewNamespace is the global namespace.
-  if (ReplaceName == FromDeclName && !NewNamespace.empty() &&
-      conflictInNamespace(ReplaceName, NewNamespace))
+  if (ReplaceName == FromDeclName && !NewNamespace.empty())
     ReplaceName = "::" + ReplaceName;
   addReplacementOrDie(Start, End, ReplaceName, *Result.SourceManager,
                       &FileToReplacements);
@@ -869,8 +765,6 @@ void ChangeNamespaceTool::fixTypeLoc(
   // Types of CXXCtorInitializers do not need to be fixed.
   if (llvm::is_contained(BaseCtorInitializerTypeLocs, Type))
     return;
-  if (isTemplateParameter(Type))
-    return;
   // The declaration which this TypeLoc refers to.
   const auto *FromDecl = Result.Nodes.getNodeAs<NamedDecl>("from_decl");
   // `hasDeclaration` gives underlying declaration, but if the type is
@@ -989,14 +883,11 @@ void ChangeNamespaceTool::onEndOfTranslationUnit() {
     // Add replacements referring to the changed code to existing replacements,
     // which refers to the original code.
     Replaces = Replaces.merge(NewReplacements);
-    auto Style = format::getStyle("file", FilePath, FallbackStyle);
-    if (!Style) {
-      llvm::errs() << llvm::toString(Style.takeError()) << "\n";
-      continue;
-    }
+    format::FormatStyle Style =
+        format::getStyle("file", FilePath, FallbackStyle);
     // Clean up old namespaces if there is nothing in it after moving.
     auto CleanReplacements =
-        format::cleanupAroundReplacements(Code, Replaces, *Style);
+        format::cleanupAroundReplacements(Code, Replaces, Style);
     if (!CleanReplacements) {
       llvm::errs() << llvm::toString(CleanReplacements.takeError()) << "\n";
       continue;

clang-tools-extra/change-namespace/ChangeNamespace.h

@@ -50,7 +50,6 @@ public:
   // files matching `FilePattern`.
   ChangeNamespaceTool(
       llvm::StringRef OldNs, llvm::StringRef NewNs, llvm::StringRef FilePattern,
-      llvm::ArrayRef<std::string> WhiteListedSymbolPatterns,
       std::map<std::string, tooling::Replacements> *FileToReplacements,
       llvm::StringRef FallbackStyle = "LLVM");
 
@@ -165,9 +164,6 @@ private:
   // CallExpr and one as DeclRefExpr), we record all DeclRefExpr's that have
   // been processed so that we don't handle them twice.
   llvm::SmallPtrSet<const clang::DeclRefExpr*, 16> ProcessedFuncRefs;
-  // Patterns of symbol names whose references are not expected to be updated
-  // when changing namespaces around them.
-  std::vector<llvm::Regex> WhiteListedSymbolRegexes;
 };
 
 } // namespace change_namespace

clang-tools-extra/change-namespace/tool/CMakeLists.txt

@@ -8,7 +8,6 @@ add_clang_executable(clang-change-namespace
   ClangChangeNamespace.cpp
   )
 target_link_libraries(clang-change-namespace
-  PRIVATE
   clangAST
   clangASTMatchers
   clangBasic

clang-tools-extra/change-namespace/tool/ClangChangeNamespace.cpp

@@ -39,7 +39,6 @@
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Signals.h"
-#include "llvm/Support/YAMLTraits.h"
 
 using namespace clang;
 using namespace llvm;
@@ -64,38 +63,10 @@ cl::opt<std::string> FilePattern(
 cl::opt<bool> Inplace("i", cl::desc("Inplace edit <file>s, if specified."),
                       cl::cat(ChangeNamespaceCategory));
 
-cl::opt<bool>
-    DumpYAML("dump_result",
-         cl::desc("Dump new file contents in YAML, if specified."),
-         cl::cat(ChangeNamespaceCategory));
-
 cl::opt<std::string> Style("style",
                            cl::desc("The style name used for reformatting."),
                            cl::init("LLVM"), cl::cat(ChangeNamespaceCategory));
 
-cl::opt<std::string> WhiteListFile(
-    "whitelist_file",
-    cl::desc("A file containing regexes of symbol names that are not expected "
-             "to be updated when changing namespaces around them."),
-    cl::init(""), cl::cat(ChangeNamespaceCategory));
-
-llvm::ErrorOr<std::vector<std::string>> GetWhiteListedSymbolPatterns() {
-  std::vector<std::string> Patterns;
-  if (WhiteListFile.empty())
-    return Patterns;
-
-  llvm::SmallVector<StringRef, 8> Lines;
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> File =
-      llvm::MemoryBuffer::getFile(WhiteListFile);
-  if (!File)
-    return File.getError();
-  llvm::StringRef Content = File.get()->getBuffer();
-  Content.split(Lines, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
-  for (auto Line : Lines)
-    Patterns.push_back(Line.trim());
-  return Patterns;
-}
-
 } // anonymous namespace
 
 int main(int argc, const char **argv) {
@@ -104,16 +75,8 @@ int main(int argc, const char **argv) {
                                              ChangeNamespaceCategory);
   const auto &Files = OptionsParser.getSourcePathList();
   tooling::RefactoringTool Tool(OptionsParser.getCompilations(), Files);
-  llvm::ErrorOr<std::vector<std::string>> WhiteListPatterns =
-      GetWhiteListedSymbolPatterns();
-  if (!WhiteListPatterns) {
-    llvm::errs() << "Failed to open whitelist file " << WhiteListFile << ". "
-                 << WhiteListPatterns.getError().message() << "\n";
-    return 1;
-  }
   change_namespace::ChangeNamespaceTool NamespaceTool(
-      OldNamespace, NewNamespace, FilePattern, *WhiteListPatterns,
-      &Tool.getReplacements(), Style);
+      OldNamespace, NewNamespace, FilePattern, &Tool.getReplacements(), Style);
   ast_matchers::MatchFinder Finder;
   NamespaceTool.registerMatchers(&Finder);
   std::unique_ptr<tooling::FrontendActionFactory> Factory =
@@ -138,41 +101,14 @@ int main(int argc, const char **argv) {
   if (Inplace)
     return Rewrite.overwriteChangedFiles();
 
-  std::set<llvm::StringRef> ChangedFiles;
-  for (const auto &it : Tool.getReplacements())
-    ChangedFiles.insert(it.first);
-
-  if (DumpYAML) {
-    auto WriteToYAML = [&](llvm::raw_ostream &OS) {
-      OS << "[\n";
-      for (auto I = ChangedFiles.begin(), E = ChangedFiles.end(); I != E; ++I) {
-        OS << "  {\n";
-        OS << "    \"FilePath\": \"" << *I << "\",\n";
-        const auto *Entry = FileMgr.getFile(*I);
-        auto ID = Sources.getOrCreateFileID(Entry, SrcMgr::C_User);
-        std::string Content;
-        llvm::raw_string_ostream ContentStream(Content);
-        Rewrite.getEditBuffer(ID).write(ContentStream);
-        OS << "    \"SourceText\": \""
-           << llvm::yaml::escape(ContentStream.str()) << "\"\n";
-        OS << "  }";
-        if (I != std::prev(E))
-          OS << ",\n";
-      }
-      OS << "\n]\n";
-    };
-    WriteToYAML(llvm::outs());
-    return 0;
-  }
-
-  for (const auto &File : ChangedFiles) {
+  for (const auto &File : Files) {
     const auto *Entry = FileMgr.getFile(File);
 
     auto ID = Sources.getOrCreateFileID(Entry, SrcMgr::C_User);
+    // FIXME: print results in parsable format, e.g. JSON.
     outs() << "============== " << File << " ==============\n";
     Rewrite.getEditBuffer(ID).write(llvm::outs());
     outs() << "\n============================================\n";
   }
-
   return 0;
 }

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

@@ -288,12 +288,13 @@ bool mergeAndDeduplicate(const TUReplacements &TUs,
     for (const tooling::Replacement &R : TU.Replacements) {
       // Use the file manager to deduplicate paths. FileEntries are
       // automatically canonicalized.
-      if (const FileEntry *Entry = SM.getFileManager().getFile(R.getFilePath())) {
-        GroupedReplacements[Entry].push_back(R);
-      } else if (Warned.insert(R.getFilePath()).second) {
-          errs() << "Described file '" << R.getFilePath()
-                 << "' doesn't exist. Ignoring...\n";
+      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);
     }
   }
 
@@ -313,12 +314,13 @@ bool mergeAndDeduplicate(const TUDiagnostics &TUs,
         for (const tooling::Replacement &R : Fix.second) {
           // Use the file manager to deduplicate paths. FileEntries are
           // automatically canonicalized.
-          if (const FileEntry *Entry = SM.getFileManager().getFile(R.getFilePath())) {
-            GroupedReplacements[Entry].push_back(R);
-          } else if (Warned.insert(R.getFilePath()).second) {
-              errs() << "Described file '" << R.getFilePath()
-                     << "' doesn't exist. Ignoring...\n";
+          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);
         }
       }
     }

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

@@ -6,7 +6,6 @@ add_clang_executable(clang-apply-replacements
   ClangApplyReplacementsMain.cpp
   )
 target_link_libraries(clang-apply-replacements
-  PRIVATE
   clangApplyReplacements
   clangBasic
   clangFormat

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

@@ -82,8 +82,8 @@ private:
 };
 } // namespace
 
-static void printVersion(raw_ostream &OS) {
-  OS << "clang-apply-replacements version " CLANG_VERSION_STRING << "\n";
+static void printVersion() {
+  outs() << "clang-apply-replacements version " CLANG_VERSION_STRING << "\n";
 }
 
 /// \brief Convenience function to get rewritten content for \c Filename from
@@ -199,7 +199,7 @@ applyFormatting(const std::vector<tooling::Replacement> &Replacements,
 int main(int argc, char **argv) {
   cl::HideUnrelatedOptions(makeArrayRef(VisibleCategories));
 
-  cl::SetVersionPrinter(printVersion);
+  cl::SetVersionPrinter(&printVersion);
   cl::ParseCommandLineOptions(argc, argv);
 
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions());
@@ -208,15 +208,8 @@ int main(int argc, char **argv) {
 
   // Determine a formatting style from options.
   format::FormatStyle FormatStyle;
-  if (DoFormat) {
-    auto FormatStyleOrError =
-        format::getStyle(FormatStyleOpt, FormatStyleConfig, "LLVM");
-    if (!FormatStyleOrError) {
-      llvm::errs() << llvm::toString(FormatStyleOrError.takeError()) << "\n";
-      return 1;
-    }
-    FormatStyle = *FormatStyleOrError;
-  }
+  if (DoFormat)
+    FormatStyle = format::getStyle(FormatStyleOpt, FormatStyleConfig, "LLVM");
 
   TUReplacements TURs;
   TUReplacementFiles TUFiles;

clang-tools-extra/clang-move/ClangMove.cpp

@@ -31,8 +31,6 @@ namespace {
 // FIXME: Move to ASTMatchers.
 AST_MATCHER(VarDecl, isStaticDataMember) { return Node.isStaticDataMember(); }
 
-AST_MATCHER(NamedDecl, notInMacro) { return !Node.getLocation().isMacroID(); }
-
 AST_MATCHER_P(Decl, hasOutermostEnclosingClass,
               ast_matchers::internal::Matcher<Decl>, InnerMatcher) {
   const auto *Context = Node.getDeclContext();
@@ -168,21 +166,6 @@ private:
   ClangMoveTool *MoveTool;
 };
 
-class VarDeclarationMatch : public MatchFinder::MatchCallback {
-public:
-  explicit VarDeclarationMatch(ClangMoveTool *MoveTool)
-      : MoveTool(MoveTool) {}
-
-  void run(const MatchFinder::MatchResult &Result) override {
-    const auto *VD = Result.Nodes.getNodeAs<clang::VarDecl>("var");
-    assert(VD);
-    MoveDeclFromOldFileToNewFile(MoveTool, VD);
-  }
-
-private:
-  ClangMoveTool *MoveTool;
-};
-
 class TypeAliasMatch : public MatchFinder::MatchCallback {
 public:
   explicit TypeAliasMatch(ClangMoveTool *MoveTool)
@@ -504,11 +487,8 @@ void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
       isExpansionInFile(makeAbsolutePath(Context->Spec.OldHeader));
   auto InOldCC = isExpansionInFile(makeAbsolutePath(Context->Spec.OldCC));
   auto InOldFiles = anyOf(InOldHeader, InOldCC);
-  auto classTemplateForwardDecls =
-      classTemplateDecl(unless(has(cxxRecordDecl(isDefinition()))));
-  auto ForwardClassDecls = namedDecl(
-      anyOf(cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition()))),
-            classTemplateForwardDecls));
+  auto ForwardDecls =
+      cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition())));
   auto TopLevelDecl =
       hasDeclContext(anyOf(namespaceDecl(), translationUnitDecl()));
 
@@ -521,8 +501,9 @@ void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
   // We consider declarations inside a class belongs to the class. So these
   // declarations will be ignored.
   auto AllDeclsInHeader = namedDecl(
-      unless(ForwardClassDecls), unless(namespaceDecl()),
-      unless(usingDirectiveDecl()), // using namespace decl.
+      unless(ForwardDecls), unless(namespaceDecl()),
+      unless(usingDirectiveDecl()),                 // using namespace decl.
+      unless(classTemplateDecl(has(ForwardDecls))), // template forward decl.
       InOldHeader,
       hasParent(decl(anyOf(namespaceDecl(), translationUnitDecl()))),
       hasDeclContext(decl(anyOf(namespaceDecl(), translationUnitDecl()))));
@@ -533,7 +514,7 @@ void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
     return;
 
   // Match forward declarations in old header.
-  Finder->addMatcher(namedDecl(ForwardClassDecls, InOldHeader).bind("fwd_decl"),
+  Finder->addMatcher(namedDecl(ForwardDecls, InOldHeader).bind("fwd_decl"),
                      this);
 
   //============================================================================
@@ -544,12 +525,12 @@ void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
   // Matching using decls/type alias decls which are in named/anonymous/global
   // namespace, these decls are always copied to new.h/cc. Those in classes,
   // functions are covered in other matchers.
-  Finder->addMatcher(namedDecl(anyOf(usingDecl(IsOldCCTopLevelDecl),
-                                     usingDirectiveDecl(IsOldCCTopLevelDecl),
-                                     typeAliasDecl(IsOldCCTopLevelDecl)),
-                               notInMacro())
-                         .bind("using_decl"),
-                     this);
+  Finder->addMatcher(
+      namedDecl(anyOf(usingDecl(IsOldCCTopLevelDecl),
+                      usingDirectiveDecl(IsOldCCTopLevelDecl),
+                      typeAliasDecl(IsOldCCTopLevelDecl)))
+          .bind("using_decl"),
+      this);
 
   // Match static functions/variable definitions which are defined in named
   // namespaces.
@@ -570,22 +551,14 @@ void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
 
   // Matchers for helper declarations in old.cc.
   auto InAnonymousNS = hasParent(namespaceDecl(isAnonymous()));
-  auto NotInMovedClass= allOf(unless(InMovedClass), InOldCC);
-  auto IsOldCCHelper =
-      allOf(NotInMovedClass, anyOf(isStaticStorageClass(), InAnonymousNS));
+  auto DefinitionInOldCC = allOf(isDefinition(), unless(InMovedClass), InOldCC);
+  auto IsOldCCHelperDefinition =
+      allOf(DefinitionInOldCC, anyOf(isStaticStorageClass(), InAnonymousNS));
   // Match helper classes separately with helper functions/variables since we
   // want to reuse these matchers in finding helpers usage below.
-  //
-  // There could be forward declarations usage for helpers, especially for
-  // classes and functions. We need include these forward declarations.
-  //
-  // Forward declarations for variable helpers will be excluded as these
-  // declarations (with "extern") are not supposed in cpp file.
-   auto HelperFuncOrVar =
-      namedDecl(notInMacro(), anyOf(functionDecl(IsOldCCHelper),
-                                    varDecl(isDefinition(), IsOldCCHelper)));
-  auto HelperClasses =
-      cxxRecordDecl(notInMacro(), NotInMovedClass, InAnonymousNS);
+  auto HelperFuncOrVar = namedDecl(anyOf(functionDecl(IsOldCCHelperDefinition),
+                                         varDecl(IsOldCCHelperDefinition)));
+  auto HelperClasses = cxxRecordDecl(DefinitionInOldCC, InAnonymousNS);
   // Save all helper declarations in old.cc.
   Finder->addMatcher(
       namedDecl(anyOf(HelperFuncOrVar, HelperClasses)).bind("helper_decls"),
@@ -635,11 +608,6 @@ void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
                          .bind("function"),
                      MatchCallbacks.back().get());
 
-  MatchCallbacks.push_back(llvm::make_unique<VarDeclarationMatch>(this));
-  Finder->addMatcher(
-      varDecl(InOldFiles, *HasAnySymbolNames, TopLevelDecl).bind("var"),
-      MatchCallbacks.back().get());
-
   // Match enum definition in old.h. Enum helpers (which are defined in old.cc)
   // will not be moved for now no matter whether they are used or not.
   MatchCallbacks.push_back(llvm::make_unique<EnumDeclarationMatch>(this));
@@ -671,12 +639,13 @@ void ClangMoveTool::run(const ast_matchers::MatchFinder::MatchResult &Result) {
       else
         MovedDecls.push_back(FWD);
     }
+  } else if (const auto *ND =
+                 Result.Nodes.getNodeAs<clang::NamedDecl>("static_decls")) {
+    MovedDecls.push_back(ND);
   } else if (const auto *ND =
                  Result.Nodes.getNodeAs<clang::NamedDecl>("helper_decls")) {
     MovedDecls.push_back(ND);
     HelperDeclarations.push_back(ND);
-    DEBUG(llvm::dbgs() << "Add helper : "
-                       << ND->getNameAsString() << " (" << ND << ")\n");
   } else if (const auto *UD =
                  Result.Nodes.getNodeAs<clang::NamedDecl>("using_decl")) {
     MovedDecls.push_back(UD);
@@ -730,12 +699,9 @@ void ClangMoveTool::removeDeclsInOldFiles() {
     // We remove the helper declarations which are not used in the old.cc after
     // moving the given declarations.
     for (const auto *D : HelperDeclarations) {
-      DEBUG(llvm::dbgs() << "Check helper is used: "
-                         << D->getNameAsString() << " (" << D << ")\n");
-      if (!UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(
-              D->getCanonicalDecl()))) {
+      if (!UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(D))) {
         DEBUG(llvm::dbgs() << "Helper removed in old.cc: "
-                           << D->getNameAsString() << " (" << D << ")\n");
+                           << D->getNameAsString() << " " << D << "\n");
         RemovedDecls.push_back(D);
       }
     }
@@ -776,13 +742,10 @@ void ClangMoveTool::removeDeclsInOldFiles() {
     // Ignore replacements for new.h/cc.
     if (SI == FilePathToFileID.end()) continue;
     llvm::StringRef Code = SM.getBufferData(SI->second);
-    auto Style = format::getStyle("file", FilePath, Context->FallbackStyle);
-    if (!Style) {
-      llvm::errs() << llvm::toString(Style.takeError()) << "\n";
-      continue;
-    }
+    format::FormatStyle Style =
+        format::getStyle("file", FilePath, Context->FallbackStyle);
     auto CleanReplacements = format::cleanupAroundReplacements(
-        Code, Context->FileToReplacements[FilePath], *Style);
+        Code, Context->FileToReplacements[FilePath], Style);
 
     if (!CleanReplacements) {
       llvm::errs() << llvm::toString(CleanReplacements.takeError()) << "\n";
@@ -811,8 +774,7 @@ void ClangMoveTool::moveDeclsToNewFiles() {
   // given symbols being moved.
   for (const auto *D : NewCCDecls) {
     if (llvm::is_contained(HelperDeclarations, D) &&
-        !UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(
-            D->getCanonicalDecl())))
+        !UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(D)))
       continue;
 
     DEBUG(llvm::dbgs() << "Helper used in new.cc: " << D->getNameAsString()
@@ -874,20 +836,11 @@ void ClangMoveTool::onEndOfTranslationUnit() {
     for (const auto *Decl : UnremovedDeclsInOldHeader) {
       auto Kind = Decl->getKind();
       const std::string QualifiedName = Decl->getQualifiedNameAsString();
-      if (Kind == Decl::Kind::Var)
-        Reporter->reportDeclaration(QualifiedName, "Variable");
-      else if (Kind == Decl::Kind::Function ||
-               Kind == Decl::Kind::FunctionTemplate)
+      if (Kind == Decl::Kind::Function || Kind == Decl::Kind::FunctionTemplate)
         Reporter->reportDeclaration(QualifiedName, "Function");
       else if (Kind == Decl::Kind::ClassTemplate ||
                Kind == Decl::Kind::CXXRecord)
         Reporter->reportDeclaration(QualifiedName, "Class");
-      else if (Kind == Decl::Kind::Enum)
-        Reporter->reportDeclaration(QualifiedName, "Enum");
-      else if (Kind == Decl::Kind::Typedef ||
-               Kind == Decl::Kind::TypeAlias ||
-               Kind == Decl::Kind::TypeAliasTemplate)
-        Reporter->reportDeclaration(QualifiedName, "TypeAlias");
     }
     return;
   }
@@ -908,7 +861,6 @@ void ClangMoveTool::onEndOfTranslationUnit() {
     case Decl::Kind::Typedef:
     case Decl::Kind::TypeAlias:
     case Decl::Kind::TypeAliasTemplate:
-    case Decl::Kind::Var:
       return true;
     default:
       return false;

clang-tools-extra/clang-move/HelperDeclRefGraph.cpp

@@ -10,11 +10,8 @@
 #include "HelperDeclRefGraph.h"
 #include "ClangMove.h"
 #include "clang/AST/Decl.h"
-#include "llvm/Support/Debug.h"
 #include <vector>
 
-#define DEBUG_TYPE "clang-move"
-
 namespace clang {
 namespace move {
 
@@ -116,19 +113,13 @@ void HelperDeclRGBuilder::run(
   if (const auto *FuncRef = Result.Nodes.getNodeAs<DeclRefExpr>("func_ref")) {
     const auto *DC = Result.Nodes.getNodeAs<Decl>("dc");
     assert(DC);
-    DEBUG(llvm::dbgs() << "Find helper function usage: "
-                       << FuncRef->getDecl()->getNameAsString() << " ("
-                       << FuncRef->getDecl() << ")\n");
-    RG->addEdge(
-        getOutmostClassOrFunDecl(DC->getCanonicalDecl()),
-        getOutmostClassOrFunDecl(FuncRef->getDecl()->getCanonicalDecl()));
+
+    RG->addEdge(getOutmostClassOrFunDecl(DC->getCanonicalDecl()),
+                getOutmostClassOrFunDecl(FuncRef->getDecl()));
   } else if (const auto *UsedClass =
                  Result.Nodes.getNodeAs<CXXRecordDecl>("used_class")) {
     const auto *DC = Result.Nodes.getNodeAs<Decl>("dc");
     assert(DC);
-    DEBUG(llvm::dbgs() << "Find helper class usage: "
-                       << UsedClass->getNameAsString() << " (" << UsedClass
-                       << ")\n");
     RG->addEdge(getOutmostClassOrFunDecl(DC->getCanonicalDecl()), UsedClass);
   }
 }

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

@@ -5,7 +5,6 @@ add_clang_executable(clang-move
   )
 
 target_link_libraries(clang-move
-  PRIVATE
   clangAST
   clangASTMatchers
   clangBasic

clang-tools-extra/clang-move/tool/ClangMoveMain.cpp

@@ -127,9 +127,10 @@ int main(int argc, const char **argv) {
   move::ClangMoveContext Context{Spec, Tool.getReplacements(),
                                  InitialDirectory.str(), Style, DumpDecls};
   move::DeclarationReporter Reporter;
-  move::ClangMoveActionFactory Factory(&Context, &Reporter);
-  
-  int CodeStatus = Tool.run(&Factory);
+  auto Factory = llvm::make_unique<clang::move::ClangMoveActionFactory>(
+      &Context, &Reporter);
+
+  int CodeStatus = Tool.run(Factory.get());
   if (CodeStatus)
     return CodeStatus;
 

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

@@ -97,10 +97,10 @@ bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
           if (R.isValid()) {
             TextDiagnostic TD(OS, AST->getASTContext().getLangOpts(),
                               &AST->getDiagnostics().getDiagnosticOptions());
-            TD.emitDiagnostic(
-                FullSourceLoc(R.getBegin(), AST->getSourceManager()),
-                DiagnosticsEngine::Note, "\"" + BI->first + "\" binds here",
-                CharSourceRange::getTokenRange(R), None);
+            TD.emitDiagnostic(R.getBegin(), DiagnosticsEngine::Note,
+                              "\"" + BI->first + "\" binds here",
+                              CharSourceRange::getTokenRange(R), None,
+                              &AST->getSourceManager());
           }
           break;
         }

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

@@ -2,7 +2,6 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
 
 add_clang_executable(clang-query ClangQuery.cpp)
 target_link_libraries(clang-query
-  PRIVATE
   clangAST
   clangASTMatchers
   clangBasic

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

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

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

@@ -0,0 +1,93 @@
+//===--- 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 <string>
+#include <vector>
+
+using namespace llvm;
+
+namespace clang {
+namespace rename {
+
+class RenamingASTConsumer : public ASTConsumer {
+public:
+  RenamingASTConsumer(
+      const std::vector<std::string> &NewNames,
+      const std::vector<std::string> &PrevNames,
+      const std::vector<std::vector<std::string>> &USRList,
+      std::map<std::string, tooling::Replacements> &FileToReplaces,
+      bool PrintLocations)
+      : NewNames(NewNames), PrevNames(PrevNames), USRList(USRList),
+        FileToReplaces(FileToReplaces), PrintLocations(PrintLocations) {}
+
+  void HandleTranslationUnit(ASTContext &Context) override {
+    for (unsigned I = 0; I < NewNames.size(); ++I)
+      HandleOneRename(Context, NewNames[I], PrevNames[I], USRList[I]);
+  }
+
+  void HandleOneRename(ASTContext &Context, const std::string &NewName,
+                       const std::string &PrevName,
+                       const std::vector<std::string> &USRs) {
+    const SourceManager &SourceMgr = Context.getSourceManager();
+    std::vector<SourceLocation> RenamingCandidates;
+    std::vector<SourceLocation> NewCandidates;
+
+    NewCandidates =
+        getLocationsOfUSRs(USRs, PrevName, Context.getTranslationUnitDecl());
+    RenamingCandidates.insert(RenamingCandidates.end(), NewCandidates.begin(),
+                              NewCandidates.end());
+
+    unsigned PrevNameLen = PrevName.length();
+    for (const auto &Loc : RenamingCandidates) {
+      if (PrintLocations) {
+        FullSourceLoc FullLoc(Loc, SourceMgr);
+        errs() << "clang-rename: renamed at: " << SourceMgr.getFilename(Loc)
+               << ":" << FullLoc.getSpellingLineNumber() << ":"
+               << FullLoc.getSpellingColumnNumber() << "\n";
+      }
+      // FIXME: better error handling.
+      tooling::Replacement Replace(SourceMgr, Loc, PrevNameLen, NewName);
+      llvm::Error Err = FileToReplaces[Replace.getFilePath()].add(Replace);
+      if (Err)
+        llvm::errs() << "Renaming failed in " << Replace.getFilePath() << "! "
+                     << llvm::toString(std::move(Err)) << "\n";
+    }
+  }
+
+private:
+  const std::vector<std::string> &NewNames, &PrevNames;
+  const std::vector<std::vector<std::string>> &USRList;
+  std::map<std::string, tooling::Replacements> &FileToReplaces;
+  bool PrintLocations;
+};
+
+std::unique_ptr<ASTConsumer> RenamingAction::newASTConsumer() {
+  return llvm::make_unique<RenamingASTConsumer>(NewNames, PrevNames, USRList,
+                                                FileToReplaces, PrintLocations);
+}
+
+} // namespace rename
+} // namespace clang

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

@@ -0,0 +1,48 @@
+//===--- 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::vector<std::string> &NewNames,
+                 const std::vector<std::string> &PrevNames,
+                 const std::vector<std::vector<std::string>> &USRList,
+                 std::map<std::string, tooling::Replacements> &FileToReplaces,
+                 bool PrintLocations = false)
+      : NewNames(NewNames), PrevNames(PrevNames), USRList(USRList),
+        FileToReplaces(FileToReplaces), PrintLocations(PrintLocations) {}
+
+  std::unique_ptr<ASTConsumer> newASTConsumer();
+
+private:
+  const std::vector<std::string> &NewNames, &PrevNames;
+  const std::vector<std::vector<std::string>> &USRList;
+  std::map<std::string, tooling::Replacements> &FileToReplaces;
+  bool PrintLocations;
+};
+
+} // namespace rename
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H

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

@@ -0,0 +1,212 @@
+//===--- 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 SourceLocation Point,
+                                      const ASTContext &Context)
+      : Result(nullptr), Point(Point), Context(Context) {}
+
+  // \brief Finds the NamedDecl for a name in the source.
+  // \param Name the fully qualified name.
+  explicit NamedDeclFindingASTVisitor(const std::string &Name,
+                                      const ASTContext &Context)
+      : Result(nullptr), Name(Name), Context(Context) {}
+
+  // 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 dyn_cast<CXXConversionDecl>(Decl)
+               ? true
+               : setResult(Decl, Decl->getLocation(),
+                           Decl->getNameAsString().length());
+  }
+
+  // Expression visitors:
+
+  bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
+    const NamedDecl *Decl = Expr->getFoundDecl();
+    return setResult(Decl, Expr->getLocation(),
+                     Decl->getNameAsString().length());
+  }
+
+  bool VisitMemberExpr(const MemberExpr *Expr) {
+    const NamedDecl *Decl = Expr->getFoundDecl().getDecl();
+    return setResult(Decl, Expr->getMemberLoc(),
+                     Decl->getNameAsString().length());
+  }
+
+  // Other visitors:
+
+  bool VisitTypeLoc(const TypeLoc Loc) {
+    const SourceLocation TypeBeginLoc = Loc.getBeginLoc();
+    const SourceLocation TypeEndLoc = Lexer::getLocForEndOfToken(
+        TypeBeginLoc, 0, Context.getSourceManager(), Context.getLangOpts());
+    if (const auto *TemplateTypeParm =
+            dyn_cast<TemplateTypeParmType>(Loc.getType()))
+      return setResult(TemplateTypeParm->getDecl(), TypeBeginLoc, TypeEndLoc);
+    if (const auto *TemplateSpecType =
+            dyn_cast<TemplateSpecializationType>(Loc.getType())) {
+      return setResult(TemplateSpecType->getTemplateName().getAsTemplateDecl(),
+                       TypeBeginLoc, TypeEndLoc);
+    }
+    return setResult(Loc.getType()->getAsCXXRecordDecl(), TypeBeginLoc,
+                     TypeEndLoc);
+  }
+
+  bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *ConstructorDecl) {
+    for (const auto *Initializer : ConstructorDecl->inits()) {
+      // Ignore implicit initializers.
+      if (!Initializer->isWritten())
+        continue;
+      if (const clang::FieldDecl *FieldDecl = Initializer->getMember()) {
+        const SourceLocation InitBeginLoc = Initializer->getSourceLocation(),
+                             InitEndLoc = Lexer::getLocForEndOfToken(
+                                 InitBeginLoc, 0, Context.getSourceManager(),
+                                 Context.getLangOpts());
+        if (!setResult(FieldDecl, InitBeginLoc, InitEndLoc))
+          return false;
+      }
+    }
+    return true;
+  }
+
+  // Other:
+
+  const NamedDecl *getNamedDecl() { return Result; }
+
+  // \brief Determines if a namespace qualifier contains the point.
+  // \returns false on success and sets Result.
+  void handleNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
+    while (NameLoc) {
+      const NamespaceDecl *Decl =
+          NameLoc.getNestedNameSpecifier()->getAsNamespace();
+      setResult(Decl, NameLoc.getLocalBeginLoc(), NameLoc.getLocalEndLoc());
+      NameLoc = NameLoc.getPrefix();
+    }
+  }
+
+private:
+  // \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 (!Decl)
+      return true;
+    if (Name.empty()) {
+      // Offset is used to find the declaration.
+      if (!Start.isValid() || !Start.isFileID() || !End.isValid() ||
+          !End.isFileID() || !isPointWithin(Start, End))
+        return true;
+    } else {
+      // Fully qualified name is used to find the declaration.
+      if (Name != Decl->getQualifiedNameAsString())
+        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 ||
+           (Context.getSourceManager().isBeforeInTranslationUnit(Start,
+                                                                 Point) &&
+            Context.getSourceManager().isBeforeInTranslationUnit(Point, End));
+  }
+
+  const NamedDecl *Result;
+  const SourceLocation Point; // The location to find the NamedDecl.
+  const std::string Name;
+  const ASTContext &Context;
+};
+} // namespace
+
+const NamedDecl *getNamedDeclAt(const ASTContext &Context,
+                                const SourceLocation Point) {
+  const SourceManager &SM = Context.getSourceManager();
+  NamedDeclFindingASTVisitor Visitor(Point, Context);
+
+  // Try to be clever about pruning down the number of top-level declarations we
+  // see. If both start and end is either before or after the point we're
+  // looking for the point cannot be inside of this decl. Don't even look at it.
+  for (auto *CurrDecl : Context.getTranslationUnitDecl()->decls()) {
+    SourceLocation StartLoc = CurrDecl->getLocStart();
+    SourceLocation EndLoc = CurrDecl->getLocEnd();
+    if (StartLoc.isValid() && EndLoc.isValid() &&
+        SM.isBeforeInTranslationUnit(StartLoc, Point) !=
+            SM.isBeforeInTranslationUnit(EndLoc, Point))
+      Visitor.TraverseDecl(CurrDecl);
+  }
+
+  NestedNameSpecifierLocFinder Finder(const_cast<ASTContext &>(Context));
+  for (const auto &Location : Finder.getNestedNameSpecifierLocations())
+    Visitor.handleNestedNameSpecifierLoc(Location);
+
+  return Visitor.getNamedDecl();
+}
+
+const NamedDecl *getNamedDeclFor(const ASTContext &Context,
+                                 const std::string &Name) {
+  NamedDeclFindingASTVisitor Visitor(Name, Context);
+  Visitor.TraverseDecl(Context.getTranslationUnitDecl());
+
+  return Visitor.getNamedDecl();
+}
+
+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 rename
+} // namespace clang

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

@@ -0,0 +1,84 @@
+//===--- 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 "clang/AST/AST.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include <string>
+#include <vector>
+
+using namespace llvm;
+using namespace clang::ast_matchers;
+
+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);
+
+// Given an AST context and a fully qualified name, returns a NamedDecl
+// identifying the symbol with a matching name. Returns null if nothing is
+// found for the name.
+const NamedDecl *getNamedDeclFor(const ASTContext &Context,
+                                 const std::string &Name);
+
+// Converts a Decl into a USR.
+std::string getUSRForDecl(const Decl *Decl);
+
+// FIXME: Implement RecursiveASTVisitor<T>::VisitNestedNameSpecifier instead.
+class NestedNameSpecifierLocFinder : public MatchFinder::MatchCallback {
+public:
+  explicit NestedNameSpecifierLocFinder(ASTContext &Context)
+      : Context(Context) {}
+
+  std::vector<NestedNameSpecifierLoc> getNestedNameSpecifierLocations() {
+    addMatchers();
+    Finder.matchAST(Context);
+    return Locations;
+  }
+
+private:
+  void addMatchers() {
+    const auto NestedNameSpecifierLocMatcher =
+        nestedNameSpecifierLoc().bind("nestedNameSpecifierLoc");
+    Finder.addMatcher(NestedNameSpecifierLocMatcher, this);
+  }
+
+  void run(const MatchFinder::MatchResult &Result) override {
+    const auto *NNS = Result.Nodes.getNodeAs<NestedNameSpecifierLoc>(
+        "nestedNameSpecifierLoc");
+    Locations.push_back(*NNS);
+  }
+
+  ASTContext &Context;
+  std::vector<NestedNameSpecifierLoc> Locations;
+  MatchFinder Finder;
+};
+
+} // namespace rename
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDER_H

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

@@ -0,0 +1,226 @@
+//===--- 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 find USR for the symbol at <offset>, as well as
+/// all additional USRs.
+///
+//===----------------------------------------------------------------------===//
+
+#include "USRFindingAction.h"
+#include "USRFinder.h"
+#include "clang/AST/AST.h"
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/RecursiveASTVisitor.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 <algorithm>
+#include <set>
+#include <string>
+#include <vector>
+
+using namespace llvm;
+
+namespace clang {
+namespace rename {
+
+namespace {
+// \brief NamedDeclFindingConsumer should delegate finding USRs of given Decl to
+// AdditionalUSRFinder. AdditionalUSRFinder adds USRs of ctor and dtor if given
+// Decl refers to class and adds USRs of all overridden methods if Decl refers
+// to virtual method.
+class AdditionalUSRFinder : public RecursiveASTVisitor<AdditionalUSRFinder> {
+public:
+  AdditionalUSRFinder(const Decl *FoundDecl, ASTContext &Context)
+      : FoundDecl(FoundDecl), Context(Context) {}
+
+  std::vector<std::string> Find() {
+    // Fill OverriddenMethods and PartialSpecs storages.
+    TraverseDecl(Context.getTranslationUnitDecl());
+    if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(FoundDecl)) {
+      addUSRsOfOverridenFunctions(MethodDecl);
+      for (const auto &OverriddenMethod : OverriddenMethods) {
+        if (checkIfOverriddenFunctionAscends(OverriddenMethod))
+          USRSet.insert(getUSRForDecl(OverriddenMethod));
+      }
+    } else if (const auto *RecordDecl = dyn_cast<CXXRecordDecl>(FoundDecl)) {
+      handleCXXRecordDecl(RecordDecl);
+    } else if (const auto *TemplateDecl =
+                   dyn_cast<ClassTemplateDecl>(FoundDecl)) {
+      handleClassTemplateDecl(TemplateDecl);
+    } else {
+      USRSet.insert(getUSRForDecl(FoundDecl));
+    }
+    return std::vector<std::string>(USRSet.begin(), USRSet.end());
+  }
+
+  bool VisitCXXMethodDecl(const CXXMethodDecl *MethodDecl) {
+    if (MethodDecl->isVirtual())
+      OverriddenMethods.push_back(MethodDecl);
+    return true;
+  }
+
+  bool VisitClassTemplatePartialSpecializationDecl(
+      const ClassTemplatePartialSpecializationDecl *PartialSpec) {
+    PartialSpecs.push_back(PartialSpec);
+    return true;
+  }
+
+private:
+  void handleCXXRecordDecl(const CXXRecordDecl *RecordDecl) {
+    RecordDecl = RecordDecl->getDefinition();
+    if (const auto *ClassTemplateSpecDecl =
+            dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl))
+      handleClassTemplateDecl(ClassTemplateSpecDecl->getSpecializedTemplate());
+    addUSRsOfCtorDtors(RecordDecl);
+  }
+
+  void handleClassTemplateDecl(const ClassTemplateDecl *TemplateDecl) {
+    for (const auto *Specialization : TemplateDecl->specializations())
+      addUSRsOfCtorDtors(Specialization);
+
+    for (const auto *PartialSpec : PartialSpecs) {
+      if (PartialSpec->getSpecializedTemplate() == TemplateDecl)
+        addUSRsOfCtorDtors(PartialSpec);
+    }
+    addUSRsOfCtorDtors(TemplateDecl->getTemplatedDecl());
+  }
+
+  void addUSRsOfCtorDtors(const CXXRecordDecl *RecordDecl) {
+    RecordDecl = RecordDecl->getDefinition();
+
+    for (const auto *CtorDecl : RecordDecl->ctors())
+      USRSet.insert(getUSRForDecl(CtorDecl));
+
+    USRSet.insert(getUSRForDecl(RecordDecl->getDestructor()));
+    USRSet.insert(getUSRForDecl(RecordDecl));
+  }
+
+  void addUSRsOfOverridenFunctions(const CXXMethodDecl *MethodDecl) {
+    USRSet.insert(getUSRForDecl(MethodDecl));
+    // Recursively visit each OverridenMethod.
+    for (const auto &OverriddenMethod : MethodDecl->overridden_methods())
+      addUSRsOfOverridenFunctions(OverriddenMethod);
+  }
+
+  bool checkIfOverriddenFunctionAscends(const CXXMethodDecl *MethodDecl) {
+    for (const auto &OverriddenMethod : MethodDecl->overridden_methods()) {
+      if (USRSet.find(getUSRForDecl(OverriddenMethod)) != USRSet.end())
+        return true;
+      return checkIfOverriddenFunctionAscends(OverriddenMethod);
+    }
+    return false;
+  }
+
+  const Decl *FoundDecl;
+  ASTContext &Context;
+  std::set<std::string> USRSet;
+  std::vector<const CXXMethodDecl *> OverriddenMethods;
+  std::vector<const ClassTemplatePartialSpecializationDecl *> PartialSpecs;
+};
+} // namespace
+
+class NamedDeclFindingConsumer : public ASTConsumer {
+public:
+  NamedDeclFindingConsumer(ArrayRef<unsigned> SymbolOffsets,
+                           ArrayRef<std::string> QualifiedNames,
+                           std::vector<std::string> &SpellingNames,
+                           std::vector<std::vector<std::string>> &USRList,
+                           bool &ErrorOccurred)
+      : SymbolOffsets(SymbolOffsets), QualifiedNames(QualifiedNames),
+        SpellingNames(SpellingNames), USRList(USRList),
+        ErrorOccurred(ErrorOccurred) {}
+
+private:
+  bool FindSymbol(ASTContext &Context, const SourceManager &SourceMgr,
+                  unsigned SymbolOffset, const std::string &QualifiedName) {
+    DiagnosticsEngine &Engine = Context.getDiagnostics();
+    const FileID MainFileID = SourceMgr.getMainFileID();
+
+    if (SymbolOffset >= SourceMgr.getFileIDSize(MainFileID)) {
+      ErrorOccurred = true;
+      unsigned InvalidOffset = Engine.getCustomDiagID(
+          DiagnosticsEngine::Error,
+          "SourceLocation in file %0 at offset %1 is invalid");
+      Engine.Report(SourceLocation(), InvalidOffset)
+          << SourceMgr.getFileEntryForID(MainFileID)->getName() << SymbolOffset;
+      return false;
+    }
+
+    const SourceLocation Point = SourceMgr.getLocForStartOfFile(MainFileID)
+                                     .getLocWithOffset(SymbolOffset);
+    const NamedDecl *FoundDecl = QualifiedName.empty()
+                                     ? getNamedDeclAt(Context, Point)
+                                     : getNamedDeclFor(Context, QualifiedName);
+
+    if (FoundDecl == nullptr) {
+      if (QualifiedName.empty()) {
+        FullSourceLoc FullLoc(Point, SourceMgr);
+        unsigned CouldNotFindSymbolAt = Engine.getCustomDiagID(
+            DiagnosticsEngine::Error,
+            "clang-rename could not find symbol (offset %0)");
+        Engine.Report(Point, CouldNotFindSymbolAt) << SymbolOffset;
+        ErrorOccurred = true;
+        return false;
+      }
+      unsigned CouldNotFindSymbolNamed = Engine.getCustomDiagID(
+          DiagnosticsEngine::Error, "clang-rename could not find symbol %0");
+      Engine.Report(CouldNotFindSymbolNamed) << QualifiedName;
+      ErrorOccurred = true;
+      return false;
+    }
+
+    // If FoundDecl is a constructor or destructor, we want to instead take
+    // the Decl of the corresponding class.
+    if (const auto *CtorDecl = dyn_cast<CXXConstructorDecl>(FoundDecl))
+      FoundDecl = CtorDecl->getParent();
+    else if (const auto *DtorDecl = dyn_cast<CXXDestructorDecl>(FoundDecl))
+      FoundDecl = DtorDecl->getParent();
+
+    SpellingNames.push_back(FoundDecl->getNameAsString());
+    AdditionalUSRFinder Finder(FoundDecl, Context);
+    USRList.push_back(Finder.Find());
+    return true;
+  }
+
+  void HandleTranslationUnit(ASTContext &Context) override {
+    const SourceManager &SourceMgr = Context.getSourceManager();
+    for (unsigned Offset : SymbolOffsets) {
+      if (!FindSymbol(Context, SourceMgr, Offset, ""))
+        return;
+    }
+    for (const std::string &QualifiedName : QualifiedNames) {
+      if (!FindSymbol(Context, SourceMgr, 0, QualifiedName))
+        return;
+    }
+  }
+
+  ArrayRef<unsigned> SymbolOffsets;
+  ArrayRef<std::string> QualifiedNames;
+  std::vector<std::string> &SpellingNames;
+  std::vector<std::vector<std::string>> &USRList;
+  bool &ErrorOccurred;
+};
+
+std::unique_ptr<ASTConsumer> USRFindingAction::newASTConsumer() {
+  return llvm::make_unique<NamedDeclFindingConsumer>(
+      SymbolOffsets, QualifiedNames, SpellingNames, USRList, ErrorOccurred);
+}
+
+} // namespace rename
+} // namespace clang

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

@@ -0,0 +1,53 @@
+//===--- 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 relevant 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/Basic/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+
+#include <string>
+#include <vector>
+
+namespace clang {
+class ASTConsumer;
+class CompilerInstance;
+class NamedDecl;
+
+namespace rename {
+
+struct USRFindingAction {
+  USRFindingAction(ArrayRef<unsigned> SymbolOffsets,
+                   ArrayRef<std::string> QualifiedNames)
+      : SymbolOffsets(SymbolOffsets), QualifiedNames(QualifiedNames),
+        ErrorOccurred(false) {}
+  std::unique_ptr<ASTConsumer> newASTConsumer();
+
+  ArrayRef<std::string> getUSRSpellings() { return SpellingNames; }
+  ArrayRef<std::vector<std::string>> getUSRList() { return USRList; }
+  bool errorOccurred() { return ErrorOccurred; }
+
+private:
+  std::vector<unsigned> SymbolOffsets;
+  std::vector<std::string> QualifiedNames;
+  std::vector<std::string> SpellingNames;
+  std::vector<std::vector<std::string>> USRList;
+  bool ErrorOccurred;
+};
+
+} // namespace rename
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDING_ACTION_H

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

@@ -0,0 +1,167 @@
+//===--- 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/LLVM.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Lex/Lexer.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Casting.h"
+#include <cstddef>
+#include <set>
+#include <string>
+#include <vector>
+
+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::vector<std::string> &USRs,
+                                   StringRef PrevName,
+                                   const ASTContext &Context)
+      : USRSet(USRs.begin(), USRs.end()), PrevName(PrevName), Context(Context) {
+  }
+
+  // Declaration visitors:
+
+  bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *ConstructorDecl) {
+    for (const auto *Initializer : ConstructorDecl->inits()) {
+      // Ignore implicit initializers.
+      if (!Initializer->isWritten())
+        continue;
+      if (const clang::FieldDecl *FieldDecl = Initializer->getMember()) {
+        if (USRSet.find(getUSRForDecl(FieldDecl)) != USRSet.end())
+          LocationsFound.push_back(Initializer->getSourceLocation());
+      }
+    }
+    return true;
+  }
+
+  bool VisitNamedDecl(const NamedDecl *Decl) {
+    if (USRSet.find(getUSRForDecl(Decl)) != USRSet.end())
+      checkAndAddLocation(Decl->getLocation());
+    return true;
+  }
+
+  // Expression visitors:
+
+  bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
+    const NamedDecl *Decl = Expr->getFoundDecl();
+
+    if (USRSet.find(getUSRForDecl(Decl)) != USRSet.end()) {
+      const SourceManager &Manager = Decl->getASTContext().getSourceManager();
+      SourceLocation Location = Manager.getSpellingLoc(Expr->getLocation());
+      checkAndAddLocation(Location);
+    }
+
+    return true;
+  }
+
+  bool VisitMemberExpr(const MemberExpr *Expr) {
+    const NamedDecl *Decl = Expr->getFoundDecl().getDecl();
+    if (USRSet.find(getUSRForDecl(Decl)) != USRSet.end()) {
+      const SourceManager &Manager = Decl->getASTContext().getSourceManager();
+      SourceLocation Location = Manager.getSpellingLoc(Expr->getMemberLoc());
+      checkAndAddLocation(Location);
+    }
+    return true;
+  }
+
+  // Other visitors:
+
+  bool VisitTypeLoc(const TypeLoc Loc) {
+    if (USRSet.find(getUSRForDecl(Loc.getType()->getAsCXXRecordDecl())) !=
+        USRSet.end())
+      checkAndAddLocation(Loc.getBeginLoc());
+    if (const auto *TemplateTypeParm =
+            dyn_cast<TemplateTypeParmType>(Loc.getType())) {
+      if (USRSet.find(getUSRForDecl(TemplateTypeParm->getDecl())) !=
+          USRSet.end())
+        checkAndAddLocation(Loc.getBeginLoc());
+    }
+    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;
+  }
+
+  // Namespace traversal:
+  void handleNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
+    while (NameLoc) {
+      const NamespaceDecl *Decl =
+          NameLoc.getNestedNameSpecifier()->getAsNamespace();
+      if (Decl && USRSet.find(getUSRForDecl(Decl)) != USRSet.end())
+        checkAndAddLocation(NameLoc.getLocalBeginLoc());
+      NameLoc = NameLoc.getPrefix();
+    }
+  }
+
+private:
+  void checkAndAddLocation(SourceLocation Loc) {
+    const SourceLocation BeginLoc = Loc;
+    const SourceLocation EndLoc = Lexer::getLocForEndOfToken(
+        BeginLoc, 0, Context.getSourceManager(), Context.getLangOpts());
+    StringRef TokenName =
+        Lexer::getSourceText(CharSourceRange::getTokenRange(BeginLoc, EndLoc),
+                             Context.getSourceManager(), Context.getLangOpts());
+    size_t Offset = TokenName.find(PrevName);
+
+    // The token of the source location we find actually has the old
+    // name.
+    if (Offset != StringRef::npos)
+      LocationsFound.push_back(BeginLoc.getLocWithOffset(Offset));
+  }
+
+  const std::set<std::string> USRSet;
+  const std::string PrevName;
+  std::vector<clang::SourceLocation> LocationsFound;
+  const ASTContext &Context;
+};
+
+} // namespace
+
+std::vector<SourceLocation>
+getLocationsOfUSRs(const std::vector<std::string> &USRs, StringRef PrevName,
+                   Decl *Decl) {
+  USRLocFindingASTVisitor Visitor(USRs, PrevName, Decl->getASTContext());
+  Visitor.TraverseDecl(Decl);
+  NestedNameSpecifierLocFinder Finder(Decl->getASTContext());
+
+  for (const auto &Location : Finder.getNestedNameSpecifierLocations())
+    Visitor.handleNestedNameSpecifierLoc(Location);
+
+  return Visitor.getLocationsFound();
+}
+
+} // namespace rename
+} // namespace clang

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

@@ -0,0 +1,35 @@
+//===--- 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 "clang/AST/AST.h"
+#include "llvm/ADT/StringRef.h"
+#include <string>
+#include <vector>
+
+namespace clang {
+namespace rename {
+
+// FIXME: make this an AST matcher. Wouldn't that be awesome??? I agree!
+std::vector<SourceLocation>
+getLocationsOfUSRs(const std::vector<std::string> &USRs,
+                   llvm::StringRef PrevName, Decl *Decl);
+
+} // namespace rename
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H

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

@@ -0,0 +1,19 @@
+add_clang_executable(clang-rename ClangRename.cpp)
+
+target_link_libraries(clang-rename
+  clangBasic
+  clangFrontend
+  clangRename
+  clangRewrite
+  clangTooling
+  clangToolingCore
+  )
+
+install(TARGETS clang-rename RUNTIME DESTINATION bin)
+
+install(PROGRAMS clang-rename.py
+  DESTINATION share/clang
+  COMPONENT clang-rename)
+install(PROGRAMS clang-rename.el
+  DESTINATION share/clang
+  COMPONENT clang-rename)

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

@@ -13,6 +13,8 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "../RenamingAction.h"
+#include "../USRFindingAction.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
@@ -24,8 +26,6 @@
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
-#include "clang/Tooling/Refactoring/Rename/RenamingAction.h"
-#include "clang/Tooling/Refactoring/Rename/USRFindingAction.h"
 #include "clang/Tooling/ReplacementsYaml.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
@@ -33,6 +33,7 @@
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
+#include <cstdlib>
 #include <string>
 #include <system_error>
 
@@ -94,9 +95,6 @@ static cl::opt<std::string>
 static cl::opt<std::string>
     Input("input", cl::desc("YAML file to load oldname-newname pairs from."),
           cl::Optional, cl::cat(ClangRenameOptions));
-static cl::opt<bool> Force("force",
-                           cl::desc("Ignore nonexistent qualified names."),
-                           cl::cat(ClangRenameOptions));
 
 int main(int argc, const char **argv) {
   tooling::CommonOptionsParser OP(argc, argv, ClangRenameOptions);
@@ -126,25 +124,25 @@ int main(int argc, const char **argv) {
   // Check the arguments for correctness.
   if (NewNames.empty()) {
     errs() << "clang-rename: -new-name must be specified.\n\n";
-    return 1;
+    exit(1);
   }
 
   if (SymbolOffsets.empty() == QualifiedNames.empty()) {
     errs() << "clang-rename: -offset and -qualified-name can't be present at "
               "the same time.\n";
-    return 1;
+    exit(1);
   }
 
   // Check if NewNames is a valid identifier in C++17.
   LangOptions Options;
   Options.CPlusPlus = true;
-  Options.CPlusPlus17 = true;
+  Options.CPlusPlus1z = true;
   IdentifierTable Table(Options);
   for (const auto &NewName : NewNames) {
     auto NewNameTokKind = Table.get(NewName).getTokenID();
     if (!tok::isAnyIdentifier(NewNameTokKind)) {
       errs() << "ERROR: new name is not a valid identifier in C++17.\n\n";
-      return 1;
+      exit(1);
     }
   }
 
@@ -154,12 +152,12 @@ int main(int argc, const char **argv) {
            << ") must be equal to number of new names(" << NewNames.size()
            << ").\n\n";
     cl::PrintHelpMessage();
-    return 1;
+    exit(1);
   }
 
   auto Files = OP.getSourcePathList();
   tooling::RefactoringTool Tool(OP.getCompilations(), Files);
-  tooling::USRFindingAction FindingAction(SymbolOffsets, QualifiedNames, Force);
+  rename::USRFindingAction FindingAction(SymbolOffsets, QualifiedNames);
   Tool.run(tooling::newFrontendActionFactory(&FindingAction).get());
   const std::vector<std::vector<std::string>> &USRList =
       FindingAction.getUSRList();
@@ -172,12 +170,12 @@ int main(int argc, const char **argv) {
 
   if (FindingAction.errorOccurred()) {
     // Diagnostics are already issued at this point.
-    return 1;
+    exit(1);
   }
 
   // Perform the renaming.
-  tooling::RenamingAction RenameAction(NewNames, PrevNames, USRList,
-                                       Tool.getReplacements(), PrintLocations);
+  rename::RenamingAction RenameAction(NewNames, PrevNames, USRList,
+                                      Tool.getReplacements(), PrintLocations);
   std::unique_ptr<tooling::FrontendActionFactory> Factory =
       tooling::newFrontendActionFactory(&RenameAction);
   int ExitCode;
@@ -192,7 +190,7 @@ int main(int argc, const char **argv) {
       llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::F_None);
       if (EC) {
         llvm::errs() << "Error opening output file: " << EC.message() << '\n';
-        return 1;
+        exit(1);
       }
 
       // Export replacements.
@@ -205,7 +203,7 @@ int main(int argc, const char **argv) {
       yaml::Output YAML(OS);
       YAML << TUR;
       OS.close();
-      return 0;
+      exit(0);
     }
 
     // Write every file to stdout. Right now we just barf the files without any
@@ -229,5 +227,5 @@ int main(int argc, const char **argv) {
     }
   }
 
-  return ExitCode;
+  exit(ExitCode);
 }

clang-tools-extra/clang-reorder-fields/ReorderFieldsAction.cpp

@@ -22,23 +22,21 @@
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Refactoring.h"
-#include "llvm/ADT/SetVector.h"
 #include <algorithm>
 #include <string>
 
 namespace clang {
 namespace reorder_fields {
 using namespace clang::ast_matchers;
-using llvm::SmallSetVector;
 
 /// \brief Finds the definition of a record by name.
 ///
 /// \returns nullptr if the name is ambiguous or not found.
-static const RecordDecl *findDefinition(StringRef RecordName,
-                                        ASTContext &Context) {
-  auto Results =
-      match(recordDecl(hasName(RecordName), isDefinition()).bind("recordDecl"),
-            Context);
+static const CXXRecordDecl *findDefinition(StringRef RecordName,
+                                           ASTContext &Context) {
+  auto Results = match(
+      recordDecl(hasName(RecordName), isDefinition()).bind("cxxRecordDecl"),
+      Context);
   if (Results.empty()) {
     llvm::errs() << "Definition of " << RecordName << "  not found\n";
     return nullptr;
@@ -48,14 +46,14 @@ static const RecordDecl *findDefinition(StringRef RecordName,
                  << " is ambiguous, several definitions found\n";
     return nullptr;
   }
-  return selectFirst<RecordDecl>("recordDecl", Results);
+  return selectFirst<CXXRecordDecl>("cxxRecordDecl", Results);
 }
 
 /// \brief Calculates the new order of fields.
 ///
 /// \returns empty vector if the list of fields doesn't match the definition.
 static SmallVector<unsigned, 4>
-getNewFieldsOrder(const RecordDecl *Definition,
+getNewFieldsOrder(const CXXRecordDecl *Definition,
                   ArrayRef<std::string> DesiredFieldsOrder) {
   assert(Definition && "Definition is null");
 
@@ -93,35 +91,13 @@ addReplacement(SourceRange Old, SourceRange New, const ASTContext &Context,
   consumeError(Replacements[R.getFilePath()].add(R));
 }
 
-/// \brief Find all member fields used in the given init-list initializer expr
-/// that belong to the same record
-///
-/// \returns a set of field declarations, empty if none were present
-static SmallSetVector<FieldDecl *, 1>
-findMembersUsedInInitExpr(const CXXCtorInitializer *Initializer,
-                          ASTContext &Context) {
-  SmallSetVector<FieldDecl *, 1> Results;
-  // Note that this does not pick up member fields of base classes since
-  // for those accesses Sema::PerformObjectMemberConversion always inserts an
-  // UncheckedDerivedToBase ImplicitCastExpr between the this expr and the
-  // object expression
-  auto FoundExprs =
-      match(findAll(memberExpr(hasObjectExpression(cxxThisExpr())).bind("ME")),
-            *Initializer->getInit(), Context);
-  for (BoundNodes &BN : FoundExprs)
-    if (auto *MemExpr = BN.getNodeAs<MemberExpr>("ME"))
-      if (auto *FD = dyn_cast<FieldDecl>(MemExpr->getMemberDecl()))
-        Results.insert(FD);
-  return Results;
-}
-
 /// \brief Reorders fields in the definition of a struct/class.
 ///
 /// At the moment reodering of fields with
 /// different accesses (public/protected/private) is not supported.
 /// \returns true on success.
 static bool reorderFieldsInDefinition(
-    const RecordDecl *Definition, ArrayRef<unsigned> NewFieldsOrder,
+    const CXXRecordDecl *Definition, ArrayRef<unsigned> NewFieldsOrder,
     const ASTContext &Context,
     std::map<std::string, tooling::Replacements> &Replacements) {
   assert(Definition && "Definition is null");
@@ -153,12 +129,11 @@ static bool reorderFieldsInDefinition(
 
 /// \brief Reorders initializers in a C++ struct/class constructor.
 ///
-/// A constructor can have initializers for an arbitrary subset of the class's
-/// fields. Thus, we need to ensure that we reorder just the initializers that
-/// are present.
+/// A constructor can have initializers for an arbitrary subset of the class's fields.
+/// Thus, we need to ensure that we reorder just the initializers that are present.
 static void reorderFieldsInConstructor(
     const CXXConstructorDecl *CtorDecl, ArrayRef<unsigned> NewFieldsOrder,
-    ASTContext &Context,
+    const ASTContext &Context,
     std::map<std::string, tooling::Replacements> &Replacements) {
   assert(CtorDecl && "Constructor declaration is null");
   if (CtorDecl->isImplicit() || CtorDecl->getNumCtorInitializers() <= 1)
@@ -176,26 +151,8 @@ static void reorderFieldsInConstructor(
   SmallVector<const CXXCtorInitializer *, 10> OldWrittenInitializersOrder;
   SmallVector<const CXXCtorInitializer *, 10> NewWrittenInitializersOrder;
   for (const auto *Initializer : CtorDecl->inits()) {
-    if (!Initializer->isMemberInitializer() || !Initializer->isWritten())
+    if (!Initializer->isWritten())
       continue;
-
-    // Warn if this reordering violates initialization expr dependencies.
-    const FieldDecl *ThisM = Initializer->getMember();
-    const auto UsedMembers = findMembersUsedInInitExpr(Initializer, Context);
-    for (const FieldDecl *UM : UsedMembers) {
-      if (NewFieldsPositions[UM->getFieldIndex()] >
-          NewFieldsPositions[ThisM->getFieldIndex()]) {
-        DiagnosticsEngine &DiagEngine = Context.getDiagnostics();
-        auto Description = ("reordering field " + UM->getName() + " after " +
-                            ThisM->getName() + " makes " + UM->getName() +
-                            " uninitialized when used in init expression")
-                               .str();
-        unsigned ID = DiagEngine.getDiagnosticIDs()->getCustomDiagID(
-            DiagnosticIDs::Warning, Description);
-        DiagEngine.Report(Initializer->getSourceLocation(), ID);
-      }
-    }
-
     OldWrittenInitializersOrder.push_back(Initializer);
     NewWrittenInitializersOrder.push_back(Initializer);
   }
@@ -225,12 +182,12 @@ static bool reorderFieldsInInitListExpr(
     const ASTContext &Context,
     std::map<std::string, tooling::Replacements> &Replacements) {
   assert(InitListEx && "Init list expression is null");
-  // We care only about InitListExprs which originate from source code.
+  // We care only about InitListExprs which originate from source code. 
   // Implicit InitListExprs are created by the semantic analyzer.
   if (!InitListEx->isExplicit())
     return true;
-  // The method InitListExpr::getSyntacticForm may return nullptr indicating
-  // that the current initializer list also serves as its syntactic form.
+  // The method InitListExpr::getSyntacticForm may return nullptr indicating that
+  // the current initializer list also serves as its syntactic form.
   if (const auto *SyntacticForm = InitListEx->getSyntacticForm())
     InitListEx = SyntacticForm;
   // If there are no initializers we do not need to change anything.
@@ -242,9 +199,10 @@ static bool reorderFieldsInInitListExpr(
   }
   for (unsigned i = 0, e = InitListEx->getNumInits(); i < e; ++i)
     if (i != NewFieldsOrder[i])
-      addReplacement(InitListEx->getInit(i)->getSourceRange(),
-                     InitListEx->getInit(NewFieldsOrder[i])->getSourceRange(),
-                     Context, Replacements);
+      addReplacement(
+          InitListEx->getInit(i)->getSourceRange(),
+          InitListEx->getInit(NewFieldsOrder[i])->getSourceRange(), Context,
+          Replacements);
   return true;
 }
 
@@ -265,7 +223,7 @@ public:
   ReorderingConsumer &operator=(const ReorderingConsumer &) = delete;
 
   void HandleTranslationUnit(ASTContext &Context) override {
-    const RecordDecl *RD = findDefinition(RecordName, Context);
+    const CXXRecordDecl *RD = findDefinition(RecordName, Context);
     if (!RD)
       return;
     SmallVector<unsigned, 4> NewFieldsOrder =
@@ -274,21 +232,16 @@ public:
       return;
     if (!reorderFieldsInDefinition(RD, NewFieldsOrder, Context, Replacements))
       return;
+    for (const auto *C : RD->ctors())
+      if (const auto *D = dyn_cast<CXXConstructorDecl>(C->getDefinition()))
+        reorderFieldsInConstructor(cast<const CXXConstructorDecl>(D),
+                                   NewFieldsOrder, Context, Replacements);
 
-    // CXXRD will be nullptr if C code (not C++) is being processed.
-    const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(RD);
-    if (CXXRD)
-      for (const auto *C : CXXRD->ctors())
-        if (const auto *D = dyn_cast<CXXConstructorDecl>(C->getDefinition()))
-          reorderFieldsInConstructor(cast<const CXXConstructorDecl>(D),
-                                     NewFieldsOrder, Context, Replacements);
-
-    // We only need to reorder init list expressions for
-    // plain C structs or C++ aggregate types.
+    // We only need to reorder init list expressions for aggregate types.
     // For other types the order of constructor parameters is used,
     // which we don't change at the moment.
     // Now (v0) partial initialization is not supported.
-    if (!CXXRD || CXXRD->isAggregate())
+    if (RD->isAggregate())
       for (auto Result :
            match(initListExpr(hasType(equalsNode(RD))).bind("initListExpr"),
                  Context))

clang-tools-extra/clang-reorder-fields/tool/CMakeLists.txt

@@ -1,7 +1,6 @@
-add_clang_tool(clang-reorder-fields ClangReorderFields.cpp)
+add_clang_executable(clang-reorder-fields ClangReorderFields.cpp)
 
 target_link_libraries(clang-reorder-fields
-  PRIVATE
   clangBasic
   clangFrontend
   clangReorderFields
@@ -9,3 +8,5 @@ target_link_libraries(clang-reorder-fields
   clangTooling
   clangToolingCore
   )
+
+install(TARGETS clang-reorder-fields RUNTIME DESTINATION bin)

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

@@ -26,21 +26,16 @@ add_clang_library(clangTidy
   clangToolingCore
   )
 
-add_subdirectory(android)
+add_subdirectory(tool)
+add_subdirectory(plugin)
 add_subdirectory(boost)
-add_subdirectory(bugprone)
 add_subdirectory(cert)
-add_subdirectory(cppcoreguidelines)
-add_subdirectory(fuchsia)
-add_subdirectory(google)
-add_subdirectory(hicpp)
 add_subdirectory(llvm)
+add_subdirectory(cppcoreguidelines)
+add_subdirectory(google)
 add_subdirectory(misc)
 add_subdirectory(modernize)
 add_subdirectory(mpi)
-add_subdirectory(objc)
 add_subdirectory(performance)
-add_subdirectory(plugin)
 add_subdirectory(readability)
-add_subdirectory(tool)
 add_subdirectory(utils)

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

@@ -89,13 +89,13 @@ private:
 
 class ErrorReporter {
 public:
-  ErrorReporter(ClangTidyContext &Context, bool ApplyFixes)
+  ErrorReporter(bool ApplyFixes, StringRef FormatStyle)
       : Files(FileSystemOptions()), DiagOpts(new DiagnosticOptions()),
         DiagPrinter(new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts)),
         Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts,
               DiagPrinter),
-        SourceMgr(Diags, Files), Context(Context), ApplyFixes(ApplyFixes),
-        TotalFixes(0), AppliedFixes(0), WarningsAsErrors(0) {
+        SourceMgr(Diags, Files), ApplyFixes(ApplyFixes), TotalFixes(0),
+        AppliedFixes(0), WarningsAsErrors(0), FormatStyle(FormatStyle) {
     DiagOpts->ShowColors = llvm::sys::Process::StandardOutHasColors();
     DiagPrinter->BeginSourceFile(LangOpts);
   }
@@ -183,6 +183,7 @@ public:
   }
 
   void Finish() {
+    // FIXME: Run clang-format on changes.
     if (ApplyFixes && TotalFixes > 0) {
       Rewriter Rewrite(SourceMgr, LangOpts);
       for (const auto &FileAndReplacements : FileReplacements) {
@@ -196,29 +197,15 @@ public:
           continue;
         }
         StringRef Code = Buffer.get()->getBuffer();
-        auto Style = format::getStyle(
-            *Context.getOptionsForFile(File).FormatStyle, File, "none");
-        if (!Style) {
-          llvm::errs() << llvm::toString(Style.takeError()) << "\n";
-          continue;
-        }
-        llvm::Expected<tooling::Replacements> Replacements =
+        format::FormatStyle Style = format::getStyle("file", File, FormatStyle);
+        llvm::Expected<Replacements> CleanReplacements =
             format::cleanupAroundReplacements(Code, FileAndReplacements.second,
-                                              *Style);
-        if (!Replacements) {
-          llvm::errs() << llvm::toString(Replacements.takeError()) << "\n";
+                                              Style);
+        if (!CleanReplacements) {
+          llvm::errs() << llvm::toString(CleanReplacements.takeError()) << "\n";
           continue;
         }
-        if (llvm::Expected<tooling::Replacements> FormattedReplacements =
-                format::formatReplacements(Code, *Replacements, *Style)) {
-          Replacements = std::move(FormattedReplacements);
-          if (!Replacements)
-            llvm_unreachable("!Replacements");
-        } else {
-          llvm::errs() << llvm::toString(FormattedReplacements.takeError())
-                       << ". Skipping formatting.\n";
-        }
-        if (!tooling::applyAllReplacements(Replacements.get(), Rewrite)) {
+        if (!tooling::applyAllReplacements(CleanReplacements.get(), Rewrite)) {
           llvm::errs() << "Can't apply replacements for file " << File << "\n";
         }
       }
@@ -239,7 +226,7 @@ private:
       return SourceLocation();
 
     const FileEntry *File = SourceMgr.getFileManager().getFile(FilePath);
-    FileID ID = SourceMgr.getOrCreateFileID(File, SrcMgr::C_User);
+    FileID ID = SourceMgr.createFileID(File, SourceLocation(), SrcMgr::C_User);
     return SourceMgr.getLocForStartOfFile(ID).getLocWithOffset(Offset);
   }
 
@@ -256,11 +243,11 @@ private:
   DiagnosticsEngine Diags;
   SourceManager SourceMgr;
   llvm::StringMap<Replacements> FileReplacements;
-  ClangTidyContext &Context;
   bool ApplyFixes;
   unsigned TotalFixes;
   unsigned AppliedFixes;
   unsigned WarningsAsErrors;
+  StringRef FormatStyle;
 };
 
 class ClangTidyASTConsumer : public MultiplexConsumer {
@@ -302,7 +289,7 @@ static void setStaticAnalyzerCheckerOpts(const ClangTidyOptions &Opts,
 
 typedef std::vector<std::pair<std::string, bool>> CheckersList;
 
-static CheckersList getCheckersControlList(ClangTidyContext &Context) {
+static CheckersList getCheckersControlList(GlobList &Filter) {
   CheckersList List;
 
   const auto &RegisteredCheckers =
@@ -310,7 +297,7 @@ static CheckersList getCheckersControlList(ClangTidyContext &Context) {
   bool AnalyzerChecksEnabled = false;
   for (StringRef CheckName : RegisteredCheckers) {
     std::string ClangTidyCheckName((AnalyzerCheckNamePrefix + CheckName).str());
-    AnalyzerChecksEnabled |= Context.isCheckEnabled(ClangTidyCheckName);
+    AnalyzerChecksEnabled |= Filter.contains(ClangTidyCheckName);
   }
 
   if (!AnalyzerChecksEnabled)
@@ -324,10 +311,8 @@ static CheckersList getCheckersControlList(ClangTidyContext &Context) {
   for (StringRef CheckName : RegisteredCheckers) {
     std::string ClangTidyCheckName((AnalyzerCheckNamePrefix + CheckName).str());
 
-    if (CheckName.startswith("core") ||
-        Context.isCheckEnabled(ClangTidyCheckName)) {
+    if (CheckName.startswith("core") || Filter.contains(ClangTidyCheckName))
       List.emplace_back(CheckName, true);
-    }
   }
   return List;
 }
@@ -373,7 +358,8 @@ ClangTidyASTConsumerFactory::CreateASTConsumer(
   AnalyzerOptions->Config["cfg-temporary-dtors"] =
       Context.getOptions().AnalyzeTemporaryDtors ? "true" : "false";
 
-  AnalyzerOptions->CheckersControlList = getCheckersControlList(Context);
+  GlobList &Filter = Context.getChecksFilter();
+  AnalyzerOptions->CheckersControlList = getCheckersControlList(Filter);
   if (!AnalyzerOptions->CheckersControlList.empty()) {
     setStaticAnalyzerCheckerOpts(Context.getOptions(), AnalyzerOptions);
     AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
@@ -392,12 +378,13 @@ ClangTidyASTConsumerFactory::CreateASTConsumer(
 
 std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
   std::vector<std::string> CheckNames;
+  GlobList &Filter = Context.getChecksFilter();
   for (const auto &CheckFactory : *CheckFactories) {
-    if (Context.isCheckEnabled(CheckFactory.first))
+    if (Filter.contains(CheckFactory.first))
       CheckNames.push_back(CheckFactory.first);
   }
 
-  for (const auto &AnalyzerCheck : getCheckersControlList(Context))
+  for (const auto &AnalyzerCheck : getCheckersControlList(Filter))
     CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);
 
   std::sort(CheckNames.begin(), CheckNames.end());
@@ -472,10 +459,13 @@ ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options) {
   return Factory.getCheckOptions();
 }
 
-void runClangTidy(clang::tidy::ClangTidyContext &Context,
-                  const CompilationDatabase &Compilations,
-                  ArrayRef<std::string> InputFiles, ProfileData *Profile) {
+ClangTidyStats
+runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
+             const CompilationDatabase &Compilations,
+             ArrayRef<std::string> InputFiles,
+             std::vector<ClangTidyError> *Errors, ProfileData *Profile) {
   ClangTool Tool(Compilations, InputFiles);
+  clang::tidy::ClangTidyContext Context(std::move(OptionsProvider));
 
   // Add extra arguments passed by the clang-tidy command-line.
   ArgumentsAdjuster PerFileExtraArgumentsInserter =
@@ -497,7 +487,7 @@ void runClangTidy(clang::tidy::ClangTidyContext &Context,
 
   // Remove plugins arguments.
   ArgumentsAdjuster PluginArgumentsRemover =
-      [](const CommandLineArguments &Args, StringRef Filename) {
+      [&Context](const CommandLineArguments &Args, StringRef Filename) {
         CommandLineArguments AdjustedArgs;
         for (size_t I = 0, E = Args.size(); I < E; ++I) {
           if (I + 4 < Args.size() && Args[I] == "-Xclang" &&
@@ -543,18 +533,20 @@ void runClangTidy(clang::tidy::ClangTidyContext &Context,
 
   ActionFactory Factory(Context);
   Tool.run(&Factory);
+  *Errors = Context.getErrors();
+  return Context.getStats();
 }
 
-void handleErrors(ClangTidyContext &Context, bool Fix,
-                  unsigned &WarningsAsErrorsCount) {
-  ErrorReporter Reporter(Context, Fix);
+void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix,
+                  StringRef FormatStyle, unsigned &WarningsAsErrorsCount) {
+  ErrorReporter Reporter(Fix, FormatStyle);
   vfs::FileSystem &FileSystem =
       *Reporter.getSourceManager().getFileManager().getVirtualFileSystem();
   auto InitialWorkingDir = FileSystem.getCurrentWorkingDirectory();
   if (!InitialWorkingDir)
     llvm::report_fatal_error("Cannot get current working path.");
 
-  for (const ClangTidyError &Error : Context.getErrors()) {
+  for (const ClangTidyError &Error : Errors) {
     if (!Error.BuildDirectory.empty()) {
       // By default, the working directory of file system is the current
       // clang-tidy running directory.

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

@@ -224,10 +224,12 @@ ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options);
 ///
 /// \param Profile if provided, it enables check profile collection in
 /// MatchFinder, and will contain the result of the profile.
-void runClangTidy(clang::tidy::ClangTidyContext &Context,
-                  const tooling::CompilationDatabase &Compilations,
-                  ArrayRef<std::string> InputFiles,
-                  ProfileData *Profile = nullptr);
+ClangTidyStats
+runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
+             const tooling::CompilationDatabase &Compilations,
+             ArrayRef<std::string> InputFiles,
+             std::vector<ClangTidyError> *Errors,
+             ProfileData *Profile = nullptr);
 
 // FIXME: This interface will need to be significantly extended to be useful.
 // FIXME: Implement confidence levels for displaying/fixing errors.
@@ -235,8 +237,8 @@ void runClangTidy(clang::tidy::ClangTidyContext &Context,
 /// \brief Displays the found \p Errors to the users. If \p Fix is true, \p
 /// Errors containing fixes are automatically applied and reformatted. If no
 /// clang-format configuration file is found, the given \P FormatStyle is used.
-void handleErrors(ClangTidyContext &Context, bool Fix,
-                  unsigned &WarningsAsErrorsCount);
+void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix,
+                  StringRef FormatStyle, unsigned &WarningsAsErrorsCount);
 
 /// \brief Serializes replacements into YAML and writes them to the specified
 /// output stream.

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

@@ -21,7 +21,6 @@
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include <tuple>
 #include <vector>
@@ -37,9 +36,10 @@ public:
       : DiagnosticRenderer(LangOpts, DiagOpts), Error(Error) {}
 
 protected:
-  void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
+  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
@@ -49,10 +49,9 @@ protected:
     if (Message.endswith(CheckNameInMessage))
       Message = Message.substr(0, Message.size() - CheckNameInMessage.size());
 
-    auto TidyMessage =
-        Loc.isValid()
-            ? tooling::DiagnosticMessage(Message, Loc.getManager(), Loc)
-            : tooling::DiagnosticMessage(Message);
+    auto TidyMessage = Loc.isValid()
+                           ? tooling::DiagnosticMessage(Message, *SM, Loc)
+                           : tooling::DiagnosticMessage(Message);
     if (Level == DiagnosticsEngine::Note) {
       Error.Notes.push_back(TidyMessage);
       return;
@@ -61,13 +60,15 @@ protected:
     Error.Message = TidyMessage;
   }
 
-  void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc,
                          DiagnosticsEngine::Level Level,
-                         ArrayRef<CharSourceRange> Ranges) override {}
+                         ArrayRef<CharSourceRange> Ranges,
+                         const SourceManager &SM) override {}
 
-  void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+  void emitCodeContext(SourceLocation Loc, DiagnosticsEngine::Level Level,
                        SmallVectorImpl<CharSourceRange> &Ranges,
-                       ArrayRef<FixItHint> Hints) override {
+                       ArrayRef<FixItHint> Hints,
+                       const SourceManager &SM) override {
     assert(Loc.isValid());
     for (const auto &FixIt : Hints) {
       CharSourceRange Range = FixIt.RemoveRange;
@@ -76,8 +77,7 @@ protected:
       assert(Range.getBegin().isFileID() && Range.getEnd().isFileID() &&
              "Only file locations supported in fix-it hints.");
 
-      tooling::Replacement Replacement(Loc.getManager(), Range,
-                                       FixIt.CodeToInsert);
+      tooling::Replacement Replacement(SM, Range, FixIt.CodeToInsert);
       llvm::Error Err = Error.Fix[Replacement.getFilePath()].add(Replacement);
       // FIXME: better error handling (at least, don't let other replacements be
       // applied).
@@ -89,13 +89,16 @@ protected:
     }
   }
 
-  void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) override {}
+  void emitIncludeLocation(SourceLocation Loc, PresumedLoc PLoc,
+                           const SourceManager &SM) override {}
 
-  void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
-                          StringRef ModuleName) override {}
+  void emitImportLocation(SourceLocation Loc, PresumedLoc PLoc,
+                          StringRef ModuleName,
+                          const SourceManager &SM) override {}
 
-  void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc,
-                                  StringRef ModuleName) override {}
+  void emitBuildingModuleLocation(SourceLocation Loc, PresumedLoc PLoc,
+                                  StringRef ModuleName,
+                                  const SourceManager &SM) override {}
 
   void endDiagnostic(DiagOrStoredDiag D,
                      DiagnosticsEngine::Level Level) override {
@@ -116,7 +119,6 @@ ClangTidyError::ClangTidyError(StringRef CheckName,
 // Returns true if GlobList starts with the negative indicator ('-'), removes it
 // from the GlobList.
 static bool ConsumeNegativeIndicator(StringRef &GlobList) {
-  GlobList = GlobList.trim(" \r\n");
   if (GlobList.startswith("-")) {
     GlobList = GlobList.substr(1);
     return true;
@@ -126,9 +128,8 @@ static bool ConsumeNegativeIndicator(StringRef &GlobList) {
 // 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 UntrimmedGlob = GlobList.substr(0, GlobList.find(','));
-  StringRef Glob = UntrimmedGlob.trim(' ');
-  GlobList = GlobList.substr(UntrimmedGlob.size() + 1);
+  StringRef Glob = GlobList.substr(0, GlobList.find(',')).trim();
+  GlobList = GlobList.substr(Glob.size() + 1);
   SmallString<128> RegexText("^");
   StringRef MetaChars("()^$|*+?.[]\\{}");
   for (char C : Glob) {
@@ -155,27 +156,6 @@ bool GlobList::contains(StringRef S, bool Contains) {
   return Contains;
 }
 
-class ClangTidyContext::CachedGlobList {
-public:
-  CachedGlobList(StringRef Globs) : Globs(Globs) {}
-
-  bool contains(StringRef S) {
-    switch (auto &Result = Cache[S]) {
-      case Yes: return true;
-      case No: return false;
-      case None:
-        Result = Globs.contains(S) ? Yes : No;
-        return Result == Yes;
-    }
-    llvm_unreachable("invalid enum");
-  }
-
-private:
-  GlobList Globs;
-  enum Tristate { None, Yes, No };
-  llvm::StringMap<Tristate> Cache;
-};
-
 ClangTidyContext::ClangTidyContext(
     std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider)
     : DiagEngine(nullptr), OptionsProvider(std::move(OptionsProvider)),
@@ -185,8 +165,6 @@ ClangTidyContext::ClangTidyContext(
   setCurrentFile("");
 }
 
-ClangTidyContext::~ClangTidyContext() = default;
-
 DiagnosticBuilder ClangTidyContext::diag(
     StringRef CheckName, SourceLocation Loc, StringRef Description,
     DiagnosticIDs::Level Level /* = DiagnosticIDs::Warning*/) {
@@ -208,9 +186,8 @@ void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
 void ClangTidyContext::setCurrentFile(StringRef File) {
   CurrentFile = File;
   CurrentOptions = getOptionsForFile(CurrentFile);
-  CheckFilter = llvm::make_unique<CachedGlobList>(*getOptions().Checks);
-  WarningAsErrorFilter =
-      llvm::make_unique<CachedGlobList>(*getOptions().WarningsAsErrors);
+  CheckFilter.reset(new GlobList(*getOptions().Checks));
+  WarningAsErrorFilter.reset(new GlobList(*getOptions().WarningsAsErrors));
 }
 
 void ClangTidyContext::setASTContext(ASTContext *Context) {
@@ -235,14 +212,14 @@ ClangTidyOptions ClangTidyContext::getOptionsForFile(StringRef File) const {
 
 void ClangTidyContext::setCheckProfileData(ProfileData *P) { Profile = P; }
 
-bool ClangTidyContext::isCheckEnabled(StringRef CheckName) const {
+GlobList &ClangTidyContext::getChecksFilter() {
   assert(CheckFilter != nullptr);
-  return CheckFilter->contains(CheckName);
+  return *CheckFilter;
 }
 
-bool ClangTidyContext::treatAsError(StringRef CheckName) const {
+GlobList &ClangTidyContext::getWarningAsErrorFilter() {
   assert(WarningAsErrorFilter != nullptr);
-  return WarningAsErrorFilter->contains(CheckName);
+  return *WarningAsErrorFilter;
 }
 
 /// \brief Store a \c ClangTidyError.
@@ -258,22 +235,20 @@ StringRef ClangTidyContext::getCheckName(unsigned DiagnosticID) const {
   return "";
 }
 
-ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(
-    ClangTidyContext &Ctx, bool RemoveIncompatibleErrors)
-    : Context(Ctx), RemoveIncompatibleErrors(RemoveIncompatibleErrors),
-      LastErrorRelatesToUserCode(false), LastErrorPassesLineFilter(false),
-      LastErrorWasIgnored(false) {
+ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx)
+    : Context(Ctx), LastErrorRelatesToUserCode(false),
+      LastErrorPassesLineFilter(false), LastErrorWasIgnored(false) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-  Diags = llvm::make_unique<DiagnosticsEngine>(
+  Diags.reset(new DiagnosticsEngine(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
-      /*ShouldOwnClient=*/false);
+      /*ShouldOwnClient=*/false));
   Context.setDiagnosticsEngine(Diags.get());
 }
 
 void ClangTidyDiagnosticConsumer::finalizeLastError() {
   if (!Errors.empty()) {
     ClangTidyError &Error = Errors.back();
-    if (!Context.isCheckEnabled(Error.DiagnosticName) &&
+    if (!Context.getChecksFilter().contains(Error.DiagnosticName) &&
         Error.DiagLevel != ClangTidyError::Error) {
       ++Context.Stats.ErrorsIgnoredCheckFilter;
       Errors.pop_back();
@@ -291,86 +266,26 @@ void ClangTidyDiagnosticConsumer::finalizeLastError() {
   LastErrorPassesLineFilter = false;
 }
 
-static bool IsNOLINTFound(StringRef NolintDirectiveText, StringRef Line,
-                          unsigned DiagID, const ClangTidyContext &Context) {
-  const size_t NolintIndex = Line.find(NolintDirectiveText);
-  if (NolintIndex == StringRef::npos)
-    return false;
-
-  size_t BracketIndex = NolintIndex + NolintDirectiveText.size();
-  // Check if the specific checks are specified in brackets.
-  if (BracketIndex < Line.size() && Line[BracketIndex] == '(') {
-    ++BracketIndex;
-    const size_t BracketEndIndex = Line.find(')', BracketIndex);
-    if (BracketEndIndex != StringRef::npos) {
-      StringRef ChecksStr =
-          Line.substr(BracketIndex, BracketEndIndex - BracketIndex);
-      // Allow disabling all the checks with "*".
-      if (ChecksStr != "*") {
-        StringRef CheckName = Context.getCheckName(DiagID);
-        // Allow specifying a few check names, delimited with comma.
-        SmallVector<StringRef, 1> Checks;
-        ChecksStr.split(Checks, ',', -1, false);
-        llvm::transform(Checks, Checks.begin(),
-                        [](StringRef S) { return S.trim(); });
-        return llvm::find(Checks, CheckName) != Checks.end();
-      }
-    }
-  }
-  return true;
-}
-
-static bool LineIsMarkedWithNOLINT(SourceManager &SM, SourceLocation Loc,
-                                   unsigned DiagID,
-                                   const ClangTidyContext &Context) {
+static bool LineIsMarkedWithNOLINT(SourceManager &SM, SourceLocation Loc) {
   bool Invalid;
   const char *CharacterData = SM.getCharacterData(Loc, &Invalid);
-  if (Invalid)
-    return false;
-
-  // Check if there's a NOLINT on this line.
-  const char *P = CharacterData;
-  while (*P != '\0' && *P != '\r' && *P != '\n')
-    ++P;
-  StringRef RestOfLine(CharacterData, P - CharacterData + 1);
-  if (IsNOLINTFound("NOLINT", RestOfLine, DiagID, Context))
-    return true;
-
-  // Check if there's a NOLINTNEXTLINE on the previous line.
-  const char *BufBegin =
-      SM.getCharacterData(SM.getLocForStartOfFile(SM.getFileID(Loc)), &Invalid);
-  if (Invalid || P == BufBegin)
-    return false;
-
-  // Scan backwards over the current line.
-  P = CharacterData;
-  while (P != BufBegin && *P != '\n')
-    --P;
-
-  // If we reached the begin of the file there is no line before it.
-  if (P == BufBegin)
-    return false;
-
-  // Skip over the newline.
-  --P;
-  const char *LineEnd = P;
-
-  // Now we're on the previous line. Skip to the beginning of it.
-  while (P != BufBegin && *P != '\n')
-    --P;
-
-  RestOfLine = StringRef(P, LineEnd - P + 1);
-  if (IsNOLINTFound("NOLINTNEXTLINE", RestOfLine, DiagID, Context))
-    return true;
-
+  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) {
+      return true;
+    }
+  }
   return false;
 }
 
-static bool LineIsMarkedWithNOLINTinMacro(SourceManager &SM, SourceLocation Loc,
-                                          unsigned DiagID,
-                                          const ClangTidyContext &Context) {
+static bool LineIsMarkedWithNOLINTinMacro(SourceManager &SM,
+                                          SourceLocation Loc) {
   while (true) {
-    if (LineIsMarkedWithNOLINT(SM, Loc, DiagID, Context))
+    if (LineIsMarkedWithNOLINT(SM, Loc))
       return true;
     if (!Loc.isMacroID())
       return false;
@@ -387,8 +302,7 @@ void ClangTidyDiagnosticConsumer::HandleDiagnostic(
   if (Info.getLocation().isValid() && DiagLevel != DiagnosticsEngine::Error &&
       DiagLevel != DiagnosticsEngine::Fatal &&
       LineIsMarkedWithNOLINTinMacro(Diags->getSourceManager(),
-                                    Info.getLocation(), Info.getID(),
-                                    Context)) {
+                                    Info.getLocation())) {
     ++Context.Stats.ErrorsIgnoredNOLINT;
     // Ignored a warning, should ignore related notes as well
     LastErrorWasIgnored = true;
@@ -437,8 +351,9 @@ void ClangTidyDiagnosticConsumer::HandleDiagnostic(
       LastErrorRelatesToUserCode = true;
       LastErrorPassesLineFilter = true;
     }
-    bool IsWarningAsError = DiagLevel == DiagnosticsEngine::Warning &&
-                            Context.treatAsError(CheckName);
+    bool IsWarningAsError =
+        DiagLevel == DiagnosticsEngine::Warning &&
+        Context.getWarningAsErrorFilter().contains(CheckName);
     Errors.emplace_back(CheckName, Level, Context.getCurrentBuildDirectory(),
                         IsWarningAsError);
   }
@@ -448,12 +363,11 @@ void ClangTidyDiagnosticConsumer::HandleDiagnostic(
       Errors.back());
   SmallString<100> Message;
   Info.FormatDiagnostic(Message);
-  FullSourceLoc Loc =
-      (Info.getLocation().isInvalid())
-          ? FullSourceLoc()
-          : FullSourceLoc(Info.getLocation(), Info.getSourceManager());
-  Converter.emitDiagnostic(Loc, DiagLevel, Message, Info.getRanges(),
-                           Info.getFixItHints());
+  SourceManager *Sources = nullptr;
+  if (Info.hasSourceManager())
+    Sources = &Info.getSourceManager();
+  Converter.emitDiagnostic(Info.getLocation(), DiagLevel, Message,
+                           Info.getRanges(), Info.getFixItHints(), Sources);
 
   checkFilters(Info.getLocation());
 }
@@ -515,8 +429,8 @@ void ClangTidyDiagnosticConsumer::checkFilters(SourceLocation Location) {
 
 llvm::Regex *ClangTidyDiagnosticConsumer::getHeaderFilter() {
   if (!HeaderFilter)
-    HeaderFilter =
-        llvm::make_unique<llvm::Regex>(*Context.getOptions().HeaderFilterRegex);
+    HeaderFilter.reset(
+        new llvm::Regex(*Context.getOptions().HeaderFilterRegex));
   return HeaderFilter.get();
 }
 
@@ -666,9 +580,7 @@ void ClangTidyDiagnosticConsumer::finish() {
   std::sort(Errors.begin(), Errors.end(), LessClangTidyError());
   Errors.erase(std::unique(Errors.begin(), Errors.end(), EqualClangTidyError()),
                Errors.end());
-
-  if (RemoveIncompatibleErrors)
-    removeIncompatibleErrors(Errors);
+  removeIncompatibleErrors(Errors);
 
   for (const ClangTidyError &Error : Errors)
     Context.storeError(Error);

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

@@ -106,8 +106,6 @@ public:
   /// \brief Initializes \c ClangTidyContext instance.
   ClangTidyContext(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider);
 
-  ~ClangTidyContext();
-
   /// \brief Report any errors detected using this method.
   ///
   /// This is still under heavy development and will likely change towards using
@@ -138,14 +136,14 @@ public:
   /// diagnostic ID.
   StringRef getCheckName(unsigned DiagnosticID) const;
 
-  /// \brief Returns \c true if the check is enabled for the \c CurrentFile.
+  /// \brief Returns check filter for the \c CurrentFile.
   ///
   /// The \c CurrentFile can be changed using \c setCurrentFile.
-  bool isCheckEnabled(StringRef CheckName) const;
+  GlobList &getChecksFilter();
 
-  /// \brief Returns \c true if the check should be upgraded to error for the
-  /// \c CurrentFile.
-  bool treatAsError(StringRef CheckName) const;
+  /// \brief Returns check filter for the \c CurrentFile which
+  /// selects checks for upgrade to error.
+  GlobList &getWarningAsErrorFilter();
 
   /// \brief Returns global options.
   const ClangTidyGlobalOptions &getGlobalOptions() const;
@@ -164,7 +162,7 @@ public:
   const ClangTidyStats &getStats() const { return Stats; }
 
   /// \brief Returns all collected errors.
-  ArrayRef<ClangTidyError> getErrors() const { return Errors; }
+  const std::vector<ClangTidyError> &getErrors() const { return Errors; }
 
   /// \brief Clears collected errors.
   void clearErrors() { Errors.clear(); }
@@ -204,9 +202,8 @@ private:
 
   std::string CurrentFile;
   ClangTidyOptions CurrentOptions;
-  class CachedGlobList;
-  std::unique_ptr<CachedGlobList> CheckFilter;
-  std::unique_ptr<CachedGlobList> WarningAsErrorFilter;
+  std::unique_ptr<GlobList> CheckFilter;
+  std::unique_ptr<GlobList> WarningAsErrorFilter;
 
   LangOptions LangOpts;
 
@@ -226,8 +223,7 @@ private:
 // implementation file.
 class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {
 public:
-  ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx,
-                              bool RemoveIncompatibleErrors = true);
+  ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx);
 
   // FIXME: The concept of converting between FixItHints and Replacements is
   // more generic and should be pulled out into a more useful Diagnostics
@@ -253,7 +249,6 @@ private:
   bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
 
   ClangTidyContext &Context;
-  bool RemoveIncompatibleErrors;
   std::unique_ptr<DiagnosticsEngine> Diags;
   SmallVector<ClangTidyError, 8> Errors;
   std::unique_ptr<llvm::Regex> HeaderFilter;

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

@@ -24,8 +24,9 @@ void ClangTidyCheckFactories::registerCheckFactory(StringRef Name,
 void ClangTidyCheckFactories::createChecks(
     ClangTidyContext *Context,
     std::vector<std::unique_ptr<ClangTidyCheck>> &Checks) {
+  GlobList &Filter = Context->getChecksFilter();
   for (const auto &Factory : Factories) {
-    if (Context->isCheckEnabled(Factory.first))
+    if (Filter.contains(Factory.first))
       Checks.emplace_back(Factory.second(Factory.first, Context));
   }
 }

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

@@ -27,6 +27,8 @@ using OptionsSource = clang::tidy::ClangTidyOptionsProvider::OptionsSource;
 
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
+LLVM_YAML_IS_SEQUENCE_VECTOR(ClangTidyOptions::StringPair)
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::string)
 
 namespace llvm {
 namespace yaml {
@@ -87,7 +89,6 @@ template <> struct MappingTraits<ClangTidyOptions> {
     IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
     IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
     IO.mapOptional("AnalyzeTemporaryDtors", Options.AnalyzeTemporaryDtors);
-    IO.mapOptional("FormatStyle", Options.FormatStyle);
     IO.mapOptional("User", Options.User);
     IO.mapOptional("CheckOptions", NOpts->Options);
     IO.mapOptional("ExtraArgs", Options.ExtraArgs);
@@ -108,7 +109,6 @@ ClangTidyOptions ClangTidyOptions::getDefaults() {
   Options.HeaderFilterRegex = "";
   Options.SystemHeaders = false;
   Options.AnalyzeTemporaryDtors = false;
-  Options.FormatStyle = "none";
   Options.User = llvm::None;
   for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
                                          E = ClangTidyModuleRegistry::end();
@@ -148,7 +148,6 @@ ClangTidyOptions::mergeWith(const ClangTidyOptions &Other) const {
   overrideValue(Result.HeaderFilterRegex, Other.HeaderFilterRegex);
   overrideValue(Result.SystemHeaders, Other.SystemHeaders);
   overrideValue(Result.AnalyzeTemporaryDtors, Other.AnalyzeTemporaryDtors);
-  overrideValue(Result.FormatStyle, Other.FormatStyle);
   overrideValue(Result.User, Other.User);
   mergeVectors(Result.ExtraArgs, Other.ExtraArgs);
   mergeVectors(Result.ExtraArgsBefore, Other.ExtraArgsBefore);

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

@@ -75,20 +75,6 @@ struct ClangTidyOptions {
   /// \brief Turns on temporary destructor-based analysis.
   llvm::Optional<bool> AnalyzeTemporaryDtors;
 
-  /// \brief Format code around applied fixes with clang-format using this
-  /// style.
-  ///
-  /// Can be one of:
-  ///   * 'none' - don't format code around applied fixes;
-  ///   * 'llvm', 'google', 'mozilla' or other predefined clang-format style
-  ///     names;
-  ///   * 'file' - use the .clang-format file in the closest parent directory of
-  ///     each source file;
-  ///   * '{inline-formatting-style-in-yaml-format}'.
-  ///
-  /// See clang-format documentation for more about configuring format style.
-  llvm::Optional<std::string> FormatStyle;
-
   /// \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()

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

@@ -51,7 +51,7 @@ def write_header(module_path, module, check_name, check_name_camel):
   print('Creating %s...' % filename)
   with open(filename, 'wb') as f:
     header_guard = ('LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_' + module.upper() + '_'
-                    + check_name_camel.upper() + '_H')
+                    + check_name.upper().replace('-', '_') + '_H')
     f.write('//===--- ')
     f.write(os.path.basename(filename))
     f.write(' - clang-tidy')
@@ -189,37 +189,6 @@ def adapt_module(module_path, module, check_name, check_name_camel):
       f.write(line)
 
 
-# Adds a release notes entry.
-def add_release_notes(module_path, module, check_name):
-  check_name_dashes = module + '-' + check_name
-  filename = os.path.normpath(os.path.join(module_path,
-                                           '../../docs/ReleaseNotes.rst'))
-  with open(filename, 'r') as f:
-    lines = f.readlines()
-
-  print('Updating %s...' % filename)
-  with open(filename, 'wb') as f:
-    note_added = False
-    header_found = False
-
-    for line in lines:
-      if not note_added:
-        match = re.search('Improvements to clang-tidy', line)
-        if match:
-          header_found = True
-        elif header_found:
-          if not line.startswith('----'):
-            f.write("""
-- New `%s
-  <http://clang.llvm.org/extra/clang-tidy/checks/%s.html>`_ check
-
-  FIXME: add release notes.
-""" % (check_name_dashes, check_name_dashes))
-            note_added = True
-
-      f.write(line)
-
-
 # Adds a test for the check.
 def write_test(module_path, module, check_name):
   check_name_dashes = module + '-' + check_name
@@ -331,7 +300,6 @@ documentation files."""
   write_header(module_path, module, check_name, check_name_camel)
   write_implementation(module_path, module, check_name_camel)
   adapt_module(module_path, module, check_name, check_name_camel)
-  add_release_notes(module_path, module, check_name)
   write_test(module_path, module, check_name)
   write_docs(module_path, module, check_name)
   update_checks_list(clang_tidy_path)

clang-tools-extra/clang-tidy/android/AndroidTidyModule.cpp

@@ -1,67 +0,0 @@
-//===--- AndroidTidyModule.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 "../ClangTidy.h"
-#include "../ClangTidyModule.h"
-#include "../ClangTidyModuleRegistry.h"
-#include "CloexecAccept4Check.h"
-#include "CloexecAcceptCheck.h"
-#include "CloexecCreatCheck.h"
-#include "CloexecEpollCreate1Check.h"
-#include "CloexecEpollCreateCheck.h"
-#include "CloexecDupCheck.h"
-#include "CloexecFopenCheck.h"
-#include "CloexecInotifyInit1Check.h"
-#include "CloexecInotifyInitCheck.h"
-#include "CloexecMemfdCreateCheck.h"
-#include "CloexecOpenCheck.h"
-#include "CloexecSocketCheck.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// This module is for Android specific checks.
-class AndroidModule : public ClangTidyModule {
-public:
-  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    CheckFactories.registerCheck<CloexecAccept4Check>("android-cloexec-accept4");
-    CheckFactories.registerCheck<CloexecAcceptCheck>("android-cloexec-accept");
-    CheckFactories.registerCheck<CloexecCreatCheck>("android-cloexec-creat");
-    CheckFactories.registerCheck<CloexecEpollCreate1Check>(
-        "android-cloexec-epoll-create1");
-    CheckFactories.registerCheck<CloexecEpollCreateCheck>(
-        "android-cloexec-epoll-create");
-    CheckFactories.registerCheck<CloexecDupCheck>("android-cloexec-dup");
-    CheckFactories.registerCheck<CloexecFopenCheck>("android-cloexec-fopen");
-    CheckFactories.registerCheck<CloexecInotifyInitCheck>(
-        "android-cloexec-inotify-init");
-    CheckFactories.registerCheck<CloexecInotifyInit1Check>(
-        "android-cloexec-inotify-init1");
-    CheckFactories.registerCheck<CloexecMemfdCreateCheck>(
-        "android-cloexec-memfd-create");
-    CheckFactories.registerCheck<CloexecOpenCheck>("android-cloexec-open");
-    CheckFactories.registerCheck<CloexecSocketCheck>("android-cloexec-socket");
-  }
-};
-
-// Register the AndroidTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<AndroidModule>
-    X("android-module", "Adds Android platform checks.");
-
-} // namespace android
-
-// This anchor is used to force the linker to link in the generated object file
-// and thus register the AndroidModule.
-volatile int AndroidModuleAnchorSource = 0;
-
-} // namespace tidy
-} // namespace clang

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

@@ -1,26 +0,0 @@
-set(LLVM_LINK_COMPONENTS support)
-
-add_clang_library(clangTidyAndroidModule
-  AndroidTidyModule.cpp
-  CloexecAccept4Check.cpp
-  CloexecAcceptCheck.cpp
-  CloexecCheck.cpp
-  CloexecCreatCheck.cpp
-  CloexecEpollCreate1Check.cpp
-  CloexecEpollCreateCheck.cpp
-  CloexecDupCheck.cpp
-  CloexecFopenCheck.cpp
-  CloexecInotifyInit1Check.cpp
-  CloexecInotifyInitCheck.cpp
-  CloexecMemfdCreateCheck.cpp
-  CloexecOpenCheck.cpp
-  CloexecSocketCheck.cpp
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangLex
-  clangTidy
-  clangTidyUtils
-  )

clang-tools-extra/clang-tidy/android/CloexecAccept4Check.cpp

@@ -1,40 +0,0 @@
-//===--- CloexecAccept4Check.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 "CloexecAccept4Check.h"
-#include "../utils/ASTUtils.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecAccept4Check::registerMatchers(MatchFinder *Finder) {
-  auto SockAddrPointerType =
-      hasType(pointsTo(recordDecl(isStruct(), hasName("sockaddr"))));
-  auto SockLenPointerType = hasType(pointsTo(namedDecl(hasName("socklen_t"))));
-
-  registerMatchersImpl(Finder,
-                       functionDecl(returns(isInteger()), hasName("accept4"),
-                                    hasParameter(0, hasType(isInteger())),
-                                    hasParameter(1, SockAddrPointerType),
-                                    hasParameter(2, SockLenPointerType),
-                                    hasParameter(3, hasType(isInteger()))));
-}
-
-void CloexecAccept4Check::check(const MatchFinder::MatchResult &Result) {
-  insertMacroFlag(Result, /*MarcoFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/3);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecAccept4Check.h

@@ -1,35 +0,0 @@
-//===--- CloexecAccept4Check.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_ANDROID_CLOEXEC_ACCEPT4_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT4_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// Finds code that uses accept4() without using the SOCK_CLOEXEC flag.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-accept4.html
-class CloexecAccept4Check : public CloexecCheck {
-public:
-  CloexecAccept4Check(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT4_H

clang-tools-extra/clang-tidy/android/CloexecAcceptCheck.cpp

@@ -1,47 +0,0 @@
-//===--- CloexecAcceptCheck.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 "CloexecAcceptCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecAcceptCheck::registerMatchers(MatchFinder *Finder) {
-  auto SockAddrPointerType =
-      hasType(pointsTo(recordDecl(isStruct(), hasName("sockaddr"))));
-  auto SockLenPointerType = hasType(pointsTo(namedDecl(hasName("socklen_t"))));
-
-  registerMatchersImpl(Finder,
-                       functionDecl(returns(isInteger()), hasName("accept"),
-                                    hasParameter(0, hasType(isInteger())),
-                                    hasParameter(1, SockAddrPointerType),
-                                    hasParameter(2, SockLenPointerType)));
-}
-
-void CloexecAcceptCheck::check(const MatchFinder::MatchResult &Result) {
-  const std::string &ReplacementText =
-      (Twine("accept4(") + getSpellingArg(Result, 0) + ", " +
-       getSpellingArg(Result, 1) + ", " + getSpellingArg(Result, 2) +
-       ", SOCK_CLOEXEC)")
-          .str();
-
-  replaceFunc(
-      Result,
-      "prefer accept4() to accept() because accept4() allows SOCK_CLOEXEC",
-      ReplacementText);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecAcceptCheck.h

@@ -1,35 +0,0 @@
-//===--- CloexecAcceptCheck.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_ANDROID_CLOEXEC_ACCEPT_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// accept() is better to be replaced by accept4().
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-accept.html
-class CloexecAcceptCheck : public CloexecCheck {
-public:
-  CloexecAcceptCheck(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT_H

clang-tools-extra/clang-tidy/android/CloexecCheck.cpp

@@ -1,114 +0,0 @@
-//===--- CloexecCheck.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 "CloexecCheck.h"
-#include "../utils/ASTUtils.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-namespace {
-// Helper function to form the correct string mode for Type3.
-// Build the replace text. If it's string constant, add <Mode> directly in the
-// end of the string. Else, add <Mode>.
-std::string buildFixMsgForStringFlag(const Expr *Arg, const SourceManager &SM,
-                                     const LangOptions &LangOpts, char Mode) {
-  if (Arg->getLocStart().isMacroID())
-    return (Lexer::getSourceText(
-                CharSourceRange::getTokenRange(Arg->getSourceRange()), SM,
-                LangOpts) +
-            " \"" + Twine(Mode) + "\"")
-        .str();
-
-  StringRef SR = cast<StringLiteral>(Arg->IgnoreParenCasts())->getString();
-  return ("\"" + SR + Twine(Mode) + "\"").str();
-}
-} // namespace
-
-const char *CloexecCheck::FuncDeclBindingStr = "funcDecl";
-
-const char *CloexecCheck::FuncBindingStr ="func";
-
-void CloexecCheck::registerMatchersImpl(
-    MatchFinder *Finder, internal::Matcher<FunctionDecl> Function) {
-  // We assume all the checked APIs are C functions.
-  Finder->addMatcher(
-      callExpr(
-          callee(functionDecl(isExternC(), Function).bind(FuncDeclBindingStr)))
-          .bind(FuncBindingStr),
-      this);
-}
-
-void CloexecCheck::insertMacroFlag(const MatchFinder::MatchResult &Result,
-                                   StringRef MacroFlag, int ArgPos) {
-  const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
-  const auto *FlagArg = MatchedCall->getArg(ArgPos);
-  const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>(FuncDeclBindingStr);
-  SourceManager &SM = *Result.SourceManager;
-
-  if (utils::exprHasBitFlagWithSpelling(FlagArg->IgnoreParenCasts(), SM,
-                                        Result.Context->getLangOpts(),
-                                        MacroFlag))
-    return;
-
-  SourceLocation EndLoc =
-      Lexer::getLocForEndOfToken(SM.getFileLoc(FlagArg->getLocEnd()), 0, SM,
-                                 Result.Context->getLangOpts());
-
-  diag(EndLoc, "%0 should use %1 where possible")
-      << FD << MacroFlag
-      << FixItHint::CreateInsertion(EndLoc, (Twine(" | ") + MacroFlag).str());
-}
-
-void CloexecCheck::replaceFunc(const MatchFinder::MatchResult &Result,
-                               StringRef WarningMsg, StringRef FixMsg) {
-  const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
-  diag(MatchedCall->getLocStart(), WarningMsg)
-      << FixItHint::CreateReplacement(MatchedCall->getSourceRange(), FixMsg);
-}
-
-void CloexecCheck::insertStringFlag(
-    const ast_matchers::MatchFinder::MatchResult &Result, const char Mode,
-    const int ArgPos) {
-  const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
-  const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>(FuncDeclBindingStr);
-  const auto *ModeArg = MatchedCall->getArg(ArgPos);
-
-  // Check if the <Mode> may be in the mode string.
-  const auto *ModeStr = dyn_cast<StringLiteral>(ModeArg->IgnoreParenCasts());
-  if (!ModeStr || (ModeStr->getString().find(Mode) != StringRef::npos))
-    return;
-
-  const std::string &ReplacementText = buildFixMsgForStringFlag(
-      ModeArg, *Result.SourceManager, Result.Context->getLangOpts(), Mode);
-
-  diag(ModeArg->getLocStart(), "use %0 mode '%1' to set O_CLOEXEC")
-      << FD << std::string(1, Mode)
-      << FixItHint::CreateReplacement(ModeArg->getSourceRange(),
-                                      ReplacementText);
-}
-
-StringRef CloexecCheck::getSpellingArg(const MatchFinder::MatchResult &Result,
-                                       int N) const {
-  const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
-  const SourceManager &SM = *Result.SourceManager;
-  return Lexer::getSourceText(
-      CharSourceRange::getTokenRange(MatchedCall->getArg(N)->getSourceRange()),
-      SM, Result.Context->getLangOpts());
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecCheck.h

@@ -1,105 +0,0 @@
-//===--- CloexecCheck.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.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// This file contains the declaration of the CloexecCheck class, which is the
-/// base class for all of the close-on-exec checks in Android module.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// \brief The base class for all close-on-exec checks in Android module.
-/// To be specific, there are some functions that need the close-on-exec flag to
-/// prevent the file descriptor leakage on fork+exec and this class provides
-/// utilities to identify and fix these C functions.
-class CloexecCheck : public ClangTidyCheck {
-public:
-  CloexecCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-
-protected:
-  void
-  registerMatchersImpl(ast_matchers::MatchFinder *Finder,
-                       ast_matchers::internal::Matcher<FunctionDecl> Function);
-
-  /// Currently, we have three types of fixes.
-  ///
-  /// Type1 is to insert the necessary macro flag in the flag argument. For
-  /// example, 'O_CLOEXEC' is required in function 'open()', so
-  /// \code
-  ///   open(file, O_RDONLY);
-  /// \endcode
-  /// should be
-  /// \code
-  ///   open(file, O_RDONLY | O_CLOEXE);
-  /// \endcode
-  ///
-  /// \param [out] Result MatchResult from AST matcher.
-  /// \param MacroFlag The macro name of the flag.
-  /// \param ArgPos The 0-based position of the flag argument.
-  void insertMacroFlag(const ast_matchers::MatchFinder::MatchResult &Result,
-                       StringRef MacroFlag, int ArgPos);
-
-  /// Type2 is to replace the API to another function that has required the
-  /// ability. For example:
-  /// \code
-  ///   creat(path, mode);
-  /// \endcode
-  /// should be
-  /// \code
-  ///   open(path, O_CREAT | O_WRONLY | O_TRUNC | O_CLOEXEC, mode)
-  /// \endcode
-  ///
-  /// \param [out] Result MatchResult from AST matcher.
-  /// \param WarningMsg The warning message.
-  /// \param FixMsg The fix message.
-  void replaceFunc(const ast_matchers::MatchFinder::MatchResult &Result,
-                   StringRef WarningMsg, StringRef FixMsg);
-
-  /// Type3 is also to add a flag to the corresponding argument, but this time,
-  /// the flag is some string and each char represents a mode rather than a
-  /// macro. For example, 'fopen' needs char 'e' in its mode argument string, so
-  /// \code
-  ///   fopen(in_file, "r");
-  /// \endcode
-  /// should be
-  /// \code
-  ///   fopen(in_file, "re");
-  /// \endcode
-  ///
-  /// \param [out] Result MatchResult from AST matcher.
-  /// \param Mode The required mode char.
-  /// \param ArgPos The 0-based position of the flag argument.
-  void insertStringFlag(const ast_matchers::MatchFinder::MatchResult &Result,
-                        const char Mode, const int ArgPos);
-
-  /// Helper function to get the spelling of a particular argument.
-  StringRef getSpellingArg(const ast_matchers::MatchFinder::MatchResult &Result,
-                           int N) const;
-
-  /// Binding name of the FuncDecl of a function call.
-  static const char *FuncDeclBindingStr;
-
-  /// Binding name of the function call expression.
-  static const char *FuncBindingStr;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_H

clang-tools-extra/clang-tidy/android/CloexecCreatCheck.cpp

@@ -1,43 +0,0 @@
-//===--- CloexecCreatCheck.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 "CloexecCreatCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecCreatCheck::registerMatchers(MatchFinder *Finder) {
-  auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter())));
-  auto MODETType = hasType(namedDecl(hasName("mode_t")));
-  registerMatchersImpl(Finder,
-                       functionDecl(isExternC(), returns(isInteger()),
-                                    hasName("creat"),
-                                    hasParameter(0, CharPointerType),
-                                    hasParameter(1, MODETType)));
-}
-
-void CloexecCreatCheck::check(const MatchFinder::MatchResult &Result) {
-  const std::string &ReplacementText =
-      (Twine("open (") + getSpellingArg(Result, 0) +
-       ", O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, " +
-       getSpellingArg(Result, 1) + ")")
-          .str();
-  replaceFunc(Result,
-              "prefer open() to creat() because open() allows O_CLOEXEC",
-              ReplacementText);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecCreatCheck.h

@@ -1,35 +0,0 @@
-//===--- CloexecCreatCheck.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_ANDROID_CLOEXEC_CREAT_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_CREAT_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// creat() is better to be replaced by open().
-/// Find the usage of creat() and redirect user to use open().
-
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-creat.html
-class CloexecCreatCheck : public CloexecCheck {
-public:
-  CloexecCreatCheck(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_CREAT_H

clang-tools-extra/clang-tidy/android/CloexecDupCheck.cpp

@@ -1,38 +0,0 @@
-//===--- CloexecDupCheck.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 "CloexecDupCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecDupCheck::registerMatchers(MatchFinder *Finder) {
-  registerMatchersImpl(Finder,
-                       functionDecl(returns(isInteger()), hasName("dup"),
-                                    hasParameter(0, hasType(isInteger()))));
-}
-
-void CloexecDupCheck::check(const MatchFinder::MatchResult &Result) {
-  const std::string &ReplacementText =
-      (Twine("fcntl(") + getSpellingArg(Result, 0) + ", F_DUPFD_CLOEXEC)")
-          .str();
-
-  replaceFunc(Result,
-              "prefer fcntl() to dup() because fcntl() allows F_DUPFD_CLOEXEC",
-              ReplacementText);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecDupCheck.h

@@ -1,36 +0,0 @@
-//===--- CloexecDupCheck.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_ANDROID_CLOEXEC_DUP_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_DUP_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// dup() is better to be replaced by fcntl(), which has close-on-exec flag.
-/// Find the usage of dup() and redirect user to use fcntl().
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-dup.html
-class CloexecDupCheck : public CloexecCheck {
-public:
-  CloexecDupCheck(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_DUP_H

clang-tools-extra/clang-tidy/android/CloexecEpollCreate1Check.cpp

@@ -1,33 +0,0 @@
-//===--- CloexecEpollCreate1Check.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 "CloexecEpollCreate1Check.h"
-#include "../utils/ASTUtils.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecEpollCreate1Check::registerMatchers(MatchFinder *Finder) {
-  registerMatchersImpl(
-      Finder, functionDecl(returns(isInteger()), hasName("epoll_create1"),
-                           hasParameter(0, hasType(isInteger()))));
-}
-
-void CloexecEpollCreate1Check::check(const MatchFinder::MatchResult &Result) {
-  insertMacroFlag(Result, /*MarcoFlag=*/"EPOLL_CLOEXEC", /*ArgPos=*/0);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecEpollCreate1Check.h

@@ -1,35 +0,0 @@
-//===--- CloexecEpollCreate1Check.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_ANDROID_CLOEXEC_EPOLL_CREATE1_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE1_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// Finds code that uses epoll_create1() without using the EPOLL_CLOEXEC flag.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-epoll-create1.html
-class CloexecEpollCreate1Check : public CloexecCheck {
-public:
-  CloexecEpollCreate1Check(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE1_H

clang-tools-extra/clang-tidy/android/CloexecEpollCreateCheck.cpp

@@ -1,36 +0,0 @@
-//===--- CloexecEpollCreateCheck.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 "CloexecEpollCreateCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecEpollCreateCheck::registerMatchers(MatchFinder *Finder) {
-  registerMatchersImpl(
-      Finder, functionDecl(returns(isInteger()), hasName("epoll_create"),
-                           hasParameter(0, hasType(isInteger()))));
-}
-
-void CloexecEpollCreateCheck::check(const MatchFinder::MatchResult &Result) {
-  replaceFunc(Result,
-              "prefer epoll_create() to epoll_create1() "
-              "because epoll_create1() allows "
-              "EPOLL_CLOEXEC",
-              "epoll_create1(EPOLL_CLOEXEC)");
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecEpollCreateCheck.h

@@ -1,35 +0,0 @@
-//===--- CloexecEpollCreateCheck.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_ANDROID_CLOEXEC_EPOLL_CREATE_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// epoll_create() is better to be replaced by epoll_create1().
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-epoll-create.html
-class CloexecEpollCreateCheck : public CloexecCheck {
-public:
-  CloexecEpollCreateCheck(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE_H

clang-tools-extra/clang-tidy/android/CloexecFopenCheck.cpp

@@ -1,36 +0,0 @@
-//===--- CloexecFopenCheck.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 "CloexecFopenCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/Type.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecFopenCheck::registerMatchers(MatchFinder *Finder) {
-  auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter())));
-  registerMatchersImpl(Finder,
-                       functionDecl(isExternC(), returns(asString("FILE *")),
-                                    hasName("fopen"),
-                                    hasParameter(0, CharPointerType),
-                                    hasParameter(1, CharPointerType)));
-}
-
-void CloexecFopenCheck::check(const MatchFinder::MatchResult &Result) {
-  insertStringFlag(Result, /*Mode=*/'e', /*ArgPos=*/1);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecFopenCheck.h

@@ -1,38 +0,0 @@
-//===--- CloexecFopenCheck.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_ANDROID_CLOEXEC_FOPEN_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_FOPEN_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// fopen() is suggested to include "e" in their mode string; like "re" would be
-/// better than "r".
-///
-/// This check only works when corresponding argument is StringLiteral. No
-/// constant propagation.
-///
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-fopen.html
-class CloexecFopenCheck : public CloexecCheck {
-public:
-  CloexecFopenCheck(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_FOPEN_H

clang-tools-extra/clang-tidy/android/CloexecInotifyInit1Check.cpp

@@ -1,33 +0,0 @@
-//===--- CloexecInotifyInit1Check.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 "CloexecInotifyInit1Check.h"
-#include "../utils/ASTUtils.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecInotifyInit1Check::registerMatchers(MatchFinder *Finder) {
-  registerMatchersImpl(
-      Finder, functionDecl(returns(isInteger()), hasName("inotify_init1"),
-                           hasParameter(0, hasType(isInteger()))));
-}
-
-void CloexecInotifyInit1Check::check(const MatchFinder::MatchResult &Result) {
-  insertMacroFlag(Result, /*MarcoFlag=*/"IN_CLOEXEC", /*ArgPos=*/0);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecInotifyInit1Check.h

@@ -1,35 +0,0 @@
-//===--- CloexecInotifyInit1Check.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_ANDROID_CLOEXEC_INOTIFY_INIT1_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT1_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// Finds code that uses inotify_init1() without using the IN_CLOEXEC flag.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-inotify-init1.html
-class CloexecInotifyInit1Check : public CloexecCheck {
-public:
-  CloexecInotifyInit1Check(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT1_H

clang-tools-extra/clang-tidy/android/CloexecInotifyInitCheck.cpp

@@ -1,34 +0,0 @@
-//===--- CloexecInotifyInitCheck.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 "CloexecInotifyInitCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecInotifyInitCheck::registerMatchers(MatchFinder *Finder) {
-  registerMatchersImpl(
-      Finder, functionDecl(returns(isInteger()), hasName("inotify_init")));
-}
-
-void CloexecInotifyInitCheck::check(const MatchFinder::MatchResult &Result) {
-  replaceFunc(Result, /*WarningMsg=*/
-              "prefer inotify_init() to inotify_init1() "
-              "because inotify_init1() allows IN_CLOEXEC",
-              /*FixMsg=*/"inotify_init1(IN_CLOEXEC)");
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecInotifyInitCheck.h

@@ -1,35 +0,0 @@
-//===--- CloexecInotifyInitCheck.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_ANDROID_CLOEXEC_INOTIFY_INIT_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// inotify_init() is better to be replaced by inotify_init1().
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-inotify-init.html
-class CloexecInotifyInitCheck : public CloexecCheck {
-public:
-  CloexecInotifyInitCheck(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT_H

clang-tools-extra/clang-tidy/android/CloexecMemfdCreateCheck.cpp

@@ -1,32 +0,0 @@
-//===--- CloexecMemfdCreateCheck.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 "CloexecMemfdCreateCheck.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecMemfdCreateCheck::registerMatchers(MatchFinder *Finder) {
-  auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter())));
-  registerMatchersImpl(
-      Finder, functionDecl(returns(isInteger()), hasName("memfd_create"),
-                           hasParameter(0, CharPointerType),
-                           hasParameter(1, hasType(isInteger()))));
-}
-
-void CloexecMemfdCreateCheck::check(const MatchFinder::MatchResult &Result) {
-  insertMacroFlag(Result, "MFD_CLOEXEC", /*ArgPos=*/1);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecMemfdCreateCheck.h

@@ -1,35 +0,0 @@
-//===--- CloexecMemfdCreateCheck.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_ANDROID_CLOEXEC_MEMFD_CREATE_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_MEMFD_CREATE_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// Finds code that uses memfd_create() without using the MFD_CLOEXEC flag.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-memfd-create.html
-class CloexecMemfdCreateCheck : public CloexecCheck {
-public:
-  CloexecMemfdCreateCheck(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_MEMFD_CREATE_H

clang-tools-extra/clang-tidy/android/CloexecOpenCheck.cpp

@@ -1,44 +0,0 @@
-//===--- CloexecOpenCheck.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 "CloexecOpenCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecOpenCheck::registerMatchers(MatchFinder *Finder) {
-  auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter())));
-  registerMatchersImpl(Finder,
-                       functionDecl(isExternC(), returns(isInteger()),
-                                    hasAnyName("open", "open64"),
-                                    hasParameter(0, CharPointerType),
-                                    hasParameter(1, hasType(isInteger()))));
-  registerMatchersImpl(Finder,
-                       functionDecl(isExternC(), returns(isInteger()),
-                                    hasName("openat"),
-                                    hasParameter(0, hasType(isInteger())),
-                                    hasParameter(1, CharPointerType),
-                                    hasParameter(2, hasType(isInteger()))));
-}
-
-void CloexecOpenCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>(FuncDeclBindingStr);
-  assert(FD->param_size() > 1);
-  int ArgPos = (FD->param_size() > 2) ? 2 : 1;
-  insertMacroFlag(Result, /*MarcoFlag=*/"O_CLOEXEC", ArgPos);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecOpenCheck.h

@@ -1,40 +0,0 @@
-//===--- CloexecOpenCheck.h - clang-tidy-----------------------------------===//
-//
-//                      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_ANDROID_CLOEXEC_OPEN_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_OPEN_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// Finds code that opens file without using the O_CLOEXEC flag.
-///
-/// open(), openat(), and open64() had better to include O_CLOEXEC in their
-/// flags argument. Only consider simple cases that the corresponding argument
-/// is constant or binary operation OR among constants like 'O_CLOEXEC' or
-/// 'O_CLOEXEC | O_RDONLY'. No constant propagation is performed.
-///
-/// Only the symbolic 'O_CLOEXEC' macro definition is checked, not the concrete
-/// value.
-class CloexecOpenCheck : public CloexecCheck {
-public:
-  CloexecOpenCheck(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_OPEN_H

clang-tools-extra/clang-tidy/android/CloexecSocketCheck.cpp

@@ -1,35 +0,0 @@
-//===--- CloexecSocketCheck.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 "CloexecSocketCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-void CloexecSocketCheck::registerMatchers(MatchFinder *Finder) {
-  registerMatchersImpl(Finder,
-                       functionDecl(isExternC(), returns(isInteger()),
-                                    hasName("socket"),
-                                    hasParameter(0, hasType(isInteger())),
-                                    hasParameter(1, hasType(isInteger())),
-                                    hasParameter(2, hasType(isInteger()))));
-}
-
-void CloexecSocketCheck::check(const MatchFinder::MatchResult &Result) {
-  insertMacroFlag(Result, /*MarcoFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/1);
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/android/CloexecSocketCheck.h

@@ -1,35 +0,0 @@
-//===--- CloexecSocketCheck.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_ANDROID_CLOEXEC_SOCKET_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_SOCKET_H
-
-#include "CloexecCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// Finds code that uses socket() without using the SOCK_CLOEXEC flag.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/android-cloexec-socket.html
-class CloexecSocketCheck : public CloexecCheck {
-public:
-  CloexecSocketCheck(StringRef Name, ClangTidyContext *Context)
-      : CloexecCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace android
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_SOCKET_H

clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp

@@ -1,308 +0,0 @@
-//===--- ArgumentCommentCheck.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 "ArgumentCommentCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Lex/Lexer.h"
-#include "clang/Lex/Token.h"
-#include "../utils/LexerUtils.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name,
-                                           ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      StrictMode(Options.getLocalOrGlobal("StrictMode", 0) != 0),
-      IdentRE("^(/\\* *)([_A-Za-z][_A-Za-z0-9]*)( *= *\\*/)$") {}
-
-void ArgumentCommentCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "StrictMode", StrictMode);
-}
-
-void ArgumentCommentCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      callExpr(unless(cxxOperatorCallExpr()),
-               // NewCallback's arguments relate to the pointed function, don't
-               // check them against NewCallback's parameter names.
-               // FIXME: Make this configurable.
-               unless(hasDeclaration(functionDecl(
-                   hasAnyName("NewCallback", "NewPermanentCallback")))))
-          .bind("expr"),
-      this);
-  Finder->addMatcher(cxxConstructExpr().bind("expr"), this);
-}
-
-static std::vector<std::pair<SourceLocation, StringRef>>
-getCommentsInRange(ASTContext *Ctx, CharSourceRange Range) {
-  std::vector<std::pair<SourceLocation, StringRef>> Comments;
-  auto &SM = Ctx->getSourceManager();
-  std::pair<FileID, unsigned> BeginLoc = SM.getDecomposedLoc(Range.getBegin()),
-                              EndLoc = SM.getDecomposedLoc(Range.getEnd());
-
-  if (BeginLoc.first != EndLoc.first)
-    return Comments;
-
-  bool Invalid = false;
-  StringRef Buffer = SM.getBufferData(BeginLoc.first, &Invalid);
-  if (Invalid)
-    return Comments;
-
-  const char *StrData = Buffer.data() + BeginLoc.second;
-
-  Lexer TheLexer(SM.getLocForStartOfFile(BeginLoc.first), Ctx->getLangOpts(),
-                 Buffer.begin(), StrData, Buffer.end());
-  TheLexer.SetCommentRetentionState(true);
-
-  while (true) {
-    Token Tok;
-    if (TheLexer.LexFromRawLexer(Tok))
-      break;
-    if (Tok.getLocation() == Range.getEnd() || Tok.is(tok::eof))
-      break;
-
-    if (Tok.is(tok::comment)) {
-      std::pair<FileID, unsigned> CommentLoc =
-          SM.getDecomposedLoc(Tok.getLocation());
-      assert(CommentLoc.first == BeginLoc.first);
-      Comments.emplace_back(
-          Tok.getLocation(),
-          StringRef(Buffer.begin() + CommentLoc.second, Tok.getLength()));
-    } else {
-      // Clear comments found before the different token, e.g. comma.
-      Comments.clear();
-    }
-  }
-
-  return Comments;
-}
-
-static std::vector<std::pair<SourceLocation, StringRef>>
-getCommentsBeforeLoc(ASTContext *Ctx, SourceLocation Loc) {
-  std::vector<std::pair<SourceLocation, StringRef>> Comments;
-  while (Loc.isValid()) {
-    clang::Token Tok =
-        utils::lexer::getPreviousToken(*Ctx, Loc, /*SkipComments=*/false);
-    if (Tok.isNot(tok::comment))
-      break;
-    Loc = Tok.getLocation();
-    Comments.emplace_back(
-        Loc,
-        Lexer::getSourceText(CharSourceRange::getCharRange(
-                                 Loc, Loc.getLocWithOffset(Tok.getLength())),
-                             Ctx->getSourceManager(), Ctx->getLangOpts()));
-  }
-  return Comments;
-}
-
-static bool isLikelyTypo(llvm::ArrayRef<ParmVarDecl *> Params,
-                         StringRef ArgName, unsigned ArgIndex) {
-  std::string ArgNameLowerStr = ArgName.lower();
-  StringRef ArgNameLower = ArgNameLowerStr;
-  // The threshold is arbitrary.
-  unsigned UpperBound = (ArgName.size() + 2) / 3 + 1;
-  unsigned ThisED = ArgNameLower.edit_distance(
-      Params[ArgIndex]->getIdentifier()->getName().lower(),
-      /*AllowReplacements=*/true, UpperBound);
-  if (ThisED >= UpperBound)
-    return false;
-
-  for (unsigned I = 0, E = Params.size(); I != E; ++I) {
-    if (I == ArgIndex)
-      continue;
-    IdentifierInfo *II = Params[I]->getIdentifier();
-    if (!II)
-      continue;
-
-    const unsigned Threshold = 2;
-    // Other parameters must be an edit distance at least Threshold more away
-    // from this parameter. This gives us greater confidence that this is a typo
-    // of this parameter and not one with a similar name.
-    unsigned OtherED = ArgNameLower.edit_distance(II->getName().lower(),
-                                                  /*AllowReplacements=*/true,
-                                                  ThisED + Threshold);
-    if (OtherED < ThisED + Threshold)
-      return false;
-  }
-
-  return true;
-}
-
-static bool sameName(StringRef InComment, StringRef InDecl, bool StrictMode) {
-  if (StrictMode)
-    return InComment == InDecl;
-  InComment = InComment.trim('_');
-  InDecl = InDecl.trim('_');
-  // FIXME: compare_lower only works for ASCII.
-  return InComment.compare_lower(InDecl) == 0;
-}
-
-static bool looksLikeExpectMethod(const CXXMethodDecl *Expect) {
-  return Expect != nullptr && Expect->getLocation().isMacroID() &&
-         Expect->getNameInfo().getName().isIdentifier() &&
-         Expect->getName().startswith("gmock_");
-}
-static bool areMockAndExpectMethods(const CXXMethodDecl *Mock,
-                                    const CXXMethodDecl *Expect) {
-  assert(looksLikeExpectMethod(Expect));
-  return Mock != nullptr && Mock->getNextDeclInContext() == Expect &&
-         Mock->getNumParams() == Expect->getNumParams() &&
-         Mock->getLocation().isMacroID() &&
-         Mock->getNameInfo().getName().isIdentifier() &&
-         Mock->getName() == Expect->getName().substr(strlen("gmock_"));
-}
-
-// This uses implementation details of MOCK_METHODx_ macros: for each mocked
-// method M it defines M() with appropriate signature and a method used to set
-// up expectations - gmock_M() - with each argument's type changed the
-// corresponding matcher. This function returns M when given either M or
-// gmock_M.
-static const CXXMethodDecl *findMockedMethod(const CXXMethodDecl *Method) {
-  if (looksLikeExpectMethod(Method)) {
-    const DeclContext *Ctx = Method->getDeclContext();
-    if (Ctx == nullptr || !Ctx->isRecord())
-      return nullptr;
-    for (const auto *D : Ctx->decls()) {
-      if (D->getNextDeclInContext() == Method) {
-        const auto *Previous = dyn_cast<CXXMethodDecl>(D);
-        return areMockAndExpectMethods(Previous, Method) ? Previous : nullptr;
-      }
-    }
-    return nullptr;
-  }
-  if (const auto *Next = dyn_cast_or_null<CXXMethodDecl>(
-                 Method->getNextDeclInContext())) {
-    if (looksLikeExpectMethod(Next) && areMockAndExpectMethods(Method, Next))
-      return Method;
-  }
-  return nullptr;
-}
-
-// For gmock expectation builder method (the target of the call generated by
-// `EXPECT_CALL(obj, Method(...))`) tries to find the real method being mocked
-// (returns nullptr, if the mock method doesn't override anything). For other
-// functions returns the function itself.
-static const FunctionDecl *resolveMocks(const FunctionDecl *Func) {
-  if (const auto *Method = dyn_cast<CXXMethodDecl>(Func)) {
-    if (const auto *MockedMethod = findMockedMethod(Method)) {
-      // If mocked method overrides the real one, we can use its parameter
-      // names, otherwise we're out of luck.
-      if (MockedMethod->size_overridden_methods() > 0) {
-        return *MockedMethod->begin_overridden_methods();
-      }
-      return nullptr;
-    }
-  }
-  return Func;
-}
-
-void ArgumentCommentCheck::checkCallArgs(ASTContext *Ctx,
-                                         const FunctionDecl *OriginalCallee,
-                                         SourceLocation ArgBeginLoc,
-                                         llvm::ArrayRef<const Expr *> Args) {
-  const FunctionDecl *Callee = resolveMocks(OriginalCallee);
-  if (!Callee)
-    return;
-
-  Callee = Callee->getFirstDecl();
-  unsigned NumArgs = std::min<unsigned>(Args.size(), Callee->getNumParams());
-  if (NumArgs == 0)
-    return;
-
-  auto makeFileCharRange = [Ctx](SourceLocation Begin, SourceLocation End) {
-    return Lexer::makeFileCharRange(CharSourceRange::getCharRange(Begin, End),
-                                    Ctx->getSourceManager(),
-                                    Ctx->getLangOpts());
-  };
-
-  for (unsigned I = 0; I < NumArgs; ++I) {
-    const ParmVarDecl *PVD = Callee->getParamDecl(I);
-    IdentifierInfo *II = PVD->getIdentifier();
-    if (!II)
-      continue;
-    if (auto Template = Callee->getTemplateInstantiationPattern()) {
-      // Don't warn on arguments for parameters instantiated from template
-      // parameter packs. If we find more arguments than the template
-      // definition has, it also means that they correspond to a parameter
-      // pack.
-      if (Template->getNumParams() <= I ||
-          Template->getParamDecl(I)->isParameterPack()) {
-        continue;
-      }
-    }
-
-    CharSourceRange BeforeArgument =
-        makeFileCharRange(ArgBeginLoc, Args[I]->getLocStart());
-    ArgBeginLoc = Args[I]->getLocEnd();
-
-    std::vector<std::pair<SourceLocation, StringRef>> Comments;
-    if (BeforeArgument.isValid()) {
-      Comments = getCommentsInRange(Ctx, BeforeArgument);
-    } else {
-      // Fall back to parsing back from the start of the argument.
-      CharSourceRange ArgsRange = makeFileCharRange(
-          Args[I]->getLocStart(), Args[NumArgs - 1]->getLocEnd());
-      Comments = getCommentsBeforeLoc(Ctx, ArgsRange.getBegin());
-    }
-
-    for (auto Comment : Comments) {
-      llvm::SmallVector<StringRef, 2> Matches;
-      if (IdentRE.match(Comment.second, &Matches) &&
-          !sameName(Matches[2], II->getName(), StrictMode)) {
-        {
-          DiagnosticBuilder Diag =
-              diag(Comment.first, "argument name '%0' in comment does not "
-                                  "match parameter name %1")
-              << Matches[2] << II;
-          if (isLikelyTypo(Callee->parameters(), Matches[2], I)) {
-            Diag << FixItHint::CreateReplacement(
-                Comment.first, (Matches[1] + II->getName() + Matches[3]).str());
-          }
-        }
-        diag(PVD->getLocation(), "%0 declared here", DiagnosticIDs::Note) << II;
-        if (OriginalCallee != Callee) {
-          diag(OriginalCallee->getLocation(),
-               "actual callee (%0) is declared here", DiagnosticIDs::Note)
-              << OriginalCallee;
-        }
-      }
-    }
-  }
-}
-
-void ArgumentCommentCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
-  if (const auto *Call = dyn_cast<CallExpr>(E)) {
-    const FunctionDecl *Callee = Call->getDirectCallee();
-    if (!Callee)
-      return;
-
-    checkCallArgs(Result.Context, Callee, Call->getCallee()->getLocEnd(),
-                  llvm::makeArrayRef(Call->getArgs(), Call->getNumArgs()));
-  } else {
-    const auto *Construct = cast<CXXConstructExpr>(E);
-    if (Construct->getNumArgs() == 1 &&
-        Construct->getArg(0)->getSourceRange() == Construct->getSourceRange()) {
-      // Ignore implicit construction.
-      return;
-    }
-    checkCallArgs(
-        Result.Context, Construct->getConstructor(),
-        Construct->getParenOrBraceRange().getBegin(),
-        llvm::makeArrayRef(Construct->getArgs(), Construct->getNumArgs()));
-  }
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

@@ -1,86 +0,0 @@
-//===--- BugproneTidyModule.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 "../ClangTidy.h"
-#include "../ClangTidyModule.h"
-#include "../ClangTidyModuleRegistry.h"
-#include "ArgumentCommentCheck.h"
-#include "AssertSideEffectCheck.h"
-#include "BoolPointerImplicitConversionCheck.h"
-#include "CopyConstructorInitCheck.h"
-#include "DanglingHandleCheck.h"
-#include "FoldInitTypeCheck.h"
-#include "ForwardDeclarationNamespaceCheck.h"
-#include "InaccurateEraseCheck.h"
-#include "IntegerDivisionCheck.h"
-#include "MisplacedOperatorInStrlenInAllocCheck.h"
-#include "MoveForwardingReferenceCheck.h"
-#include "MultipleStatementMacroCheck.h"
-#include "StringConstructorCheck.h"
-#include "SuspiciousMemsetUsageCheck.h"
-#include "UndefinedMemoryManipulationCheck.h"
-#include "UseAfterMoveCheck.h"
-#include "VirtualNearMissCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-class BugproneModule : public ClangTidyModule {
-public:
-  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    CheckFactories.registerCheck<ArgumentCommentCheck>(
-        "bugprone-argument-comment");
-    CheckFactories.registerCheck<AssertSideEffectCheck>(
-        "bugprone-assert-side-effect");
-    CheckFactories.registerCheck<BoolPointerImplicitConversionCheck>(
-        "bugprone-bool-pointer-implicit-conversion");
-    CheckFactories.registerCheck<CopyConstructorInitCheck>(
-        "bugprone-copy-constructor-init");
-    CheckFactories.registerCheck<DanglingHandleCheck>(
-        "bugprone-dangling-handle");
-    CheckFactories.registerCheck<FoldInitTypeCheck>(
-        "bugprone-fold-init-type");
-    CheckFactories.registerCheck<ForwardDeclarationNamespaceCheck>(
-        "bugprone-forward-declaration-namespace");
-    CheckFactories.registerCheck<InaccurateEraseCheck>(
-        "bugprone-inaccurate-erase");
-    CheckFactories.registerCheck<IntegerDivisionCheck>(
-        "bugprone-integer-division");
-    CheckFactories.registerCheck<MisplacedOperatorInStrlenInAllocCheck>(
-        "bugprone-misplaced-operator-in-strlen-in-alloc");
-    CheckFactories.registerCheck<MoveForwardingReferenceCheck>(
-        "bugprone-move-forwarding-reference");
-    CheckFactories.registerCheck<MultipleStatementMacroCheck>(
-        "bugprone-multiple-statement-macro");
-    CheckFactories.registerCheck<StringConstructorCheck>(
-        "bugprone-string-constructor");
-    CheckFactories.registerCheck<SuspiciousMemsetUsageCheck>(
-        "bugprone-suspicious-memset-usage");
-    CheckFactories.registerCheck<UndefinedMemoryManipulationCheck>(
-        "bugprone-undefined-memory-manipulation");
-    CheckFactories.registerCheck<UseAfterMoveCheck>(
-        "bugprone-use-after-move");
-    CheckFactories.registerCheck<VirtualNearMissCheck>(
-        "bugprone-virtual-near-miss");
-  }
-};
-
-} // namespace bugprone
-
-// Register the BugproneTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<bugprone::BugproneModule>
-    X("bugprone-module", "Adds checks for bugprone code constructs.");
-
-// This anchor is used to force the linker to link in the generated object file
-// and thus register the BugproneModule.
-volatile int BugproneModuleAnchorSource = 0;
-
-} // namespace tidy
-} // namespace clang

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

@@ -1,32 +0,0 @@
-set(LLVM_LINK_COMPONENTS support)
-
-add_clang_library(clangTidyBugproneModule
-  ArgumentCommentCheck.cpp
-  AssertSideEffectCheck.cpp
-  BoolPointerImplicitConversionCheck.cpp
-  BugproneTidyModule.cpp
-  CopyConstructorInitCheck.cpp
-  DanglingHandleCheck.cpp
-  FoldInitTypeCheck.cpp
-  ForwardDeclarationNamespaceCheck.cpp
-  InaccurateEraseCheck.cpp
-  IntegerDivisionCheck.cpp
-  MisplacedOperatorInStrlenInAllocCheck.cpp
-  MoveForwardingReferenceCheck.cpp
-  MultipleStatementMacroCheck.cpp
-  StringConstructorCheck.cpp
-  SuspiciousMemsetUsageCheck.cpp
-  UndefinedMemoryManipulationCheck.cpp
-  UseAfterMoveCheck.cpp
-  VirtualNearMissCheck.cpp
-
-  LINK_LIBS
-  clangAnalysis
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangLex
-  clangTidy
-  clangTidyUtils
-  clangTooling
-  )

clang-tools-extra/clang-tidy/bugprone/CopyConstructorInitCheck.cpp

@@ -1,121 +0,0 @@
-//===--- CopyConstructorInitCheck.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 "CopyConstructorInitCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-void CopyConstructorInitCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  // In the future this might be extended to move constructors?
-  Finder->addMatcher(
-      cxxConstructorDecl(
-          isCopyConstructor(),
-          hasAnyConstructorInitializer(cxxCtorInitializer(
-              isBaseInitializer(),
-              withInitializer(cxxConstructExpr(hasDeclaration(
-                  cxxConstructorDecl(isDefaultConstructor())))))),
-          unless(isInstantiated()))
-          .bind("ctor"),
-      this);
-}
-
-void CopyConstructorInitCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
-  std::string ParamName = Ctor->getParamDecl(0)->getNameAsString();
-
-  // We want only one warning (and FixIt) for each ctor.
-  std::string FixItInitList;
-  bool HasRelevantBaseInit = false;
-  bool ShouldNotDoFixit = false;
-  bool HasWrittenInitializer = false;
-  SmallVector<FixItHint, 2> SafeFixIts;
-  for (const auto *Init : Ctor->inits()) {
-    bool CtorInitIsWritten = Init->isWritten();
-    HasWrittenInitializer = HasWrittenInitializer || CtorInitIsWritten;
-    if (!Init->isBaseInitializer())
-      continue;
-    const Type *BaseType = Init->getBaseClass();
-    // Do not do fixits if there is a type alias involved or one of the bases
-    // are explicitly initialized. In the latter case we not do fixits to avoid
-    // -Wreorder warnings.
-    if (const auto *TempSpecTy = dyn_cast<TemplateSpecializationType>(BaseType))
-      ShouldNotDoFixit = ShouldNotDoFixit || TempSpecTy->isTypeAlias();
-    ShouldNotDoFixit = ShouldNotDoFixit || isa<TypedefType>(BaseType);
-    ShouldNotDoFixit = ShouldNotDoFixit || CtorInitIsWritten;
-    const CXXRecordDecl *BaseClass =
-        BaseType->getAsCXXRecordDecl()->getDefinition();
-    if (BaseClass->field_empty() &&
-        BaseClass->forallBases(
-            [](const CXXRecordDecl *Class) { return Class->field_empty(); }))
-      continue;
-    bool NonCopyableBase = false;
-    for (const auto *Ctor : BaseClass->ctors()) {
-      if (Ctor->isCopyConstructor() &&
-          (Ctor->getAccess() == AS_private || Ctor->isDeleted())) {
-        NonCopyableBase = true;
-        break;
-      }
-    }
-    if (NonCopyableBase)
-      continue;
-    const auto *CExpr = dyn_cast<CXXConstructExpr>(Init->getInit());
-    if (!CExpr || !CExpr->getConstructor()->isDefaultConstructor())
-      continue;
-    HasRelevantBaseInit = true;
-    if (CtorInitIsWritten) {
-      if (!ParamName.empty())
-        SafeFixIts.push_back(
-            FixItHint::CreateInsertion(CExpr->getLocEnd(), ParamName));
-    } else {
-      if (Init->getSourceLocation().isMacroID() ||
-          Ctor->getLocation().isMacroID() || ShouldNotDoFixit)
-        break;
-      FixItInitList += BaseClass->getNameAsString();
-      FixItInitList += "(" + ParamName + "), ";
-    }
-  }
-  if (!HasRelevantBaseInit)
-    return;
-
-  auto Diag = diag(Ctor->getLocation(),
-                   "calling a base constructor other than the copy constructor")
-              << SafeFixIts;
-
-  if (FixItInitList.empty() || ParamName.empty() || ShouldNotDoFixit)
-    return;
-
-  std::string FixItMsg{FixItInitList.substr(0, FixItInitList.size() - 2)};
-  SourceLocation FixItLoc;
-  // There is no initialization list in this constructor.
-  if (!HasWrittenInitializer) {
-    FixItLoc = Ctor->getBody()->getLocStart();
-    FixItMsg = " : " + FixItMsg;
-  } else {
-    // We apply the missing ctors at the beginning of the initialization list.
-    FixItLoc = (*Ctor->init_begin())->getSourceLocation();
-    FixItMsg += ',';
-  }
-  FixItMsg += ' ';
-
-  Diag << FixItHint::CreateInsertion(FixItLoc, FixItMsg);
-} // namespace misc
-
-} // namespace misc
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/bugprone/CopyConstructorInitCheck.h

@@ -1,36 +0,0 @@
-//===--- CopyConstructorInitCheck.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_BUGPRONE_COPY_CONSTRUCTOR_INIT_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_COPY_CONSTRUCTOR_INIT_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds copy constructors where the ctor don't call the copy constructor of
-/// the base class.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/misc-copy-constructor-init.html
-class CopyConstructorInitCheck : public ClangTidyCheck {
-public:
-  CopyConstructorInitCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace misc
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_COPY_CONSTRUCTOR_INIT_H

clang-tools-extra/clang-tidy/bugprone/InaccurateEraseCheck.cpp

@@ -1,81 +0,0 @@
-//===--- InaccurateEraseCheck.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 "InaccurateEraseCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-namespace {
-AST_MATCHER(Decl, isInStdNamespace) { return Node.isInStdNamespace(); }
-}
-
-void InaccurateEraseCheck::registerMatchers(MatchFinder *Finder) {
-  // Only register the matchers for C++; the functionality currently does not
-  // provide any benefit to other languages, despite being benign.
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  const auto EndCall =
-      callExpr(
-          callee(functionDecl(hasAnyName("remove", "remove_if", "unique"))),
-          hasArgument(
-              1,
-              anyOf(cxxConstructExpr(has(ignoringImplicit(
-                        cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))
-                            .bind("end")))),
-                    anything())))
-          .bind("alg");
-
-  const auto DeclInStd = type(hasUnqualifiedDesugaredType(
-      tagType(hasDeclaration(decl(isInStdNamespace())))));
-  Finder->addMatcher(
-      cxxMemberCallExpr(
-          on(anyOf(hasType(DeclInStd), hasType(pointsTo(DeclInStd)))),
-          callee(cxxMethodDecl(hasName("erase"))), argumentCountIs(1),
-          hasArgument(0, has(ignoringImplicit(
-                             anyOf(EndCall, has(ignoringImplicit(EndCall)))))),
-          unless(isInTemplateInstantiation()))
-          .bind("erase"),
-      this);
-}
-
-void InaccurateEraseCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *MemberCall =
-      Result.Nodes.getNodeAs<CXXMemberCallExpr>("erase");
-  const auto *EndExpr =
-      Result.Nodes.getNodeAs<CXXMemberCallExpr>("end");
-  const SourceLocation Loc = MemberCall->getLocStart();
-
-  FixItHint Hint;
-
-  if (!Loc.isMacroID() && EndExpr) {
-    const auto *AlgCall = Result.Nodes.getNodeAs<CallExpr>("alg");
-    std::string ReplacementText = Lexer::getSourceText(
-        CharSourceRange::getTokenRange(EndExpr->getSourceRange()),
-        *Result.SourceManager, getLangOpts());
-    const SourceLocation EndLoc = Lexer::getLocForEndOfToken(
-        AlgCall->getLocEnd(), 0, *Result.SourceManager, getLangOpts());
-    Hint = FixItHint::CreateInsertion(EndLoc, ", " + ReplacementText);
-  }
-
-  diag(Loc, "this call will remove at most one item even when multiple items "
-            "should be removed")
-      << Hint;
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/bugprone/IntegerDivisionCheck.cpp

@@ -1,57 +0,0 @@
-//===--- IntegerDivisionCheck.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 "IntegerDivisionCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-void IntegerDivisionCheck::registerMatchers(MatchFinder *Finder) {
-  const auto IntType = hasType(isInteger());
-
-  const auto BinaryOperators = binaryOperator(anyOf(
-      hasOperatorName("%"), hasOperatorName("<<"), hasOperatorName(">>"),
-      hasOperatorName("<<"), hasOperatorName("^"), hasOperatorName("|"),
-      hasOperatorName("&"), hasOperatorName("||"), hasOperatorName("&&"),
-      hasOperatorName("<"), hasOperatorName(">"), hasOperatorName("<="),
-      hasOperatorName(">="), hasOperatorName("=="), hasOperatorName("!=")));
-
-  const auto UnaryOperators =
-      unaryOperator(anyOf(hasOperatorName("~"), hasOperatorName("!")));
-
-  const auto Exceptions =
-      anyOf(BinaryOperators, conditionalOperator(), binaryConditionalOperator(),
-            callExpr(IntType), explicitCastExpr(IntType), UnaryOperators);
-
-  Finder->addMatcher(
-      binaryOperator(
-          hasOperatorName("/"), hasLHS(expr(IntType)), hasRHS(expr(IntType)),
-          hasAncestor(
-              castExpr(hasCastKind(CK_IntegralToFloating)).bind("FloatCast")),
-          unless(hasAncestor(
-              expr(Exceptions,
-                   hasAncestor(castExpr(equalsBoundNode("FloatCast")))))))
-          .bind("IntDiv"),
-      this);
-}
-
-void IntegerDivisionCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *IntDiv = Result.Nodes.getNodeAs<BinaryOperator>("IntDiv");
-  diag(IntDiv->getLocStart(), "result of integer division used in a floating "
-                              "point context; possible loss of precision");
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/bugprone/IntegerDivisionCheck.h

@@ -1,36 +0,0 @@
-//===--- IntegerDivisionCheck.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_BUGPRONE_INTEGER_DIVISION_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INTEGER_DIVISION_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds cases where integer division in a floating point context is likely to
-/// cause unintended loss of precision.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-integer-division.html
-class IntegerDivisionCheck : public ClangTidyCheck {
-public:
-  IntegerDivisionCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INTEGER_DIVISION_H

clang-tools-extra/clang-tidy/bugprone/MisplacedOperatorInStrlenInAllocCheck.cpp

@@ -1,112 +0,0 @@
-//===--- MisplacedOperatorInStrlenInAllocCheck.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 "MisplacedOperatorInStrlenInAllocCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-void MisplacedOperatorInStrlenInAllocCheck::registerMatchers(
-    MatchFinder *Finder) {
-  const auto StrLenFunc = functionDecl(anyOf(
-      hasName("::strlen"), hasName("::std::strlen"), hasName("::strnlen"),
-      hasName("::std::strnlen"), hasName("::strnlen_s"),
-      hasName("::std::strnlen_s"), hasName("::wcslen"),
-      hasName("::std::wcslen"), hasName("::wcsnlen"), hasName("::std::wcsnlen"),
-      hasName("::wcsnlen_s"), hasName("std::wcsnlen_s")));
-
-  const auto BadUse =
-      callExpr(callee(StrLenFunc),
-               hasAnyArgument(ignoringImpCasts(
-                   binaryOperator(allOf(hasOperatorName("+"),
-                                        hasRHS(ignoringParenImpCasts(
-                                            integerLiteral(equals(1))))))
-                       .bind("BinOp"))))
-          .bind("StrLen");
-
-  const auto BadArg = anyOf(
-      allOf(hasDescendant(BadUse),
-            unless(binaryOperator(allOf(
-                hasOperatorName("+"), hasLHS(BadUse),
-                hasRHS(ignoringParenImpCasts(integerLiteral(equals(1)))))))),
-      BadUse);
-
-  const auto Alloc0Func =
-      functionDecl(anyOf(hasName("::malloc"), hasName("std::malloc"),
-                         hasName("::alloca"), hasName("std::alloca")));
-  const auto Alloc1Func =
-      functionDecl(anyOf(hasName("::calloc"), hasName("std::calloc"),
-                         hasName("::realloc"), hasName("std::realloc")));
-
-  const auto Alloc0FuncPtr =
-      varDecl(hasType(isConstQualified()),
-              hasInitializer(ignoringParenImpCasts(
-                  declRefExpr(hasDeclaration(Alloc0Func)))));
-  const auto Alloc1FuncPtr =
-      varDecl(hasType(isConstQualified()),
-              hasInitializer(ignoringParenImpCasts(
-                  declRefExpr(hasDeclaration(Alloc1Func)))));
-
-  Finder->addMatcher(callExpr(callee(decl(anyOf(Alloc0Func, Alloc0FuncPtr))),
-                              hasArgument(0, BadArg))
-                         .bind("Alloc"),
-                     this);
-  Finder->addMatcher(callExpr(callee(decl(anyOf(Alloc1Func, Alloc1FuncPtr))),
-                              hasArgument(1, BadArg))
-                         .bind("Alloc"),
-                     this);
-  Finder->addMatcher(
-      cxxNewExpr(isArray(), hasArraySize(BadArg)).bind("Alloc"), this);
-}
-
-void MisplacedOperatorInStrlenInAllocCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  const Expr *Alloc = Result.Nodes.getNodeAs<CallExpr>("Alloc");
-  if (!Alloc)
-    Alloc = Result.Nodes.getNodeAs<CXXNewExpr>("Alloc");
-  assert(Alloc && "Matched node bound by 'Alloc' shoud be either 'CallExpr'"
-         " or 'CXXNewExpr'");
-
-  const auto *StrLen = Result.Nodes.getNodeAs<CallExpr>("StrLen");
-  const auto *BinOp = Result.Nodes.getNodeAs<BinaryOperator>("BinOp");
-
-  const StringRef StrLenText = Lexer::getSourceText(
-      CharSourceRange::getTokenRange(StrLen->getSourceRange()),
-      *Result.SourceManager, getLangOpts());
-  const StringRef Arg0Text = Lexer::getSourceText(
-      CharSourceRange::getTokenRange(StrLen->getArg(0)->getSourceRange()),
-      *Result.SourceManager, getLangOpts());
-  const StringRef StrLenBegin = StrLenText.substr(0, StrLenText.find(Arg0Text));
-  const StringRef StrLenEnd = StrLenText.substr(
-      StrLenText.find(Arg0Text) + Arg0Text.size(), StrLenText.size());
-
-  const StringRef LHSText = Lexer::getSourceText(
-      CharSourceRange::getTokenRange(BinOp->getLHS()->getSourceRange()),
-      *Result.SourceManager, getLangOpts());
-  const StringRef RHSText = Lexer::getSourceText(
-      CharSourceRange::getTokenRange(BinOp->getRHS()->getSourceRange()),
-      *Result.SourceManager, getLangOpts());
-
-  auto Hint = FixItHint::CreateReplacement(
-      StrLen->getSourceRange(),
-      (StrLenBegin + LHSText + StrLenEnd + " + " + RHSText).str());
-
-  diag(Alloc->getLocStart(),
-       "addition operator is applied to the argument of %0 instead of its "
-       "result") << StrLen->getDirectCallee()->getName() << Hint;
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/bugprone/MisplacedOperatorInStrlenInAllocCheck.h

@@ -1,37 +0,0 @@
-//===--- MisplacedOperatorInStrlenInAllocCheck.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_BUGPRONE_MISPLACED_OPERATOR_IN_STRLEN_IN_ALLOC_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MISPLACED_OPERATOR_IN_STRLEN_IN_ALLOC_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds cases where ``1`` is added to the string in the argument to a function
-/// in the ``strlen()`` family instead of the result and value is used as an
-/// argument to a memory allocation function.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-misplaced-operator-in-strlen-in-alloc.html
-class MisplacedOperatorInStrlenInAllocCheck : public ClangTidyCheck {
-public:
-  MisplacedOperatorInStrlenInAllocCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MISPLACED_OPERATOR_IN_STRLEN_IN_ALLOC_H

clang-tools-extra/clang-tidy/bugprone/MultipleStatementMacroCheck.h

@@ -1,37 +0,0 @@
-//===--- MultipleStatementMacroCheck.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_BUGPRONE_MULTIPLE_STATEMENT_MACRO_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MULTIPLE_STATEMENT_MACRO_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Detect multiple statement macros that are used in unbraced conditionals.
-/// Only the first statement of the macro will be inside the conditional and the
-/// other ones will be executed unconditionally.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-multiple-statement-macro.html
-class MultipleStatementMacroCheck : public ClangTidyCheck {
-public:
-  MultipleStatementMacroCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MULTIPLE_STATEMENT_MACRO_H

clang-tools-extra/clang-tidy/bugprone/StringConstructorCheck.h

@@ -1,39 +0,0 @@
-//===--- StringConstructorCheck.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_BUGPRONE_STRING_CONSTRUCTOR_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRING_CONSTRUCTOR_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds suspicious string constructor and check their parameters.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-string-constructor.html
-class StringConstructorCheck : public ClangTidyCheck {
-public:
-  StringConstructorCheck(StringRef Name, ClangTidyContext *Context);
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-
-private:
-  const bool WarnOnLargeLength;
-  const unsigned int LargeLengthThreshold;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRING_CONSTRUCTOR_H

clang-tools-extra/clang-tidy/bugprone/SuspiciousMemsetUsageCheck.cpp

@@ -1,127 +0,0 @@
-//===--- SuspiciousMemsetUsageCheck.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 "SuspiciousMemsetUsageCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Lex/Lexer.h"
-#include "clang/Tooling/FixIt.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-void SuspiciousMemsetUsageCheck::registerMatchers(MatchFinder *Finder) {
-  // Note: void *memset(void *buffer, int fill_char, size_t byte_count);
-  // Look for memset(x, '0', z). Probably memset(x, 0, z) was intended.
-  Finder->addMatcher(
-      callExpr(
-          callee(functionDecl(hasName("::memset"))),
-          hasArgument(1, characterLiteral(equals(static_cast<unsigned>('0')))
-                             .bind("char-zero-fill")),
-          unless(
-              eachOf(hasArgument(0, anyOf(hasType(pointsTo(isAnyCharacter())),
-                                          hasType(arrayType(hasElementType(
-                                              isAnyCharacter()))))),
-                     isInTemplateInstantiation()))),
-      this);
-
-  // Look for memset with an integer literal in its fill_char argument.
-  // Will check if it gets truncated.
-  Finder->addMatcher(callExpr(callee(functionDecl(hasName("::memset"))),
-                              hasArgument(1, integerLiteral().bind("num-fill")),
-                              unless(isInTemplateInstantiation())),
-                     this);
-
-  // Look for memset(x, y, 0) as that is most likely an argument swap.
-  Finder->addMatcher(
-      callExpr(callee(functionDecl(hasName("::memset"))),
-               unless(hasArgument(1, anyOf(characterLiteral(equals(
-                                               static_cast<unsigned>('0'))),
-                                           integerLiteral()))),
-               unless(isInTemplateInstantiation()))
-          .bind("call"),
-      this);
-}
-
-void SuspiciousMemsetUsageCheck::check(const MatchFinder::MatchResult &Result) {
-  if (const auto *CharZeroFill =
-          Result.Nodes.getNodeAs<CharacterLiteral>("char-zero-fill")) {
-    // Case 1: fill_char of memset() is a character '0'. Probably an
-    // integer zero was intended.
-
-    SourceRange CharRange = CharZeroFill->getSourceRange();
-    auto Diag =
-        diag(CharZeroFill->getLocStart(), "memset fill value is char '0', "
-                                          "potentially mistaken for int 0");
-
-    // Only suggest a fix if no macros are involved.
-    if (CharRange.getBegin().isMacroID())
-      return;
-    Diag << FixItHint::CreateReplacement(
-        CharSourceRange::getTokenRange(CharRange), "0");
-  }
-
-  else if (const auto *NumFill =
-               Result.Nodes.getNodeAs<IntegerLiteral>("num-fill")) {
-    // Case 2: fill_char of memset() is larger in size than an unsigned char
-    // so it gets truncated during conversion.
-
-    llvm::APSInt NumValue;
-    const auto UCharMax = (1 << Result.Context->getCharWidth()) - 1;
-    if (!NumFill->EvaluateAsInt(NumValue, *Result.Context) ||
-        (NumValue >= 0 && NumValue <= UCharMax))
-      return;
-
-    diag(NumFill->getLocStart(), "memset fill value is out of unsigned "
-                                 "character range, gets truncated");
-  }
-
-  else if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
-    // Case 3: byte_count of memset() is zero. This is most likely an
-    // argument swap.
-
-    const Expr *FillChar = Call->getArg(1);
-    const Expr *ByteCount = Call->getArg(2);
-
-    // Return if `byte_count` is not zero at compile time.
-    llvm::APSInt Value1, Value2;
-    if (ByteCount->isValueDependent() ||
-        !ByteCount->EvaluateAsInt(Value2, *Result.Context) || Value2 != 0)
-      return;
-
-    // Return if `fill_char` is known to be zero or negative at compile
-    // time. In these cases, swapping the args would be a nop, or
-    // introduce a definite bug. The code is likely correct.
-    if (!FillChar->isValueDependent() &&
-        FillChar->EvaluateAsInt(Value1, *Result.Context) &&
-        (Value1 == 0 || Value1.isNegative()))
-      return;
-
-    // `byte_count` is known to be zero at compile time, and `fill_char` is
-    // either not known or known to be a positive integer. Emit a warning
-    // and fix-its to swap the arguments.
-    auto D = diag(Call->getLocStart(),
-                  "memset of size zero, potentially swapped arguments");
-    StringRef RHSString = tooling::fixit::getText(*ByteCount, *Result.Context);
-    StringRef LHSString = tooling::fixit::getText(*FillChar, *Result.Context);
-    if (LHSString.empty() || RHSString.empty())
-      return;
-
-    D << tooling::fixit::createReplacement(*FillChar, RHSString)
-      << tooling::fixit::createReplacement(*ByteCount, LHSString);
-  }
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/bugprone/SuspiciousMemsetUsageCheck.h

@@ -1,35 +0,0 @@
-//===--- SuspiciousMemsetUsageCheck.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_BUGPRONE_SUSPICIOUS_MEMSET_USAGE_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUS_MEMSET_USAGE_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds memset calls with potential mistakes in their arguments.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-memset-usage.html
-class SuspiciousMemsetUsageCheck : public ClangTidyCheck {
-public:
-  SuspiciousMemsetUsageCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUS_MEMSET_USAGE_H

clang-tools-extra/clang-tidy/bugprone/UndefinedMemoryManipulationCheck.cpp

@@ -1,71 +0,0 @@
-//===--- UndefinedMemoryManipulationCheck.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 "UndefinedMemoryManipulationCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-namespace {
-AST_MATCHER(CXXRecordDecl, isNotTriviallyCopyable) {
-  // For incomplete types, assume they are TriviallyCopyable.
-  return Node.hasDefinition() ? !Node.isTriviallyCopyable() : false;
-}
-} // namespace
-
-void UndefinedMemoryManipulationCheck::registerMatchers(MatchFinder *Finder) {
-  const auto NotTriviallyCopyableObject =
-      hasType(ast_matchers::hasCanonicalType(
-          pointsTo(cxxRecordDecl(isNotTriviallyCopyable()))));
-
-  // Check whether destination object is not TriviallyCopyable.
-  // Applicable to all three memory manipulation functions.
-  Finder->addMatcher(callExpr(callee(functionDecl(hasAnyName(
-                                  "::memset", "::memcpy", "::memmove"))),
-                              hasArgument(0, NotTriviallyCopyableObject))
-                         .bind("dest"),
-                     this);
-
-  // Check whether source object is not TriviallyCopyable.
-  // Only applicable to memcpy() and memmove().
-  Finder->addMatcher(
-      callExpr(callee(functionDecl(hasAnyName("::memcpy", "::memmove"))),
-               hasArgument(1, NotTriviallyCopyableObject))
-          .bind("src"),
-      this);
-}
-
-void UndefinedMemoryManipulationCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("dest")) {
-    QualType DestType = Call->getArg(0)->IgnoreImplicit()->getType();
-    if (!DestType->getPointeeType().isNull())
-      DestType = DestType->getPointeeType();
-    diag(Call->getLocStart(), "undefined behavior, destination object type %0 "
-                              "is not TriviallyCopyable")
-        << DestType;
-  }
-  if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("src")) {
-    QualType SourceType = Call->getArg(1)->IgnoreImplicit()->getType();
-    if (!SourceType->getPointeeType().isNull())
-      SourceType = SourceType->getPointeeType();
-    diag(Call->getLocStart(),
-         "undefined behavior, source object type %0 is not TriviallyCopyable")
-        << SourceType;
-  }
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/bugprone/UndefinedMemoryManipulationCheck.h

@@ -1,37 +0,0 @@
-//===--- UndefinedMemoryManipulationCheck.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_BUGPRONE_UNDEFINED_MEMORY_MANIPULATION_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNDEFINED_MEMORY_MANIPULATION_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds calls of memory manipulation functions ``memset()``, ``memcpy()`` and
-/// ``memmove()`` on not TriviallyCopyable objects resulting in undefined
-/// behavior.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-undefined-memory-manipulation.html
-class UndefinedMemoryManipulationCheck : public ClangTidyCheck {
-public:
-  UndefinedMemoryManipulationCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNDEFINED_MEMORY_MANIPULATION_H

clang-tools-extra/clang-tidy/bugprone/UseAfterMoveCheck.h

@@ -1,36 +0,0 @@
-//===--- UseAfterMoveCheck.h - clang-tidy ---------------------------------===//
-//
-//                     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_BUGPRONE_USEAFTERMOVECHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_USEAFTERMOVECHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// The check warns if an object is used after it has been moved, without an
-/// intervening reinitialization.
-///
-/// For details, see the user-facing documentation:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-use-after-move.html
-class UseAfterMoveCheck : public ClangTidyCheck {
-public:
-  UseAfterMoveCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_USEAFTERMOVECHECK_H

clang-tools-extra/clang-tidy/cert/CERTTidyModule.cpp

@@ -11,16 +11,14 @@
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../google/UnnamedNamespaceInHeaderCheck.h"
+#include "../misc/MoveConstructorInitCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
 #include "../misc/NonCopyableObjects.h"
 #include "../misc/StaticAssertCheck.h"
 #include "../misc/ThrowByValueCatchByReferenceCheck.h"
-#include "../performance/MoveConstructorInitCheck.h"
 #include "CommandProcessorCheck.h"
-#include "DontModifyStdNamespaceCheck.h"
 #include "FloatLoopCounter.h"
 #include "LimitedRandomnessCheck.h"
-#include "PostfixOperatorCheck.h"
 #include "SetLongJmpCheck.h"
 #include "StaticObjectExceptionCheck.h"
 #include "StrToNumCheck.h"
@@ -36,17 +34,13 @@ public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     // C++ checkers
     // DCL
-    CheckFactories.registerCheck<PostfixOperatorCheck>(
-        "cert-dcl21-cpp");
     CheckFactories.registerCheck<VariadicFunctionDefCheck>("cert-dcl50-cpp");
     CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
         "cert-dcl54-cpp");
-    CheckFactories.registerCheck<DontModifyStdNamespaceCheck>(
-        "cert-dcl58-cpp");
     CheckFactories.registerCheck<google::build::UnnamedNamespaceInHeaderCheck>(
         "cert-dcl59-cpp");
     // OOP
-    CheckFactories.registerCheck<performance::MoveConstructorInitCheck>(
+    CheckFactories.registerCheck<misc::MoveConstructorInitCheck>(
         "cert-oop11-cpp");
     // ERR
     CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(

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

@@ -3,10 +3,8 @@ set(LLVM_LINK_COMPONENTS support)
 add_clang_library(clangTidyCERTModule
   CERTTidyModule.cpp
   CommandProcessorCheck.cpp
-  DontModifyStdNamespaceCheck.cpp
   FloatLoopCounter.cpp
   LimitedRandomnessCheck.cpp
-  PostfixOperatorCheck.cpp
   SetLongJmpCheck.cpp
   StaticObjectExceptionCheck.cpp
   StrToNumCheck.cpp
@@ -22,6 +20,5 @@ add_clang_library(clangTidyCERTModule
   clangTidy
   clangTidyGoogleModule
   clangTidyMiscModule
-  clangTidyPerformanceModule
   clangTidyUtils
   )

clang-tools-extra/clang-tidy/cert/DontModifyStdNamespaceCheck.cpp

@@ -1,49 +0,0 @@
-//===--- DontModifyStdNamespaceCheck.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 "DontModifyStdNamespaceCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-void DontModifyStdNamespaceCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(
-      namespaceDecl(unless(isExpansionInSystemHeader()),
-                    anyOf(hasName("std"), hasName("posix")),
-                    has(decl(unless(anyOf(
-                        functionDecl(isExplicitTemplateSpecialization()),
-                        cxxRecordDecl(isExplicitTemplateSpecialization()))))))
-          .bind("nmspc"),
-      this);
-}
-
-void DontModifyStdNamespaceCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  const auto *N = Result.Nodes.getNodeAs<NamespaceDecl>("nmspc");
-
-  // Only consider top level namespaces.
-  if (N->getParent() != Result.Context->getTranslationUnitDecl())
-    return;
-
-  diag(N->getLocation(),
-       "modification of %0 namespace can result in undefined behavior")
-      << N;
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/cert/DontModifyStdNamespaceCheck.h

@@ -1,36 +0,0 @@
-//===--- DontModifyStdNamespaceCheck.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_CERT_DONT_MODIFY_STD_NAMESPACE_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DONT_MODIFY_STD_NAMESPACE_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// Modification of the std or posix namespace can result in undefined behavior.
-/// This check warns for such modifications.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-msc53-cpp.html
-class DontModifyStdNamespaceCheck : public ClangTidyCheck {
-public:
-  DontModifyStdNamespaceCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DONT_MODIFY_STD_NAMESPACE_H

clang-tools-extra/clang-tidy/cert/PostfixOperatorCheck.cpp

@@ -1,88 +0,0 @@
-//===--- PostfixOperatorCheck.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 "PostfixOperatorCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-void PostfixOperatorCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(functionDecl(anyOf(hasOverloadedOperatorName("++"),
-                                        hasOverloadedOperatorName("--")))
-                         .bind("decl"),
-                     this);
-}
-
-void PostfixOperatorCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *FuncDecl = Result.Nodes.getNodeAs<FunctionDecl>("decl");
-
-  bool HasThis = false;
-  if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(FuncDecl))
-    HasThis = MethodDecl->isInstance();
-
-  // Check if the operator is a postfix one.
-  if (FuncDecl->getNumParams() != (HasThis ? 1 : 2))
-    return;
-
-  SourceRange ReturnRange = FuncDecl->getReturnTypeSourceRange();
-  SourceLocation Location = ReturnRange.getBegin();
-  if (!Location.isValid())
-    return;
-
-  QualType ReturnType = FuncDecl->getReturnType();
-
-  // Warn when the operators return a reference.
-  if (const auto *RefType = ReturnType->getAs<ReferenceType>()) {
-    auto Diag = diag(Location, "overloaded %0 returns a reference instead of a "
-                               "constant object type")
-                << FuncDecl;
-
-    if (Location.isMacroID() || ReturnType->getAs<TypedefType>() ||
-        RefType->getPointeeTypeAsWritten()->getAs<TypedefType>())
-      return;
-
-    QualType ReplaceType =
-        ReturnType.getNonReferenceType().getLocalUnqualifiedType();
-    // The getReturnTypeSourceRange omits the qualifiers. We do not want to
-    // duplicate the const.
-    if (!ReturnType->getPointeeType().isConstQualified())
-      ReplaceType.addConst();
-
-    Diag << FixItHint::CreateReplacement(
-        ReturnRange,
-        ReplaceType.getAsString(Result.Context->getPrintingPolicy()) + " ");
-
-    return;
-  }
-
-  if (ReturnType.isConstQualified() || ReturnType->isBuiltinType() ||
-      ReturnType->isPointerType())
-    return;
-
-  auto Diag =
-      diag(Location, "overloaded %0 returns a non-constant object instead of a "
-                     "constant object type")
-      << FuncDecl;
-
-  if (!Location.isMacroID() && !ReturnType->getAs<TypedefType>())
-    Diag << FixItHint::CreateInsertion(Location, "const ");
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/cert/PostfixOperatorCheck.h

@@ -1,36 +0,0 @@
-//===--- PostfixOperatorCheck.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_CERT_POSTFIX_OPERATOR_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_POSTFIX_OPERATOR_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// Checks if the overloaded postfix ++ and -- operator return a constant
-/// object.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-postfix-operator.html
-class PostfixOperatorCheck : public ClangTidyCheck {
-public:
-  PostfixOperatorCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_POSTFIX_OPERATOR_H

clang-tools-extra/clang-tidy/cert/StaticObjectExceptionCheck.cpp

@@ -19,7 +19,7 @@ namespace tidy {
 namespace cert {
 
 void StaticObjectExceptionCheck::registerMatchers(MatchFinder *Finder) {
-  if ((!getLangOpts().CPlusPlus) || (!getLangOpts().CXXExceptions))
+  if (!getLangOpts().CPlusPlus)
     return;
 
   // Match any static or thread_local variable declaration that has an

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

@@ -4,7 +4,6 @@ add_clang_library(clangTidyCppCoreGuidelinesModule
   CppCoreGuidelinesTidyModule.cpp
   InterfacesGlobalInitCheck.cpp
   NoMallocCheck.cpp
-  OwningMemoryCheck.cpp
   ProBoundsArrayToPointerDecayCheck.cpp
   ProBoundsConstantArrayIndexCheck.cpp
   ProBoundsPointerArithmeticCheck.cpp

clang-tools-extra/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

@@ -13,7 +13,6 @@
 #include "../misc/UnconventionalAssignOperatorCheck.h"
 #include "InterfacesGlobalInitCheck.h"
 #include "NoMallocCheck.h"
-#include "OwningMemoryCheck.h"
 #include "ProBoundsArrayToPointerDecayCheck.h"
 #include "ProBoundsConstantArrayIndexCheck.h"
 #include "ProBoundsPointerArithmeticCheck.h"
@@ -38,8 +37,6 @@ public:
     CheckFactories.registerCheck<InterfacesGlobalInitCheck>(
         "cppcoreguidelines-interfaces-global-init");
     CheckFactories.registerCheck<NoMallocCheck>("cppcoreguidelines-no-malloc");
-    CheckFactories.registerCheck<OwningMemoryCheck>(
-        "cppcoreguidelines-owning-memory");
     CheckFactories.registerCheck<ProBoundsArrayToPointerDecayCheck>(
         "cppcoreguidelines-pro-bounds-array-to-pointer-decay");
     CheckFactories.registerCheck<ProBoundsConstantArrayIndexCheck>(

clang-tools-extra/clang-tidy/cppcoreguidelines/NoMallocCheck.cpp

@@ -8,63 +8,43 @@
 //===----------------------------------------------------------------------===//
 
 #include "NoMallocCheck.h"
-#include "../utils/Matchers.h"
-#include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
-#include <algorithm>
+#include <iostream>
 #include <string>
-#include <vector>
 
 using namespace clang::ast_matchers;
-using namespace clang::ast_matchers::internal;
 
 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
-namespace {
-Matcher<FunctionDecl> hasAnyListedName(const std::string &FunctionNames) {
-  const std::vector<std::string> NameList =
-      utils::options::parseStringList(FunctionNames);
-  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
-}
-} // namespace
-
-void NoMallocCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "Allocations", AllocList);
-  Options.store(Opts, "Reallocations", ReallocList);
-  Options.store(Opts, "Deallocations", DeallocList);
-}
-
 void NoMallocCheck::registerMatchers(MatchFinder *Finder) {
   // C-style memory management is only problematic in C++.
   if (!getLangOpts().CPlusPlus)
     return;
 
   // Registering malloc, will suggest RAII.
-  Finder->addMatcher(callExpr(callee(functionDecl(hasAnyListedName(AllocList))))
-                         .bind("allocation"),
-                     this);
+  Finder->addMatcher(
+      callExpr(callee(functionDecl(hasAnyName("::malloc", "::calloc"))))
+          .bind("aquisition"),
+      this);
 
   // Registering realloc calls, suggest std::vector or std::string.
   Finder->addMatcher(
-      callExpr(callee(functionDecl(hasAnyListedName(ReallocList))))
-          .bind("realloc"),
+      callExpr(callee(functionDecl(hasName("::realloc")))).bind("realloc"),
       this);
 
   // Registering free calls, will suggest RAII instead.
   Finder->addMatcher(
-      callExpr(callee(functionDecl(hasAnyListedName(DeallocList))))
-          .bind("free"),
-      this);
+      callExpr(callee(functionDecl(hasName("::free")))).bind("free"), this);
 }
 
 void NoMallocCheck::check(const MatchFinder::MatchResult &Result) {
   const CallExpr *Call = nullptr;
   StringRef Recommendation;
 
-  if ((Call = Result.Nodes.getNodeAs<CallExpr>("allocation")))
+  if ((Call = Result.Nodes.getNodeAs<CallExpr>("aquisition")))
     Recommendation = "consider a container or a smart pointer";
   else if ((Call = Result.Nodes.getNodeAs<CallExpr>("realloc")))
     Recommendation = "consider std::vector or std::string";

clang-tools-extra/clang-tidy/cppcoreguidelines/NoMallocCheck.h

@@ -27,32 +27,14 @@ namespace cppcoreguidelines {
 /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-no-malloc.html
 class NoMallocCheck : public ClangTidyCheck {
 public:
-  /// Construct Checker and read in configuration for function names.
   NoMallocCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context),
-        AllocList(Options.get("Allocations", "::malloc;::calloc")),
-        ReallocList(Options.get("Reallocations", "::realloc")),
-        DeallocList(Options.get("Deallocations", "::free")) {}
-
-  /// Make configuration of checker discoverable.
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+      : ClangTidyCheck(Name, Context) {}
 
   /// Registering for malloc, calloc, realloc and free calls.
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
 
   /// Checks matched function calls and gives suggestion to modernize the code.
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-
-private:
-  /// Semicolon-separated list of fully qualified names of memory allocation
-  /// functions the check warns about. Defaults to `::malloc;::calloc`.
-  const std::string AllocList;
-  /// Semicolon-separated list of fully qualified names of memory reallocation
-  /// functions the check warns about. Defaults to `::realloc`.
-  const std::string ReallocList;
-  /// Semicolon-separated list of fully qualified names of memory deallocation
-  /// functions the check warns about. Defaults to `::free`.
-  const std::string DeallocList;
 };
 
 } // namespace cppcoreguidelines

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

@@ -1,394 +0,0 @@
-//===--- OwningMemoryCheck.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 "OwningMemoryCheck.h"
-#include "../utils/Matchers.h"
-#include "../utils/OptionsUtils.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include <string>
-#include <vector>
-
-using namespace clang::ast_matchers;
-using namespace clang::ast_matchers::internal;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-// FIXME: Copied from 'NoMallocCheck.cpp'. Has to be refactored into 'util' or
-// something like that.
-namespace {
-Matcher<FunctionDecl> hasAnyListedName(const std::string &FunctionNames) {
-  const std::vector<std::string> NameList =
-      utils::options::parseStringList(FunctionNames);
-  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
-}
-} // namespace
-
-void OwningMemoryCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "LegacyResourceProducers", LegacyResourceProducers);
-  Options.store(Opts, "LegacyResourceConsumers", LegacyResourceConsumers);
-}
-
-/// Match common cases, where the owner semantic is relevant, like function
-/// calls, delete expressions and others.
-void OwningMemoryCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus11)
-    return;
-
-  const auto OwnerDecl = typeAliasTemplateDecl(hasName("::gsl::owner"));
-  const auto IsOwnerType = hasType(OwnerDecl);
-
-  const auto LegacyCreatorFunctions = hasAnyListedName(LegacyResourceProducers);
-  const auto LegacyConsumerFunctions =
-      hasAnyListedName(LegacyResourceConsumers);
-
-  // Legacy functions that are use for resource management but cannot be
-  // updated to use `gsl::owner<>`, like standard C memory management.
-  const auto CreatesLegacyOwner =
-      callExpr(callee(functionDecl(LegacyCreatorFunctions)));
-  // C-style functions like `::malloc()` sometimes create owners as void*
-  // which is expected to be cast to the correct type in C++. This case
-  // must be catched explicitly.
-  const auto LegacyOwnerCast =
-      castExpr(hasSourceExpression(CreatesLegacyOwner));
-  // Functions that do manual resource management but cannot be updated to use
-  // owner. Best example is `::free()`.
-  const auto LegacyOwnerConsumers = functionDecl(LegacyConsumerFunctions);
-
-  const auto CreatesOwner =
-      anyOf(cxxNewExpr(),
-            callExpr(callee(
-                functionDecl(returns(qualType(hasDeclaration(OwnerDecl)))))),
-            CreatesLegacyOwner, LegacyOwnerCast);
-
-  const auto ConsideredOwner = eachOf(IsOwnerType, CreatesOwner);
-
-  // Find delete expressions that delete non-owners.
-  Finder->addMatcher(
-      cxxDeleteExpr(
-          hasDescendant(
-              declRefExpr(unless(ConsideredOwner)).bind("deleted_variable")))
-          .bind("delete_expr"),
-      this);
-
-  // Ignoring the implicit casts is vital because the legacy owners do not work
-  // with the 'owner<>' annotation and therefore always implicitly cast to the
-  // legacy type (even 'void *').
-  //
-  // Furthermore, legacy owner functions are assumed to use raw pointers for
-  // resources. This check assumes that all pointer arguments of a legacy
-  // functions shall be 'gsl::owner<>'.
-  Finder->addMatcher(
-      callExpr(
-          allOf(callee(LegacyOwnerConsumers),
-                hasAnyArgument(allOf(unless(ignoringImpCasts(ConsideredOwner)),
-                                     hasType(pointerType())))))
-          .bind("legacy_consumer"),
-      this);
-
-  // Matching assignment to owners, with the rhs not being an owner nor creating
-  // one.
-  Finder->addMatcher(binaryOperator(allOf(matchers::isAssignmentOperator(),
-                                          hasLHS(IsOwnerType),
-                                          hasRHS(unless(ConsideredOwner))))
-                         .bind("owner_assignment"),
-                     this);
-
-  // Matching initialization of owners with non-owners, nor creating owners.
-  Finder->addMatcher(
-      namedDecl(
-          varDecl(allOf(hasInitializer(unless(ConsideredOwner)), IsOwnerType))
-              .bind("owner_initialization")),
-      this);
-
-  const auto HasConstructorInitializerForOwner =
-      has(cxxConstructorDecl(forEachConstructorInitializer(
-          cxxCtorInitializer(allOf(isMemberInitializer(), forField(IsOwnerType),
-                                   withInitializer(
-                                       // Avoid templatesdeclaration with
-                                       // excluding parenListExpr.
-                                       allOf(unless(ConsideredOwner),
-                                             unless(parenListExpr())))))
-              .bind("owner_member_initializer"))));
-
-  // Match class member initialization that expects owners, but does not get
-  // them.
-  Finder->addMatcher(cxxRecordDecl(HasConstructorInitializerForOwner), this);
-
-  // Matching on assignment operations where the RHS is a newly created owner,
-  // but the LHS is not an owner.
-  Finder->addMatcher(
-      binaryOperator(allOf(matchers::isAssignmentOperator(),
-                           hasLHS(unless(IsOwnerType)), hasRHS(CreatesOwner)))
-          .bind("bad_owner_creation_assignment"),
-      this);
-
-  // Matching on initialization operations where the initial value is a newly
-  // created owner, but the LHS is not an owner.
-  Finder->addMatcher(
-      namedDecl(varDecl(eachOf(allOf(hasInitializer(CreatesOwner),
-                                     unless(IsOwnerType)),
-                               allOf(hasInitializer(ConsideredOwner),
-                                     hasType(autoType().bind("deduced_type")))))
-                    .bind("bad_owner_creation_variable")),
-      this);
-
-  // Match on all function calls that expect owners as arguments, but didn't
-  // get them.
-  Finder->addMatcher(
-      callExpr(forEachArgumentWithParam(
-          expr(unless(ConsideredOwner)).bind("expected_owner_argument"),
-          parmVarDecl(IsOwnerType))),
-      this);
-
-  // Matching for function calls where one argument is a created owner, but the
-  // parameter type is not an owner.
-  Finder->addMatcher(callExpr(forEachArgumentWithParam(
-                         expr(CreatesOwner).bind("bad_owner_creation_argument"),
-                         parmVarDecl(unless(IsOwnerType))
-                             .bind("bad_owner_creation_parameter"))),
-                     this);
-
-  // Matching on functions, that return an owner/resource, but don't declare
-  // their return type as owner.
-  Finder->addMatcher(
-      functionDecl(
-          allOf(hasDescendant(returnStmt(hasReturnValue(ConsideredOwner))
-                                  .bind("bad_owner_return")),
-                unless(returns(qualType(hasDeclaration(OwnerDecl))))))
-          .bind("function_decl"),
-      this);
-
-  // Match on classes that have an owner as member, but don't declare a
-  // destructor to properly release the owner.
-  Finder->addMatcher(
-      cxxRecordDecl(
-          allOf(
-              has(fieldDecl(IsOwnerType).bind("undestructed_owner_member")),
-              anyOf(unless(has(cxxDestructorDecl())),
-                    has(cxxDestructorDecl(anyOf(isDefaulted(), isDeleted()))))))
-          .bind("non_destructor_class"),
-      this);
-}
-
-void OwningMemoryCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto &Nodes = Result.Nodes;
-
-  bool CheckExecuted = false;
-  CheckExecuted |= handleDeletion(Nodes);
-  CheckExecuted |= handleLegacyConsumers(Nodes);
-  CheckExecuted |= handleExpectedOwner(Nodes);
-  CheckExecuted |= handleAssignmentAndInit(Nodes);
-  CheckExecuted |= handleAssignmentFromNewOwner(Nodes);
-  CheckExecuted |= handleReturnValues(Nodes);
-  CheckExecuted |= handleOwnerMembers(Nodes);
-
-  assert(CheckExecuted &&
-         "None of the subroutines executed, logic error in matcher!");
-}
-
-bool OwningMemoryCheck::handleDeletion(const BoundNodes &Nodes) {
-  // Result of delete matchers.
-  const auto *DeleteStmt = Nodes.getNodeAs<CXXDeleteExpr>("delete_expr");
-  const auto *DeletedVariable =
-      Nodes.getNodeAs<DeclRefExpr>("deleted_variable");
-
-  // Deletion of non-owners, with `delete variable;`
-  if (DeleteStmt) {
-    diag(DeleteStmt->getLocStart(),
-         "deleting a pointer through a type that is "
-         "not marked 'gsl::owner<>'; consider using a "
-         "smart pointer instead")
-        << DeletedVariable->getSourceRange();
-
-    // FIXME: The declaration of the variable that was deleted can be
-    // rewritten.
-    const ValueDecl *Decl = DeletedVariable->getDecl();
-    diag(Decl->getLocStart(), "variable declared here", DiagnosticIDs::Note)
-        << Decl->getSourceRange();
-
-    return true;
-  }
-  return false;
-}
-
-bool OwningMemoryCheck::handleLegacyConsumers(const BoundNodes &Nodes) {
-  // Result of matching for legacy consumer-functions like `::free()`.
-  const auto *LegacyConsumer = Nodes.getNodeAs<CallExpr>("legacy_consumer");
-
-  // FIXME: `freopen` should be handled seperately because it takes the filename
-  // as a pointer, which should not be an owner. The argument that is an owner
-  // is known and the false positive coming from the filename can be avoided.
-  if (LegacyConsumer) {
-    diag(LegacyConsumer->getLocStart(),
-         "calling legacy resource function without passing a 'gsl::owner<>'")
-        << LegacyConsumer->getSourceRange();
-    return true;
-  }
-  return false;
-}
-
-bool OwningMemoryCheck::handleExpectedOwner(const BoundNodes &Nodes) {
-  // Result of function call matchers.
-  const auto *ExpectedOwner = Nodes.getNodeAs<Expr>("expected_owner_argument");
-
-  // Expected function argument to be owner.
-  if (ExpectedOwner) {
-    diag(ExpectedOwner->getLocStart(),
-         "expected argument of type 'gsl::owner<>'; got %0")
-        << ExpectedOwner->getType() << ExpectedOwner->getSourceRange();
-    return true;
-  }
-  return false;
-}
-
-/// Assignment and initialization of owner variables.
-bool OwningMemoryCheck::handleAssignmentAndInit(const BoundNodes &Nodes) {
-  const auto *OwnerAssignment =
-      Nodes.getNodeAs<BinaryOperator>("owner_assignment");
-  const auto *OwnerInitialization =
-      Nodes.getNodeAs<VarDecl>("owner_initialization");
-  const auto *OwnerInitializer =
-      Nodes.getNodeAs<CXXCtorInitializer>("owner_member_initializer");
-
-  // Assignments to owners.
-  if (OwnerAssignment) {
-    diag(OwnerAssignment->getLocStart(),
-         "expected assignment source to be of type 'gsl::owner<>'; got %0")
-        << OwnerAssignment->getRHS()->getType()
-        << OwnerAssignment->getSourceRange();
-    return true;
-  }
-
-  // Initialization of owners.
-  if (OwnerInitialization) {
-    diag(OwnerInitialization->getLocStart(),
-         "expected initialization with value of type 'gsl::owner<>'; got %0")
-        << OwnerInitialization->getAnyInitializer()->getType()
-        << OwnerInitialization->getSourceRange();
-    return true;
-  }
-
-  // Initializer of class constructors that initialize owners.
-  if (OwnerInitializer) {
-    diag(OwnerInitializer->getSourceLocation(),
-         "expected initialization of owner member variable with value of type "
-         "'gsl::owner<>'; got %0")
-        // FIXME: the expression from getInit has type 'void', but the type
-        // of the supplied argument would be of interest.
-        << OwnerInitializer->getInit()->getType()
-        << OwnerInitializer->getSourceRange();
-    return true;
-  }
-  return false;
-}
-
-/// Problematic assignment and initializations, since the assigned value is a
-/// newly created owner.
-bool OwningMemoryCheck::handleAssignmentFromNewOwner(const BoundNodes &Nodes) {
-  const auto *BadOwnerAssignment =
-      Nodes.getNodeAs<BinaryOperator>("bad_owner_creation_assignment");
-  const auto *BadOwnerInitialization =
-      Nodes.getNodeAs<VarDecl>("bad_owner_creation_variable");
-
-  const auto *BadOwnerArgument =
-      Nodes.getNodeAs<Expr>("bad_owner_creation_argument");
-  const auto *BadOwnerParameter =
-      Nodes.getNodeAs<ParmVarDecl>("bad_owner_creation_parameter");
-
-  // Bad assignments to non-owners, where the RHS is a newly created owner.
-  if (BadOwnerAssignment) {
-    diag(BadOwnerAssignment->getLocStart(),
-         "assigning newly created 'gsl::owner<>' to non-owner %0")
-        << BadOwnerAssignment->getLHS()->getType()
-        << BadOwnerAssignment->getSourceRange();
-    return true;
-  }
-
-  // Bad initialization of non-owners, where the RHS is a newly created owner.
-  if (BadOwnerInitialization) {
-    diag(BadOwnerInitialization->getLocStart(),
-         "initializing non-owner %0 with a newly created 'gsl::owner<>'")
-        << BadOwnerInitialization->getType()
-        << BadOwnerInitialization->getSourceRange();
-
-    // FIXME: FixitHint to rewrite the type of the initialized variable
-    // as 'gsl::owner<OriginalType>'
-
-    // If the type of the variable was deduced, the wrapping owner typedef is
-    // eliminated, therefore the check emits a special note for that case.
-    if (Nodes.getNodeAs<AutoType>("deduced_type")) {
-      diag(BadOwnerInitialization->getLocStart(),
-           "type deduction did not result in an owner", DiagnosticIDs::Note);
-    }
-    return true;
-  }
-
-  // Function call, where one arguments is a newly created owner, but the
-  // parameter type is not.
-  if (BadOwnerArgument) {
-    assert(BadOwnerParameter &&
-           "parameter for the problematic argument not found");
-    diag(BadOwnerArgument->getLocStart(), "initializing non-owner argument of "
-                                          "type %0 with a newly created "
-                                          "'gsl::owner<>'")
-        << BadOwnerParameter->getType() << BadOwnerArgument->getSourceRange();
-    return true;
-  }
-  return false;
-}
-
-bool OwningMemoryCheck::handleReturnValues(const BoundNodes &Nodes) {
-  // Function return statements, that are owners/resources, but the function
-  // declaration does not declare its return value as owner.
-  const auto *BadReturnType = Nodes.getNodeAs<ReturnStmt>("bad_owner_return");
-  const auto *Function = Nodes.getNodeAs<FunctionDecl>("function_decl");
-
-  // Function return values, that should be owners but aren't.
-  if (BadReturnType) {
-    // The returned value is a resource or variable that was not annotated with
-    // owner<> and the function return type is not owner<>.
-    diag(BadReturnType->getLocStart(),
-         "returning a newly created resource of "
-         "type %0 or 'gsl::owner<>' from a "
-         "function whose return type is not 'gsl::owner<>'")
-        << Function->getReturnType() << BadReturnType->getSourceRange();
-
-    // FIXME: Rewrite the return type as 'gsl::owner<OriginalType>'
-    return true;
-  }
-  return false;
-}
-
-bool OwningMemoryCheck::handleOwnerMembers(const BoundNodes &Nodes) {
-  // Classes, that have owners as member, but do not declare destructors
-  // accordingly.
-  const auto *BadClass = Nodes.getNodeAs<CXXRecordDecl>("non_destructor_class");
-
-  // Classes, that contains owners, but do not declare destructors.
-  if (BadClass) {
-    const auto *DeclaredOwnerMember =
-        Nodes.getNodeAs<FieldDecl>("undestructed_owner_member");
-    assert(DeclaredOwnerMember &&
-           "match on class with bad destructor but without a declared owner");
-
-    diag(DeclaredOwnerMember->getLocStart(),
-         "member variable of type 'gsl::owner<>' requires the class %0 to "
-         "implement a destructor to release the owned resource")
-        << BadClass;
-    return true;
-  }
-  return false;
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.h

@@ -1,63 +0,0 @@
-//===--- OwningMemoryCheck.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_CPPCOREGUIDELINES_OWNING_MEMORY_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_OWNING_MEMORY_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// Checks for common use cases for gsl::owner and enforces the unique owner
-/// nature of it whenever possible.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-owning-memory.html
-class OwningMemoryCheck : public ClangTidyCheck {
-public:
-  OwningMemoryCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context),
-        LegacyResourceProducers(Options.get(
-            "LegacyResourceProducers", "::malloc;::aligned_alloc;::realloc;"
-                                       "::calloc;::fopen;::freopen;::tmpfile")),
-        LegacyResourceConsumers(Options.get(
-            "LegacyResourceConsumers", "::free;::realloc;::freopen;::fclose")) {
-  }
-
-  /// Make configuration of checker discoverable.
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-
-private:
-  bool handleDeletion(const ast_matchers::BoundNodes &Nodes);
-  bool handleLegacyConsumers(const ast_matchers::BoundNodes &Nodes);
-  bool handleExpectedOwner(const ast_matchers::BoundNodes &Nodes);
-  bool handleAssignmentAndInit(const ast_matchers::BoundNodes &Nodes);
-  bool handleAssignmentFromNewOwner(const ast_matchers::BoundNodes &Nodes);
-  bool handleReturnValues(const ast_matchers::BoundNodes &Nodes);
-  bool handleOwnerMembers(const ast_matchers::BoundNodes &Nodes);
-
-  /// List of old C-style functions that create resources.
-  /// Defaults to
-  /// `::malloc;::aligned_alloc;::realloc;::calloc;::fopen;::freopen;::tmpfile`.
-  const std::string LegacyResourceProducers;
-  /// List of old C-style functions that consume or release resources.
-  /// Defaults to `::free;::realloc;::freopen;::fclose`.
-  const std::string LegacyResourceConsumers;
-};
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_OWNING_MEMORY_H

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp

@@ -23,7 +23,7 @@ ProBoundsConstantArrayIndexCheck::ProBoundsConstantArrayIndexCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")),
       IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
-          Options.getLocalOrGlobal("IncludeStyle", "llvm"))) {}
+          Options.get("IncludeStyle", "llvm"))) {}
 
 void ProBoundsConstantArrayIndexCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {

clang-tools-extra/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

@@ -32,16 +32,22 @@ AST_MATCHER(CXXRecordDecl, hasDefaultConstructor) {
 }
 
 // Iterate over all the fields in a record type, both direct and indirect (e.g.
-// if the record contains an anonmyous struct).
+// if the record contains an anonmyous struct). If OneFieldPerUnion is true and
+// the record type (or indirect field) is a union, forEachField will stop after
+// the first field.
 template <typename T, typename Func>
-void forEachField(const RecordDecl &Record, const T &Fields, Func &&Fn) {
+void forEachField(const RecordDecl &Record, const T &Fields,
+                  bool OneFieldPerUnion, Func &&Fn) {
   for (const FieldDecl *F : Fields) {
     if (F->isAnonymousStructOrUnion()) {
       if (const CXXRecordDecl *R = F->getType()->getAsCXXRecordDecl())
-        forEachField(*R, R->fields(), Fn);
+        forEachField(*R, R->fields(), OneFieldPerUnion, Fn);
     } else {
       Fn(F);
     }
+
+    if (OneFieldPerUnion && Record.isUnion())
+      break;
   }
 }
 
@@ -119,12 +125,12 @@ struct IntializerInsertion {
     SourceLocation Location;
     switch (Placement) {
     case InitializerPlacement::New:
-      Location = utils::lexer::getPreviousToken(
+      Location = utils::lexer::getPreviousNonCommentToken(
                      Context, Constructor.getBody()->getLocStart())
                      .getLocation();
       break;
     case InitializerPlacement::Before:
-      Location = utils::lexer::getPreviousToken(
+      Location = utils::lexer::getPreviousNonCommentToken(
                      Context, Where->getSourceRange().getBegin())
                      .getLocation();
       break;
@@ -221,7 +227,7 @@ void getInitializationsInOrder(const CXXRecordDecl &ClassDecl,
       Decls.emplace_back(Decl);
     }
   }
-  forEachField(ClassDecl, ClassDecl.fields(),
+  forEachField(ClassDecl, ClassDecl.fields(), false,
                [&](const FieldDecl *F) { Decls.push_back(F); });
 }
 
@@ -347,7 +353,7 @@ void ProTypeMemberInitCheck::checkMissingMemberInitializer(
 
   // Gather all fields (direct and indirect) that need to be initialized.
   SmallPtrSet<const FieldDecl *, 16> FieldsToInit;
-  forEachField(ClassDecl, ClassDecl.fields(), [&](const FieldDecl *F) {
+  forEachField(ClassDecl, ClassDecl.fields(), false, [&](const FieldDecl *F) {
     if (!F->hasInClassInitializer() &&
         utils::type_traits::isTriviallyDefaultConstructible(F->getType(),
                                                             Context) &&
@@ -373,12 +379,12 @@ void ProTypeMemberInitCheck::checkMissingMemberInitializer(
   // Collect all fields in order, both direct fields and indirect fields from
   // anonmyous record types.
   SmallVector<const FieldDecl *, 16> OrderedFields;
-  forEachField(ClassDecl, ClassDecl.fields(),
+  forEachField(ClassDecl, ClassDecl.fields(), false,
                [&](const FieldDecl *F) { OrderedFields.push_back(F); });
 
   // Collect all the fields we need to initialize, including indirect fields.
   SmallPtrSet<const FieldDecl *, 16> AllFieldsToInit;
-  forEachField(ClassDecl, FieldsToInit,
+  forEachField(ClassDecl, FieldsToInit, false,
                [&](const FieldDecl *F) { AllFieldsToInit.insert(F); });
   if (AllFieldsToInit.empty())
     return;
@@ -398,16 +404,11 @@ void ProTypeMemberInitCheck::checkMissingMemberInitializer(
   // Collect all fields but only suggest a fix for the first member of unions,
   // as initializing more than one union member is an error.
   SmallPtrSet<const FieldDecl *, 16> FieldsToFix;
-  SmallPtrSet<const RecordDecl *, 4> UnionsSeen;
-  forEachField(ClassDecl, OrderedFields, [&](const FieldDecl *F) {
-    if (!FieldsToInit.count(F))
-      return;
+  forEachField(ClassDecl, FieldsToInit, true, [&](const FieldDecl *F) {
     // Don't suggest fixes for enums because we don't know a good default.
     // Don't suggest fixes for bitfields because in-class initialization is not
     // possible.
-    if (F->getType()->isEnumeralType() || F->isBitField())
-      return;
-    if (!F->getParent()->isUnion() || UnionsSeen.insert(F->getParent()).second)
+    if (!F->getType()->isEnumeralType() && !F->isBitField())
       FieldsToFix.insert(F);
   });
   if (FieldsToFix.empty())
@@ -448,9 +449,6 @@ void ProTypeMemberInitCheck::checkMissingBaseClassInitializer(
 
   // Remove any bases that were explicitly written in the initializer list.
   if (Ctor) {
-    if (Ctor->isImplicit())
-      return;
-
     for (const CXXCtorInitializer *Init : Ctor->inits()) {
       if (Init->isBaseInitializer() && Init->isWritten())
         BasesToInit.erase(Init->getBaseClass()->getAsCXXRecordDecl());