ReleaseNotes: move the retpoline bullets higher

llvm-svn: 326550

clang-tools-extra/CMakeLists.txt

@@ -7,7 +7,6 @@ add_subdirectory(clang-tidy-vs)
 endif()
 
 add_subdirectory(change-namespace)
-add_subdirectory(clang-doc)
 add_subdirectory(clang-query)
 add_subdirectory(clang-move)
 add_subdirectory(clangd)

clang-tools-extra/LICENSE.TXT

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

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

@@ -478,13 +478,13 @@ void ChangeNamespaceTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
                                 hasAncestor(namespaceDecl(isAnonymous())),
                                 hasAncestor(cxxRecordDecl()))),
                    hasParent(namespaceDecl()));
-  Finder->addMatcher(
-      expr(allOf(hasAncestor(decl().bind("dc")), IsInMovedNs,
-                 unless(hasAncestor(isImplicit())),
-                 anyOf(callExpr(callee(FuncMatcher)).bind("call"),
-                       declRefExpr(to(FuncMatcher.bind("func_decl")))
-                           .bind("func_ref")))),
-      this);
+  Finder->addMatcher(decl(forEachDescendant(expr(anyOf(
+                              callExpr(callee(FuncMatcher)).bind("call"),
+                              declRefExpr(to(FuncMatcher.bind("func_decl")))
+                                  .bind("func_ref")))),
+                          IsInMovedNs, unless(isImplicit()))
+                         .bind("dc"),
+                     this);
 
   auto GlobalVarMatcher = varDecl(
       hasGlobalStorage(), hasParent(namespaceDecl()),

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

@@ -10,7 +10,6 @@ add_clang_library(clangApplyReplacements
   clangBasic
   clangRewrite
   clangToolingCore
-  clangToolingRefactor
   )
 
 include_directories(

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

@@ -18,7 +18,6 @@
 
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Refactoring.h"
-#include "clang/Tooling/Refactoring/AtomicChange.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
@@ -30,8 +29,15 @@ namespace clang {
 class DiagnosticsEngine;
 class Rewriter;
 
+namespace format {
+struct FormatStyle;
+} // end namespace format
+
 namespace replace {
 
+/// \brief Collection of source ranges.
+typedef std::vector<clang::tooling::Range> RangeVector;
+
 /// \brief Collection of TranslationUnitReplacements.
 typedef std::vector<clang::tooling::TranslationUnitReplacements> TUReplacements;
 
@@ -41,10 +47,10 @@ typedef std::vector<std::string> TUReplacementFiles;
 /// \brief Collection of TranslationUniDiagnostics.
 typedef std::vector<clang::tooling::TranslationUnitDiagnostics> TUDiagnostics;
 
-/// \brief Map mapping file name to a set of AtomicChange targeting that file.
+/// \brief Map mapping file name to Replacements targeting that file.
 typedef llvm::DenseMap<const clang::FileEntry *,
-                       std::vector<tooling::AtomicChange>>
-    FileToChangesMap;
+                       std::vector<clang::tooling::Replacement>>
+    FileToReplacementsMap;
 
 /// \brief Recursively descends through a directory structure rooted at \p
 /// Directory and attempts to deserialize *.yaml files as
@@ -71,39 +77,65 @@ std::error_code collectReplacementsFromDirectory(
     const llvm::StringRef Directory, TUDiagnostics &TUs,
     TUReplacementFiles &TUFiles, clang::DiagnosticsEngine &Diagnostics);
 
-/// \brief Deduplicate, check for conflicts, and extract all Replacements stored
-/// in \c TUs. Conflicting replacements are skipped.
+/// \brief Deduplicate, check for conflicts, and apply all Replacements stored
+/// in \c TUs. If conflicts occur, no Replacements are applied.
 ///
-/// \post For all (key,value) in FileChanges, value[i].getOffset() <=
+/// \post For all (key,value) in GroupedReplacements, value[i].getOffset() <=
 /// value[i+1].getOffset().
 ///
 /// \param[in] TUs Collection of TranslationUnitReplacements or
-/// TranslationUnitDiagnostics to merge, deduplicate, and test for conflicts.
-/// \param[out] FileChanges Container grouping all changes by the
-/// file they target. Only non conflicting replacements are kept into
-/// FileChanges.
+/// TranslationUnitDiagnostics to merge,
+/// deduplicate, and test for conflicts.
+/// \param[out] GroupedReplacements Container grouping all Replacements by the
+/// file they target.
 /// \param[in] SM SourceManager required for conflict reporting.
 ///
 /// \returns \parblock
-///          \li true If all changes were converted successfully.
+///          \li true If all changes were applied successfully.
 ///          \li false If there were conflicts.
-bool mergeAndDeduplicate(const TUReplacements &TUs, const TUDiagnostics &TUDs,
-                         FileToChangesMap &FileChanges,
+bool mergeAndDeduplicate(const TUReplacements &TUs,
+                         FileToReplacementsMap &GroupedReplacements,
                          clang::SourceManager &SM);
 
-/// \brief Apply \c AtomicChange on File and rewrite it.
+bool mergeAndDeduplicate(const TUDiagnostics &TUs,
+                         FileToReplacementsMap &GroupedReplacements,
+                         clang::SourceManager &SM);
+
+// FIXME: Remove this function after changing clang-apply-replacements to use
+// Replacements class.
+bool applyAllReplacements(const std::vector<tooling::Replacement> &Replaces,
+                          Rewriter &Rewrite);
+
+/// \brief Apply all replacements in \c GroupedReplacements.
 ///
-/// \param[in] File Path of the file where to apply AtomicChange.
-/// \param[in] Changes to apply.
-/// \param[in] Spec For code cleanup and formatting.
-/// \param[in] Diagnostics DiagnosticsEngine used for error output.
+/// \param[in] GroupedReplacements Deduplicated and conflict free Replacements
+/// to apply.
+/// \param[out] Rewrites The results of applying replacements will be applied
+/// to this Rewriter.
 ///
-/// \returns The changed code if all changes are applied successfully;
-/// otherwise, an llvm::Error carrying llvm::StringError or an error_code.
-llvm::Expected<std::string>
-applyChanges(StringRef File, const std::vector<tooling::AtomicChange> &Changes,
-             const tooling::ApplyChangesSpec &Spec,
-             DiagnosticsEngine &Diagnostics);
+/// \returns \parblock
+///          \li true If all changes were applied successfully.
+///          \li false If a replacement failed to apply.
+bool applyReplacements(const FileToReplacementsMap &GroupedReplacements,
+                       clang::Rewriter &Rewrites);
+
+/// \brief Given a collection of Replacements for a single file, produces a list
+/// of source ranges that enclose those Replacements.
+///
+/// \pre Replacements[i].getOffset() <= Replacements[i+1].getOffset().
+///
+/// \param[in] Replacements Replacements from a single file.
+///
+/// \returns Collection of source ranges that enclose all given Replacements.
+/// One range is created for each replacement.
+RangeVector calculateChangedRanges(
+    const std::vector<clang::tooling::Replacement> &Replacements);
+
+/// \brief Write the contents of \c FileContents to disk. Keys of the map are
+/// filenames and values are the new contents for those files.
+///
+/// \param[in] Rewrites Rewriter containing written files to write to disk.
+bool writeFiles(const clang::Rewriter &Rewrites);
 
 /// \brief Delete the replacement files.
 ///

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

@@ -80,9 +80,10 @@ std::error_code collectReplacementsFromDirectory(
   return ErrorCode;
 }
 
-std::error_code collectReplacementsFromDirectory(
-    const llvm::StringRef Directory, TUDiagnostics &TUs,
-    TUReplacementFiles &TUFiles, clang::DiagnosticsEngine &Diagnostics) {
+std::error_code
+collectReplacementsFromDirectory(const llvm::StringRef Directory,
+                                 TUDiagnostics &TUs, TUReplacementFiles &TUFiles,
+                                 clang::DiagnosticsEngine &Diagnostics) {
   using namespace llvm::sys::fs;
   using namespace llvm::sys::path;
 
@@ -124,109 +125,259 @@ std::error_code collectReplacementsFromDirectory(
   return ErrorCode;
 }
 
-/// \brief Extract replacements from collected TranslationUnitReplacements and
-/// TranslationUnitDiagnostics and group them per file.
+/// \brief Dumps information for a sequence of conflicting Replacements.
 ///
-/// \param[in] TUs Collection of all found and deserialized
-/// TranslationUnitReplacements.
-/// \param[in] TUDs Collection of all found and deserialized
-/// TranslationUnitDiagnostics.
-/// \param[in] SM Used to deduplicate paths.
-///
-/// \returns A map mapping FileEntry to a set of Replacement targeting that
-/// file.
-static llvm::DenseMap<const FileEntry *, std::vector<tooling::Replacement>>
-groupReplacements(const TUReplacements &TUs, const TUDiagnostics &TUDs,
-                  const clang::SourceManager &SM) {
-  std::set<StringRef> Warned;
-  llvm::DenseMap<const FileEntry *, std::vector<tooling::Replacement>>
-      GroupedReplacements;
+/// \param[in] File FileEntry for the file the conflicting Replacements are
+/// for.
+/// \param[in] ConflictingReplacements List of conflicting Replacements.
+/// \param[in] SM SourceManager used for reporting.
+static void reportConflict(
+    const FileEntry *File,
+    const llvm::ArrayRef<clang::tooling::Replacement> ConflictingReplacements,
+    SourceManager &SM) {
+  FileID FID = SM.translateFile(File);
+  if (FID.isInvalid())
+    FID = SM.createFileID(File, SourceLocation(), SrcMgr::C_User);
 
-  auto AddToGroup = [&](const tooling::Replacement &R) {
-    // 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";
+  // FIXME: Output something a little more user-friendly (e.g. unified diff?)
+  errs() << "The following changes conflict:\n";
+  for (const tooling::Replacement &R : ConflictingReplacements) {
+    if (R.getLength() == 0) {
+      errs() << "  Insert at " << SM.getLineNumber(FID, R.getOffset()) << ":"
+             << SM.getColumnNumber(FID, R.getOffset()) << " "
+             << R.getReplacementText() << "\n";
+    } else {
+      if (R.getReplacementText().empty())
+        errs() << "  Remove ";
+      else
+        errs() << "  Replace ";
+
+      errs() << SM.getLineNumber(FID, R.getOffset()) << ":"
+             << SM.getColumnNumber(FID, R.getOffset()) << "-"
+             << SM.getLineNumber(FID, R.getOffset() + R.getLength() - 1) << ":"
+             << SM.getColumnNumber(FID, R.getOffset() + R.getLength() - 1);
+
+      if (R.getReplacementText().empty())
+        errs() << "\n";
+      else
+        errs() << " with \"" << R.getReplacementText() << "\"\n";
     }
+  }
+}
+
+// FIXME: Remove this function after changing clang-apply-replacements to use
+// Replacements class.
+bool applyAllReplacements(const std::vector<tooling::Replacement> &Replaces,
+                          Rewriter &Rewrite) {
+  bool Result = true;
+  for (auto I = Replaces.begin(), E = Replaces.end(); I != E; ++I) {
+    if (I->isApplicable()) {
+      Result = I->apply(Rewrite) && Result;
+    } else {
+      Result = false;
+    }
+  }
+  return Result;
+}
+
+// FIXME: moved from libToolingCore. remove this when std::vector<Replacement>
+// is replaced with tooling::Replacements class.
+static void deduplicate(std::vector<tooling::Replacement> &Replaces,
+                        std::vector<tooling::Range> &Conflicts) {
+  if (Replaces.empty())
+    return;
+
+  auto LessNoPath = [](const tooling::Replacement &LHS,
+                       const tooling::Replacement &RHS) {
+    if (LHS.getOffset() != RHS.getOffset())
+      return LHS.getOffset() < RHS.getOffset();
+    if (LHS.getLength() != RHS.getLength())
+      return LHS.getLength() < RHS.getLength();
+    return LHS.getReplacementText() < RHS.getReplacementText();
   };
 
-  for (const auto &TU : TUs)
-    for (const tooling::Replacement &R : TU.Replacements)
-      AddToGroup(R);
+  auto EqualNoPath = [](const tooling::Replacement &LHS,
+                        const tooling::Replacement &RHS) {
+    return LHS.getOffset() == RHS.getOffset() &&
+           LHS.getLength() == RHS.getLength() &&
+           LHS.getReplacementText() == RHS.getReplacementText();
+  };
 
-  for (const auto &TU : TUDs)
-    for (const auto &D : TU.Diagnostics)
-      for (const auto &Fix : D.Fix)
-        for (const tooling::Replacement &R : Fix.second)
-          AddToGroup(R);
+  // Deduplicate. We don't want to deduplicate based on the path as we assume
+  // that all replacements refer to the same file (or are symlinks).
+  std::sort(Replaces.begin(), Replaces.end(), LessNoPath);
+  Replaces.erase(std::unique(Replaces.begin(), Replaces.end(), EqualNoPath),
+                 Replaces.end());
 
-  // Sort replacements per file to keep consistent behavior when
-  // clang-apply-replacements run on differents machine.
-  for (auto &FileAndReplacements : GroupedReplacements) {
-    llvm::sort(FileAndReplacements.second.begin(),
-               FileAndReplacements.second.end());
+  // Detect conflicts
+  tooling::Range ConflictRange(Replaces.front().getOffset(),
+                               Replaces.front().getLength());
+  unsigned ConflictStart = 0;
+  unsigned ConflictLength = 1;
+  for (unsigned i = 1; i < Replaces.size(); ++i) {
+    tooling::Range Current(Replaces[i].getOffset(), Replaces[i].getLength());
+    if (ConflictRange.overlapsWith(Current)) {
+      // Extend conflicted range
+      ConflictRange =
+          tooling::Range(ConflictRange.getOffset(),
+                         std::max(ConflictRange.getLength(),
+                                  Current.getOffset() + Current.getLength() -
+                                      ConflictRange.getOffset()));
+      ++ConflictLength;
+    } else {
+      if (ConflictLength > 1)
+        Conflicts.push_back(tooling::Range(ConflictStart, ConflictLength));
+      ConflictRange = Current;
+      ConflictStart = i;
+      ConflictLength = 1;
+    }
   }
 
-  return GroupedReplacements;
+  if (ConflictLength > 1)
+    Conflicts.push_back(tooling::Range(ConflictStart, ConflictLength));
 }
 
-bool mergeAndDeduplicate(const TUReplacements &TUs, const TUDiagnostics &TUDs,
-                         FileToChangesMap &FileChanges,
-                         clang::SourceManager &SM) {
-  auto GroupedReplacements = groupReplacements(TUs, TUDs, SM);
-  bool ConflictDetected = false;
+/// \brief Deduplicates and tests for conflicts among the replacements for each
+/// file in \c Replacements. Any conflicts found are reported.
+///
+/// \post Replacements[i].getOffset() <= Replacements[i+1].getOffset().
+///
+/// \param[in,out] Replacements Container of all replacements grouped by file
+/// to be deduplicated and checked for conflicts.
+/// \param[in] SM SourceManager required for conflict reporting.
+///
+/// \returns \parblock
+///          \li true if conflicts were detected
+///          \li false if no conflicts were detected
+static bool deduplicateAndDetectConflicts(FileToReplacementsMap &Replacements,
+                                          SourceManager &SM) {
+  bool conflictsFound = false;
 
-  // To report conflicting replacements on corresponding file, all replacements
-  // are stored into 1 big AtomicChange.
-  for (const auto &FileAndReplacements : GroupedReplacements) {
+  for (auto &FileAndReplacements : Replacements) {
     const FileEntry *Entry = FileAndReplacements.first;
-    const SourceLocation BeginLoc =
-        SM.getLocForStartOfFile(SM.getOrCreateFileID(Entry, SrcMgr::C_User));
-    tooling::AtomicChange FileChange(Entry->getName(), Entry->getName());
-    for (const auto &R : FileAndReplacements.second) {
-      llvm::Error Err =
-          FileChange.replace(SM, BeginLoc.getLocWithOffset(R.getOffset()),
-                             R.getLength(), R.getReplacementText());
-      if (Err) {
-        // FIXME: This will report conflicts by pair using a file+offset format
-        // which is not so much human readable.
-        // A first improvement could be to translate offset to line+col. For
-        // this and without loosing error message some modifications arround
-        // `tooling::ReplacementError` are need (access to
-        // `getReplacementErrString`).
-        // A better strategy could be to add a pretty printer methods for
-        // conflict reporting. Methods that could be parameterized to report a
-        // conflict in different format, file+offset, file+line+col, or even
-        // more human readable using VCS conflict markers.
-        // For now, printing directly the error reported by `AtomicChange` is
-        // the easiest solution.
-        errs() << llvm::toString(std::move(Err)) << "\n";
-        ConflictDetected = true;
+    auto &Replacements = FileAndReplacements.second;
+    assert(Entry != nullptr && "No file entry!");
+
+    std::vector<tooling::Range> Conflicts;
+    deduplicate(FileAndReplacements.second, Conflicts);
+
+    if (Conflicts.empty())
+      continue;
+
+    conflictsFound = true;
+
+    errs() << "There are conflicting changes to " << Entry->getName() << ":\n";
+
+    for (const tooling::Range &Conflict : Conflicts) {
+      auto ConflictingReplacements = llvm::makeArrayRef(
+          &Replacements[Conflict.getOffset()], Conflict.getLength());
+      reportConflict(Entry, ConflictingReplacements, SM);
+    }
+  }
+
+  return conflictsFound;
+}
+
+bool mergeAndDeduplicate(const TUReplacements &TUs,
+                         FileToReplacementsMap &GroupedReplacements,
+                         clang::SourceManager &SM) {
+
+  // Group all replacements by target file.
+  std::set<StringRef> Warned;
+  for (const auto &TU : TUs) {
+    for (const tooling::Replacement &R : TU.Replacements) {
+      // Use the file manager to deduplicate paths. FileEntries are
+      // automatically canonicalized.
+      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";
       }
     }
-    FileChanges.try_emplace(Entry,
-                            std::vector<tooling::AtomicChange>{FileChange});
   }
 
-  return !ConflictDetected;
+  // Ask clang to deduplicate and report conflicts.
+  return !deduplicateAndDetectConflicts(GroupedReplacements, SM);
 }
 
-llvm::Expected<std::string>
-applyChanges(StringRef File, const std::vector<tooling::AtomicChange> &Changes,
-             const tooling::ApplyChangesSpec &Spec,
-             DiagnosticsEngine &Diagnostics) {
-  FileManager Files((FileSystemOptions()));
-  SourceManager SM(Diagnostics, Files);
+bool mergeAndDeduplicate(const TUDiagnostics &TUs,
+                         FileToReplacementsMap &GroupedReplacements,
+                         clang::SourceManager &SM) {
 
-  llvm::ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
-      SM.getFileManager().getBufferForFile(File);
-  if (!Buffer)
-    return errorCodeToError(Buffer.getError());
-  return tooling::applyAtomicChanges(File, Buffer.get()->getBuffer(), Changes,
-                                     Spec);
+  // Group all replacements by target file.
+  std::set<StringRef> Warned;
+  for (const auto &TU : TUs) {
+    for (const auto &D : TU.Diagnostics) {
+      for (const auto &Fix : D.Fix) {
+        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";
+          }
+        }
+      }
+    }
+  }
+
+  // Ask clang to deduplicate and report conflicts.
+  return !deduplicateAndDetectConflicts(GroupedReplacements, SM);
+}
+
+bool applyReplacements(const FileToReplacementsMap &GroupedReplacements,
+                       clang::Rewriter &Rewrites) {
+
+  // Apply all changes
+  //
+  // FIXME: No longer certain GroupedReplacements is really the best kind of
+  // data structure for applying replacements. Rewriter certainly doesn't care.
+  // However, until we nail down the design of ReplacementGroups, might as well
+  // leave this as is.
+  for (const auto &FileAndReplacements : GroupedReplacements) {
+    if (!applyAllReplacements(FileAndReplacements.second, Rewrites))
+      return false;
+  }
+
+  return true;
+}
+
+RangeVector calculateChangedRanges(
+    const std::vector<clang::tooling::Replacement> &Replaces) {
+  RangeVector ChangedRanges;
+
+  // Generate the new ranges from the replacements.
+  int Shift = 0;
+  for (const tooling::Replacement &R : Replaces) {
+    unsigned Offset = R.getOffset() + Shift;
+    unsigned Length = R.getReplacementText().size();
+    Shift += Length - R.getLength();
+    ChangedRanges.push_back(tooling::Range(Offset, Length));
+  }
+
+  return ChangedRanges;
+}
+
+bool writeFiles(const clang::Rewriter &Rewrites) {
+
+  for (auto BufferI = Rewrites.buffer_begin(), BufferE = Rewrites.buffer_end();
+       BufferI != BufferE; ++BufferI) {
+    StringRef FileName =
+        Rewrites.getSourceMgr().getFileEntryForID(BufferI->first)->getName();
+
+    std::error_code EC;
+    llvm::raw_fd_ostream FileStream(FileName, EC, llvm::sys::fs::F_Text);
+    if (EC) {
+      errs() << "Warning: Could not write to " << EC.message() << "\n";
+      continue;
+    }
+    BufferI->second.write(FileStream);
+  }
+
+  return true;
 }
 
 bool deleteReplacementFiles(const TUReplacementFiles &Files,

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

@@ -2,7 +2,7 @@ set(LLVM_LINK_COMPONENTS
   Support
   )
 
-add_clang_tool(clang-apply-replacements
+add_clang_executable(clang-apply-replacements
   ClangApplyReplacementsMain.cpp
   )
 target_link_libraries(clang-apply-replacements
@@ -12,7 +12,6 @@ target_link_libraries(clang-apply-replacements
   clangFormat
   clangRewrite
   clangToolingCore
-  clangToolingRefactor
   )
 
 install(TARGETS clang-apply-replacements

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

@@ -86,6 +86,116 @@ static void printVersion(raw_ostream &OS) {
   OS << "clang-apply-replacements version " CLANG_VERSION_STRING << "\n";
 }
 
+/// \brief Convenience function to get rewritten content for \c Filename from
+/// \c Rewrites.
+///
+/// \pre Replacements[i].getFilePath() == Replacements[i+1].getFilePath().
+/// \post Replacements.empty() -> Result.empty()
+///
+/// \param[in] Replacements Replacements to apply
+/// \param[in] Rewrites Rewriter to use to apply replacements.
+/// \param[out] Result Contents of the file after applying replacements if
+/// replacements were provided.
+///
+/// \returns \parblock
+///          \li true if all replacements were applied successfully.
+///          \li false if at least one replacement failed to apply.
+static bool
+getRewrittenData(const std::vector<tooling::Replacement> &Replacements,
+                 Rewriter &Rewrites, std::string &Result) {
+  if (Replacements.empty())
+    return true;
+
+  if (!applyAllReplacements(Replacements, Rewrites))
+    return false;
+
+  SourceManager &SM = Rewrites.getSourceMgr();
+  FileManager &Files = SM.getFileManager();
+
+  StringRef FileName = Replacements.begin()->getFilePath();
+  const clang::FileEntry *Entry = Files.getFile(FileName);
+  assert(Entry && "Expected an existing file");
+  FileID ID = SM.translateFile(Entry);
+  assert(ID.isValid() && "Expected a valid FileID");
+  const RewriteBuffer *Buffer = Rewrites.getRewriteBufferFor(ID);
+  Result = std::string(Buffer->begin(), Buffer->end());
+
+  return true;
+}
+
+/// \brief Apply \c Replacements and return the new file contents.
+///
+/// \pre Replacements[i].getFilePath() == Replacements[i+1].getFilePath().
+/// \post Replacements.empty() -> Result.empty()
+///
+/// \param[in] Replacements Replacements to apply.
+/// \param[out] Result Contents of the file after applying replacements if
+/// replacements were provided.
+/// \param[in] Diagnostics For diagnostic output.
+///
+/// \returns \parblock
+///          \li true if all replacements applied successfully.
+///          \li false if at least one replacement failed to apply.
+static bool
+applyReplacements(const std::vector<tooling::Replacement> &Replacements,
+                  std::string &Result, DiagnosticsEngine &Diagnostics) {
+  FileManager Files((FileSystemOptions()));
+  SourceManager SM(Diagnostics, Files);
+  Rewriter Rewrites(SM, LangOptions());
+
+  return getRewrittenData(Replacements, Rewrites, Result);
+}
+
+/// \brief Apply code formatting to all places where replacements were made.
+///
+/// \pre !Replacements.empty().
+/// \pre Replacements[i].getFilePath() == Replacements[i+1].getFilePath().
+/// \pre Replacements[i].getOffset() <= Replacements[i+1].getOffset().
+///
+/// \param[in] Replacements Replacements that were made to the file. Provided
+/// to indicate where changes were made.
+/// \param[in] FileData The contents of the file \b after \c Replacements have
+/// been applied.
+/// \param[out] FormattedFileData The contents of the file after reformatting.
+/// \param[in] FormatStyle Style to apply.
+/// \param[in] Diagnostics For diagnostic output.
+///
+/// \returns \parblock
+///          \li true if reformatting replacements were all successfully
+///          applied.
+///          \li false if at least one reformatting replacement failed to apply.
+static bool
+applyFormatting(const std::vector<tooling::Replacement> &Replacements,
+                const StringRef FileData, std::string &FormattedFileData,
+                const format::FormatStyle &FormatStyle,
+                DiagnosticsEngine &Diagnostics) {
+  assert(!Replacements.empty() && "Need at least one replacement");
+
+  RangeVector Ranges = calculateChangedRanges(Replacements);
+
+  StringRef FileName = Replacements.begin()->getFilePath();
+  tooling::Replacements R =
+      format::reformat(FormatStyle, FileData, Ranges, FileName);
+
+  // FIXME: Remove this copy when tooling::Replacements is implemented as a
+  // vector instead of a set.
+  std::vector<tooling::Replacement> FormattingReplacements;
+  std::copy(R.begin(), R.end(), back_inserter(FormattingReplacements));
+
+  if (FormattingReplacements.empty()) {
+    FormattedFileData = FileData;
+    return true;
+  }
+
+  FileManager Files((FileSystemOptions()));
+  SourceManager SM(Diagnostics, Files);
+  SM.overrideFileContents(Files.getFile(FileName),
+                          llvm::MemoryBuffer::getMemBufferCopy(FileData));
+  Rewriter Rewrites(SM, LangOptions());
+
+  return getRewrittenData(FormattingReplacements, Rewrites, FormattedFileData);
+}
+
 int main(int argc, char **argv) {
   cl::HideUnrelatedOptions(makeArrayRef(VisibleCategories));
 
@@ -97,13 +207,16 @@ int main(int argc, char **argv) {
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), DiagOpts.get());
 
   // Determine a formatting style from options.
-  auto FormatStyleOrError =
-      format::getStyle(FormatStyleOpt, FormatStyleConfig, "LLVM");
-  if (!FormatStyleOrError) {
-    llvm::errs() << llvm::toString(FormatStyleOrError.takeError()) << "\n";
-    return 1;
+  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;
   }
-  format::FormatStyle FormatStyle = std::move(*FormatStyleOrError);
 
   TUReplacements TURs;
   TUReplacementFiles TUFiles;
@@ -131,23 +244,34 @@ int main(int argc, char **argv) {
   FileManager Files((FileSystemOptions()));
   SourceManager SM(Diagnostics, Files);
 
-  FileToChangesMap Changes;
-  if (!mergeAndDeduplicate(TURs, TUDs, Changes, SM))
+  FileToReplacementsMap GroupedReplacements;
+  if (!mergeAndDeduplicate(TURs, GroupedReplacements, SM))
+    return 1;
+  if (!mergeAndDeduplicate(TUDs, GroupedReplacements, SM))
     return 1;
 
-  tooling::ApplyChangesSpec Spec;
-  Spec.Cleanup = true;
-  Spec.Style = FormatStyle;
-  Spec.Format = DoFormat ? tooling::ApplyChangesSpec::kAll
-                         : tooling::ApplyChangesSpec::kNone;
+  Rewriter ReplacementsRewriter(SM, LangOptions());
 
-  for (const auto &FileChange : Changes) {
-    const FileEntry *Entry = FileChange.first;
-    StringRef FileName = Entry->getName();
-    llvm::Expected<std::string> NewFileData =
-        applyChanges(FileName, FileChange.second, Spec, Diagnostics);
-    if (!NewFileData) {
-      errs() << llvm::toString(NewFileData.takeError()) << "\n";
+  for (const auto &FileAndReplacements : GroupedReplacements) {
+    // This shouldn't happen but if a file somehow has no replacements skip to
+    // next file.
+    if (FileAndReplacements.second.empty())
+      continue;
+
+    std::string NewFileData;
+    StringRef FileName = FileAndReplacements.first->getName();
+    if (!applyReplacements(FileAndReplacements.second, NewFileData,
+                           Diagnostics)) {
+      errs() << "Failed to apply replacements to " << FileName << "\n";
+      continue;
+    }
+
+    // Apply formatting if requested.
+    if (DoFormat &&
+        !applyFormatting(FileAndReplacements.second, NewFileData, NewFileData,
+                         FormatStyle, Diagnostics)) {
+      errs() << "Failed to apply reformatting replacements for " << FileName
+             << "\n";
       continue;
     }
 
@@ -158,7 +282,8 @@ int main(int argc, char **argv) {
       llvm::errs() << "Could not open " << FileName << " for writing\n";
       continue;
     }
-    FileStream << *NewFileData;
+
+    FileStream << NewFileData;
   }
 
   return 0;

clang-tools-extra/clang-doc/BitcodeReader.cpp

@@ -1,622 +0,0 @@
-//===--  BitcodeReader.cpp - ClangDoc Bitcode Reader ------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "BitcodeReader.h"
-#include "llvm/ADT/IndexedMap.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace clang {
-namespace doc {
-
-using Record = llvm::SmallVector<uint64_t, 1024>;
-
-bool decodeRecord(Record R, llvm::SmallVectorImpl<char> &Field,
-                  llvm::StringRef Blob) {
-  Field.assign(Blob.begin(), Blob.end());
-  return true;
-}
-
-bool decodeRecord(Record R, SymbolID &Field, llvm::StringRef Blob) {
-  if (R[0] != BitCodeConstants::USRHashSize)
-    return false;
-
-  // First position in the record is the length of the following array, so we
-  // copy the following elements to the field.
-  for (int I = 0, E = R[0]; I < E; ++I)
-    Field[I] = R[I + 1];
-  return true;
-}
-
-bool decodeRecord(Record R, bool &Field, llvm::StringRef Blob) {
-  Field = R[0] != 0;
-  return true;
-}
-
-bool decodeRecord(Record R, int &Field, llvm::StringRef Blob) {
-  if (R[0] > INT_MAX)
-    return false;
-  Field = (int)R[0];
-  return true;
-}
-
-bool decodeRecord(Record R, AccessSpecifier &Field, llvm::StringRef Blob) {
-  switch (R[0]) {
-  case AS_public:
-  case AS_private:
-  case AS_protected:
-  case AS_none:
-    Field = (AccessSpecifier)R[0];
-    return true;
-  default:
-    return false;
-  }
-}
-
-bool decodeRecord(Record R, TagTypeKind &Field, llvm::StringRef Blob) {
-  switch (R[0]) {
-  case TTK_Struct:
-  case TTK_Interface:
-  case TTK_Union:
-  case TTK_Class:
-  case TTK_Enum:
-    Field = (TagTypeKind)R[0];
-    return true;
-  default:
-    return false;
-  }
-}
-
-bool decodeRecord(Record R, llvm::Optional<Location> &Field,
-                  llvm::StringRef Blob) {
-  if (R[0] > INT_MAX)
-    return false;
-  Field.emplace((int)R[0], Blob);
-  return true;
-}
-
-bool decodeRecord(Record R, InfoType &Field, llvm::StringRef Blob) {
-  switch (auto IT = static_cast<InfoType>(R[0])) {
-  case InfoType::IT_namespace:
-  case InfoType::IT_record:
-  case InfoType::IT_function:
-  case InfoType::IT_default:
-  case InfoType::IT_enum:
-    Field = IT;
-    return true;
-  }
-  return false;
-}
-
-bool decodeRecord(Record R, FieldId &Field, llvm::StringRef Blob) {
-  switch (auto F = static_cast<FieldId>(R[0])) {
-  case FieldId::F_namespace:
-  case FieldId::F_parent:
-  case FieldId::F_vparent:
-  case FieldId::F_type:
-  case FieldId::F_default:
-    Field = F;
-    return true;
-  }
-  return false;
-}
-
-bool decodeRecord(Record R, llvm::SmallVectorImpl<llvm::SmallString<16>> &Field,
-                  llvm::StringRef Blob) {
-  Field.push_back(Blob);
-  return true;
-}
-
-bool decodeRecord(Record R, llvm::SmallVectorImpl<Location> &Field,
-                  llvm::StringRef Blob) {
-  if (R[0] > INT_MAX)
-    return false;
-  Field.emplace_back((int)R[0], Blob);
-  return true;
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
-                 const unsigned VersionNo) {
-  if (ID == VERSION && R[0] == VersionNo)
-    return true;
-  return false;
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
-                 NamespaceInfo *I) {
-  switch (ID) {
-  case NAMESPACE_USR:
-    return decodeRecord(R, I->USR, Blob);
-  case NAMESPACE_NAME:
-    return decodeRecord(R, I->Name, Blob);
-  default:
-    return false;
-  }
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, RecordInfo *I) {
-  switch (ID) {
-  case RECORD_USR:
-    return decodeRecord(R, I->USR, Blob);
-  case RECORD_NAME:
-    return decodeRecord(R, I->Name, Blob);
-  case RECORD_DEFLOCATION:
-    return decodeRecord(R, I->DefLoc, Blob);
-  case RECORD_LOCATION:
-    return decodeRecord(R, I->Loc, Blob);
-  case RECORD_TAG_TYPE:
-    return decodeRecord(R, I->TagType, Blob);
-  default:
-    return false;
-  }
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, EnumInfo *I) {
-  switch (ID) {
-  case ENUM_USR:
-    return decodeRecord(R, I->USR, Blob);
-  case ENUM_NAME:
-    return decodeRecord(R, I->Name, Blob);
-  case ENUM_DEFLOCATION:
-    return decodeRecord(R, I->DefLoc, Blob);
-  case ENUM_LOCATION:
-    return decodeRecord(R, I->Loc, Blob);
-  case ENUM_MEMBER:
-    return decodeRecord(R, I->Members, Blob);
-  case ENUM_SCOPED:
-    return decodeRecord(R, I->Scoped, Blob);
-  default:
-    return false;
-  }
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, FunctionInfo *I) {
-  switch (ID) {
-  case FUNCTION_USR:
-    return decodeRecord(R, I->USR, Blob);
-  case FUNCTION_NAME:
-    return decodeRecord(R, I->Name, Blob);
-  case FUNCTION_DEFLOCATION:
-    return decodeRecord(R, I->DefLoc, Blob);
-  case FUNCTION_LOCATION:
-    return decodeRecord(R, I->Loc, Blob);
-  case FUNCTION_ACCESS:
-    return decodeRecord(R, I->Access, Blob);
-  case FUNCTION_IS_METHOD:
-    return decodeRecord(R, I->IsMethod, Blob);
-  default:
-    return false;
-  }
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, TypeInfo *I) {
-  return true;
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
-                 FieldTypeInfo *I) {
-  switch (ID) {
-  case FIELD_TYPE_NAME:
-    return decodeRecord(R, I->Name, Blob);
-  default:
-    return false;
-  }
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob,
-                 MemberTypeInfo *I) {
-  switch (ID) {
-  case MEMBER_TYPE_NAME:
-    return decodeRecord(R, I->Name, Blob);
-  case MEMBER_TYPE_ACCESS:
-    return decodeRecord(R, I->Access, Blob);
-  default:
-    return false;
-  }
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, CommentInfo *I) {
-  switch (ID) {
-  case COMMENT_KIND:
-    return decodeRecord(R, I->Kind, Blob);
-  case COMMENT_TEXT:
-    return decodeRecord(R, I->Text, Blob);
-  case COMMENT_NAME:
-    return decodeRecord(R, I->Name, Blob);
-  case COMMENT_DIRECTION:
-    return decodeRecord(R, I->Direction, Blob);
-  case COMMENT_PARAMNAME:
-    return decodeRecord(R, I->ParamName, Blob);
-  case COMMENT_CLOSENAME:
-    return decodeRecord(R, I->CloseName, Blob);
-  case COMMENT_ATTRKEY:
-    return decodeRecord(R, I->AttrKeys, Blob);
-  case COMMENT_ATTRVAL:
-    return decodeRecord(R, I->AttrValues, Blob);
-  case COMMENT_ARG:
-    return decodeRecord(R, I->Args, Blob);
-  case COMMENT_SELFCLOSING:
-    return decodeRecord(R, I->SelfClosing, Blob);
-  case COMMENT_EXPLICIT:
-    return decodeRecord(R, I->Explicit, Blob);
-  default:
-    return false;
-  }
-}
-
-bool parseRecord(Record R, unsigned ID, llvm::StringRef Blob, Reference *I,
-                 FieldId &F) {
-  switch (ID) {
-  case REFERENCE_USR:
-    return decodeRecord(R, I->USR, Blob);
-  case REFERENCE_NAME:
-    return decodeRecord(R, I->Name, Blob);
-  case REFERENCE_TYPE:
-    return decodeRecord(R, I->RefType, Blob);
-  case REFERENCE_FIELD:
-    return decodeRecord(R, F, Blob);
-  default:
-    return false;
-  }
-}
-
-template <typename T> CommentInfo *getCommentInfo(T I) {
-  llvm::errs() << "Cannot have comment subblock.\n";
-  exit(1);
-}
-
-template <> CommentInfo *getCommentInfo(FunctionInfo *I) {
-  I->Description.emplace_back();
-  return &I->Description.back();
-}
-
-template <> CommentInfo *getCommentInfo(NamespaceInfo *I) {
-  I->Description.emplace_back();
-  return &I->Description.back();
-}
-
-template <> CommentInfo *getCommentInfo(RecordInfo *I) {
-  I->Description.emplace_back();
-  return &I->Description.back();
-}
-
-template <> CommentInfo *getCommentInfo(EnumInfo *I) {
-  I->Description.emplace_back();
-  return &I->Description.back();
-}
-
-template <> CommentInfo *getCommentInfo(CommentInfo *I) {
-  I->Children.emplace_back(llvm::make_unique<CommentInfo>());
-  return I->Children.back().get();
-}
-
-template <> CommentInfo *getCommentInfo(std::unique_ptr<CommentInfo> &I) {
-  return getCommentInfo(I.get());
-}
-
-template <typename T, typename TTypeInfo>
-void addTypeInfo(T I, TTypeInfo &&TI) {
-  llvm::errs() << "Invalid type for info.\n";
-  exit(1);
-}
-
-template <> void addTypeInfo(RecordInfo *I, MemberTypeInfo &&T) {
-  I->Members.emplace_back(std::move(T));
-}
-
-template <> void addTypeInfo(FunctionInfo *I, TypeInfo &&T) {
-  I->ReturnType = std::move(T);
-}
-
-template <> void addTypeInfo(FunctionInfo *I, FieldTypeInfo &&T) {
-  I->Params.emplace_back(std::move(T));
-}
-
-template <typename T> void addReference(T I, Reference &&R, FieldId F) {
-  llvm::errs() << "Invalid field type for info.\n";
-  exit(1);
-}
-
-template <> void addReference(TypeInfo *I, Reference &&R, FieldId F) {
-  switch (F) {
-  case FieldId::F_type:
-    I->Type = std::move(R);
-    break;
-  default:
-    llvm::errs() << "Invalid field type for info.\n";
-    exit(1);
-  }
-}
-
-template <> void addReference(FieldTypeInfo *I, Reference &&R, FieldId F) {
-  switch (F) {
-  case FieldId::F_type:
-    I->Type = std::move(R);
-    break;
-  default:
-    llvm::errs() << "Invalid field type for info.\n";
-    exit(1);
-  }
-}
-
-template <> void addReference(MemberTypeInfo *I, Reference &&R, FieldId F) {
-  switch (F) {
-  case FieldId::F_type:
-    I->Type = std::move(R);
-    break;
-  default:
-    llvm::errs() << "Invalid field type for info.\n";
-    exit(1);
-  }
-}
-
-template <> void addReference(EnumInfo *I, Reference &&R, FieldId F) {
-  switch (F) {
-  case FieldId::F_namespace:
-    I->Namespace.emplace_back(std::move(R));
-    break;
-  default:
-    llvm::errs() << "Invalid field type for info.\n";
-    exit(1);
-  }
-}
-
-template <> void addReference(NamespaceInfo *I, Reference &&R, FieldId F) {
-  switch (F) {
-  case FieldId::F_namespace:
-    I->Namespace.emplace_back(std::move(R));
-    break;
-  default:
-    llvm::errs() << "Invalid field type for info.\n";
-    exit(1);
-  }
-}
-
-template <> void addReference(FunctionInfo *I, Reference &&R, FieldId F) {
-  switch (F) {
-  case FieldId::F_namespace:
-    I->Namespace.emplace_back(std::move(R));
-    break;
-  case FieldId::F_parent:
-    I->Parent = std::move(R);
-    break;
-  default:
-    llvm::errs() << "Invalid field type for info.\n";
-    exit(1);
-  }
-}
-
-template <> void addReference(RecordInfo *I, Reference &&R, FieldId F) {
-  switch (F) {
-  case FieldId::F_namespace:
-    I->Namespace.emplace_back(std::move(R));
-    break;
-  case FieldId::F_parent:
-    I->Parents.emplace_back(std::move(R));
-    break;
-  case FieldId::F_vparent:
-    I->VirtualParents.emplace_back(std::move(R));
-    break;
-  default:
-    llvm::errs() << "Invalid field type for info.\n";
-    exit(1);
-  }
-}
-
-// Read records from bitcode into a given info.
-template <typename T> bool ClangDocBitcodeReader::readRecord(unsigned ID, T I) {
-  Record R;
-  llvm::StringRef Blob;
-  unsigned RecID = Stream.readRecord(ID, R, &Blob);
-  return parseRecord(R, RecID, Blob, I);
-}
-
-template <> bool ClangDocBitcodeReader::readRecord(unsigned ID, Reference *I) {
-  Record R;
-  llvm::StringRef Blob;
-  unsigned RecID = Stream.readRecord(ID, R, &Blob);
-  return parseRecord(R, RecID, Blob, I, CurrentReferenceField);
-}
-
-// Read a block of records into a single info.
-template <typename T> bool ClangDocBitcodeReader::readBlock(unsigned ID, T I) {
-  if (Stream.EnterSubBlock(ID))
-    return false;
-
-  while (true) {
-    unsigned BlockOrCode = 0;
-    Cursor Res = skipUntilRecordOrBlock(BlockOrCode);
-
-    switch (Res) {
-    case Cursor::BadBlock:
-      return false;
-    case Cursor::BlockEnd:
-      return true;
-    case Cursor::BlockBegin:
-      if (readSubBlock(BlockOrCode, I))
-        continue;
-      if (!Stream.SkipBlock())
-        return false;
-      continue;
-    case Cursor::Record:
-      break;
-    }
-    if (!readRecord(BlockOrCode, I))
-      return false;
-  }
-}
-
-template <typename T>
-bool ClangDocBitcodeReader::readSubBlock(unsigned ID, T I) {
-  switch (ID) {
-  // Blocks can only have Comment, Reference, or TypeInfo subblocks
-  case BI_COMMENT_BLOCK_ID:
-    if (readBlock(ID, getCommentInfo(I)))
-      return true;
-    return false;
-  case BI_TYPE_BLOCK_ID: {
-    TypeInfo TI;
-    if (readBlock(ID, &TI)) {
-      addTypeInfo(I, std::move(TI));
-      return true;
-    }
-    return false;
-  }
-  case BI_FIELD_TYPE_BLOCK_ID: {
-    FieldTypeInfo TI;
-    if (readBlock(ID, &TI)) {
-      addTypeInfo(I, std::move(TI));
-      return true;
-    }
-    return false;
-  }
-  case BI_MEMBER_TYPE_BLOCK_ID: {
-    MemberTypeInfo TI;
-    if (readBlock(ID, &TI)) {
-      addTypeInfo(I, std::move(TI));
-      return true;
-    }
-    return false;
-  }
-  case BI_REFERENCE_BLOCK_ID: {
-    Reference R;
-    if (readBlock(ID, &R)) {
-      addReference(I, std::move(R), CurrentReferenceField);
-      return true;
-    }
-    return false;
-  }
-  default:
-    llvm::errs() << "Invalid subblock type.\n";
-    return false;
-  }
-}
-
-ClangDocBitcodeReader::Cursor
-ClangDocBitcodeReader::skipUntilRecordOrBlock(unsigned &BlockOrRecordID) {
-  BlockOrRecordID = 0;
-
-  while (!Stream.AtEndOfStream()) {
-    unsigned Code = Stream.ReadCode();
-
-    switch ((llvm::bitc::FixedAbbrevIDs)Code) {
-    case llvm::bitc::ENTER_SUBBLOCK:
-      BlockOrRecordID = Stream.ReadSubBlockID();
-      return Cursor::BlockBegin;
-    case llvm::bitc::END_BLOCK:
-      if (Stream.ReadBlockEnd())
-        return Cursor::BadBlock;
-      return Cursor::BlockEnd;
-    case llvm::bitc::DEFINE_ABBREV:
-      Stream.ReadAbbrevRecord();
-      continue;
-    case llvm::bitc::UNABBREV_RECORD:
-      return Cursor::BadBlock;
-    default:
-      BlockOrRecordID = Code;
-      return Cursor::Record;
-    }
-  }
-  llvm_unreachable("Premature stream end.");
-}
-
-bool ClangDocBitcodeReader::validateStream() {
-  if (Stream.AtEndOfStream())
-    return false;
-
-  // Sniff for the signature.
-  if (Stream.Read(8) != BitCodeConstants::Signature[0] ||
-      Stream.Read(8) != BitCodeConstants::Signature[1] ||
-      Stream.Read(8) != BitCodeConstants::Signature[2] ||
-      Stream.Read(8) != BitCodeConstants::Signature[3])
-    return false;
-  return true;
-}
-
-bool ClangDocBitcodeReader::readBlockInfoBlock() {
-  BlockInfo = Stream.ReadBlockInfoBlock();
-  if (!BlockInfo)
-    return false;
-  Stream.setBlockInfo(&*BlockInfo);
-  return true;
-}
-
-template <typename T>
-std::unique_ptr<Info> ClangDocBitcodeReader::createInfo(unsigned ID) {
-  std::unique_ptr<Info> I = llvm::make_unique<T>();
-  if (readBlock(ID, static_cast<T *>(I.get())))
-    return I;
-  llvm::errs() << "Error reading from block.\n";
-  return nullptr;
-}
-
-std::unique_ptr<Info> ClangDocBitcodeReader::readBlockToInfo(unsigned ID) {
-  switch (ID) {
-  case BI_NAMESPACE_BLOCK_ID:
-    return createInfo<NamespaceInfo>(ID);
-  case BI_RECORD_BLOCK_ID:
-    return createInfo<RecordInfo>(ID);
-  case BI_ENUM_BLOCK_ID:
-    return createInfo<EnumInfo>(ID);
-  case BI_FUNCTION_BLOCK_ID:
-    return createInfo<FunctionInfo>(ID);
-  default:
-    llvm::errs() << "Error reading from block.\n";
-    return nullptr;
-  }
-}
-
-// Entry point
-std::vector<std::unique_ptr<Info>> ClangDocBitcodeReader::readBitcode() {
-  std::vector<std::unique_ptr<Info>> Infos;
-  if (!validateStream())
-    return Infos;
-
-  // Read the top level blocks.
-  while (!Stream.AtEndOfStream()) {
-    unsigned Code = Stream.ReadCode();
-    if (Code != llvm::bitc::ENTER_SUBBLOCK)
-      return Infos;
-
-    unsigned ID = Stream.ReadSubBlockID();
-    switch (ID) {
-    // NamedType and Comment blocks should not appear at the top level
-    case BI_TYPE_BLOCK_ID:
-    case BI_FIELD_TYPE_BLOCK_ID:
-    case BI_MEMBER_TYPE_BLOCK_ID:
-    case BI_COMMENT_BLOCK_ID:
-    case BI_REFERENCE_BLOCK_ID:
-      llvm::errs() << "Invalid top level block.\n";
-      return Infos;
-    case BI_NAMESPACE_BLOCK_ID:
-    case BI_RECORD_BLOCK_ID:
-    case BI_ENUM_BLOCK_ID:
-    case BI_FUNCTION_BLOCK_ID:
-      if (std::unique_ptr<Info> I = readBlockToInfo(ID)) {
-        Infos.emplace_back(std::move(I));
-      }
-      return Infos;
-    case BI_VERSION_BLOCK_ID:
-      if (readBlock(ID, VersionNumber))
-        continue;
-      return Infos;
-    case llvm::bitc::BLOCKINFO_BLOCK_ID:
-      if (readBlockInfoBlock())
-        continue;
-      return Infos;
-    default:
-      if (!Stream.SkipBlock())
-        continue;
-    }
-  }
-  return Infos;
-}
-
-} // namespace doc
-} // namespace clang

clang-tools-extra/clang-doc/BitcodeReader.h

@@ -1,73 +0,0 @@
-//===--  BitcodeReader.h - ClangDoc Bitcode Reader --------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements a reader for parsing the clang-doc internal
-// representation from LLVM bitcode. The reader takes in a stream of bits and
-// generates the set of infos that it represents.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEREADER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEREADER_H
-
-#include "BitcodeWriter.h"
-#include "Representation.h"
-#include "clang/AST/AST.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/Bitcode/BitstreamReader.h"
-
-namespace clang {
-namespace doc {
-
-// Class to read bitstream into an InfoSet collection
-class ClangDocBitcodeReader {
-public:
-  ClangDocBitcodeReader(llvm::BitstreamCursor &Stream) : Stream(Stream) {}
-
-  // Main entry point, calls readBlock to read each block in the given stream.
-  std::vector<std::unique_ptr<Info>> readBitcode();
-
-private:
-  enum class Cursor { BadBlock = 1, Record, BlockEnd, BlockBegin };
-
-  // Top level parsing
-  bool validateStream();
-  bool readVersion();
-  bool readBlockInfoBlock();
-
-  // Read a block of records into a single Info struct, calls readRecord on each
-  // record found.
-  template <typename T> bool readBlock(unsigned ID, T I);
-
-  // Step through a block of records to find the next data field.
-  template <typename T> bool readSubBlock(unsigned ID, T I);
-
-  // Read record data into the given Info data field, calling the appropriate
-  // parseRecord functions to parse and store the data.
-  template <typename T> bool readRecord(unsigned ID, T I);
-
-  // Allocate the relevant type of info and add read data to the object.
-  template <typename T> std::unique_ptr<Info> createInfo(unsigned ID);
-
-  // Helper function to step through blocks to find and dispatch the next record
-  // or block to be read.
-  Cursor skipUntilRecordOrBlock(unsigned &BlockOrRecordID);
-
-  // Helper function to set up the approriate type of Info.
-  std::unique_ptr<Info> readBlockToInfo(unsigned ID);
-
-  llvm::BitstreamCursor &Stream;
-  Optional<llvm::BitstreamBlockInfo> BlockInfo;
-  FieldId CurrentReferenceField;
-};
-
-} // namespace doc
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEREADER_H

clang-tools-extra/clang-doc/BitcodeWriter.cpp

@@ -1,518 +0,0 @@
-//===--  BitcodeWriter.cpp - ClangDoc Bitcode Writer ------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "BitcodeWriter.h"
-#include "llvm/ADT/IndexedMap.h"
-#include <initializer_list>
-
-namespace clang {
-namespace doc {
-
-// Empty SymbolID for comparison, so we don't have to construct one every time.
-static const SymbolID EmptySID = SymbolID();
-
-// Since id enums are not zero-indexed, we need to transform the given id into
-// its associated index.
-struct BlockIdToIndexFunctor {
-  using argument_type = unsigned;
-  unsigned operator()(unsigned ID) const { return ID - BI_FIRST; }
-};
-
-struct RecordIdToIndexFunctor {
-  using argument_type = unsigned;
-  unsigned operator()(unsigned ID) const { return ID - RI_FIRST; }
-};
-
-using AbbrevDsc = void (*)(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev);
-
-static void AbbrevGen(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev,
-                      const std::initializer_list<llvm::BitCodeAbbrevOp> Ops) {
-  for (const auto &Op : Ops)
-    Abbrev->Add(Op);
-}
-
-static void BoolAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
-  AbbrevGen(Abbrev,
-            {// 0. Boolean
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
-                                   BitCodeConstants::BoolSize)});
-}
-
-static void IntAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
-  AbbrevGen(Abbrev,
-            {// 0. Fixed-size integer
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
-                                   BitCodeConstants::IntSize)});
-}
-
-static void SymbolIDAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
-  AbbrevGen(Abbrev,
-            {// 0. Fixed-size integer (length of the sha1'd USR)
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
-                                   BitCodeConstants::USRLengthSize),
-             // 1. Fixed-size array of Char6 (USR)
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Array),
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
-                                   BitCodeConstants::USRBitLengthSize)});
-}
-
-static void StringAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
-  AbbrevGen(Abbrev,
-            {// 0. Fixed-size integer (length of the following string)
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
-                                   BitCodeConstants::StringLengthSize),
-             // 1. The string blob
-             llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)});
-}
-
-// Assumes that the file will not have more than 65535 lines.
-static void LocationAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
-  AbbrevGen(
-      Abbrev,
-      {// 0. Fixed-size integer (line number)
-       llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
-                             BitCodeConstants::LineNumberSize),
-       // 1. Fixed-size integer (length of the following string (filename))
-       llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
-                             BitCodeConstants::StringLengthSize),
-       // 2. The string blob
-       llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)});
-}
-
-struct RecordIdDsc {
-  llvm::StringRef Name;
-  AbbrevDsc Abbrev = nullptr;
-
-  RecordIdDsc() = default;
-  RecordIdDsc(llvm::StringRef Name, AbbrevDsc Abbrev)
-      : Name(Name), Abbrev(Abbrev) {}
-
-  // Is this 'description' valid?
-  operator bool() const {
-    return Abbrev != nullptr && Name.data() != nullptr && !Name.empty();
-  }
-};
-
-static const llvm::IndexedMap<llvm::StringRef, BlockIdToIndexFunctor>
-    BlockIdNameMap = []() {
-      llvm::IndexedMap<llvm::StringRef, BlockIdToIndexFunctor> BlockIdNameMap;
-      BlockIdNameMap.resize(BlockIdCount);
-
-      // There is no init-list constructor for the IndexedMap, so have to
-      // improvise
-      static const std::vector<std::pair<BlockId, const char *const>> Inits = {
-          {BI_VERSION_BLOCK_ID, "VersionBlock"},
-          {BI_NAMESPACE_BLOCK_ID, "NamespaceBlock"},
-          {BI_ENUM_BLOCK_ID, "EnumBlock"},
-          {BI_TYPE_BLOCK_ID, "TypeBlock"},
-          {BI_FIELD_TYPE_BLOCK_ID, "FieldTypeBlock"},
-          {BI_MEMBER_TYPE_BLOCK_ID, "MemberTypeBlock"},
-          {BI_RECORD_BLOCK_ID, "RecordBlock"},
-          {BI_FUNCTION_BLOCK_ID, "FunctionBlock"},
-          {BI_COMMENT_BLOCK_ID, "CommentBlock"},
-          {BI_REFERENCE_BLOCK_ID, "ReferenceBlock"}};
-      assert(Inits.size() == BlockIdCount);
-      for (const auto &Init : Inits)
-        BlockIdNameMap[Init.first] = Init.second;
-      assert(BlockIdNameMap.size() == BlockIdCount);
-      return BlockIdNameMap;
-    }();
-
-static const llvm::IndexedMap<RecordIdDsc, RecordIdToIndexFunctor>
-    RecordIdNameMap = []() {
-      llvm::IndexedMap<RecordIdDsc, RecordIdToIndexFunctor> RecordIdNameMap;
-      RecordIdNameMap.resize(RecordIdCount);
-
-      // There is no init-list constructor for the IndexedMap, so have to
-      // improvise
-      static const std::vector<std::pair<RecordId, RecordIdDsc>> Inits = {
-          {VERSION, {"Version", &IntAbbrev}},
-          {COMMENT_KIND, {"Kind", &StringAbbrev}},
-          {COMMENT_TEXT, {"Text", &StringAbbrev}},
-          {COMMENT_NAME, {"Name", &StringAbbrev}},
-          {COMMENT_DIRECTION, {"Direction", &StringAbbrev}},
-          {COMMENT_PARAMNAME, {"ParamName", &StringAbbrev}},
-          {COMMENT_CLOSENAME, {"CloseName", &StringAbbrev}},
-          {COMMENT_SELFCLOSING, {"SelfClosing", &BoolAbbrev}},
-          {COMMENT_EXPLICIT, {"Explicit", &BoolAbbrev}},
-          {COMMENT_ATTRKEY, {"AttrKey", &StringAbbrev}},
-          {COMMENT_ATTRVAL, {"AttrVal", &StringAbbrev}},
-          {COMMENT_ARG, {"Arg", &StringAbbrev}},
-          {FIELD_TYPE_NAME, {"Name", &StringAbbrev}},
-          {MEMBER_TYPE_NAME, {"Name", &StringAbbrev}},
-          {MEMBER_TYPE_ACCESS, {"Access", &IntAbbrev}},
-          {NAMESPACE_USR, {"USR", &SymbolIDAbbrev}},
-          {NAMESPACE_NAME, {"Name", &StringAbbrev}},
-          {ENUM_USR, {"USR", &SymbolIDAbbrev}},
-          {ENUM_NAME, {"Name", &StringAbbrev}},
-          {ENUM_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
-          {ENUM_LOCATION, {"Location", &LocationAbbrev}},
-          {ENUM_MEMBER, {"Member", &StringAbbrev}},
-          {ENUM_SCOPED, {"Scoped", &BoolAbbrev}},
-          {RECORD_USR, {"USR", &SymbolIDAbbrev}},
-          {RECORD_NAME, {"Name", &StringAbbrev}},
-          {RECORD_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
-          {RECORD_LOCATION, {"Location", &LocationAbbrev}},
-          {RECORD_TAG_TYPE, {"TagType", &IntAbbrev}},
-          {FUNCTION_USR, {"USR", &SymbolIDAbbrev}},
-          {FUNCTION_NAME, {"Name", &StringAbbrev}},
-          {FUNCTION_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
-          {FUNCTION_LOCATION, {"Location", &LocationAbbrev}},
-          {FUNCTION_ACCESS, {"Access", &IntAbbrev}},
-          {FUNCTION_IS_METHOD, {"IsMethod", &BoolAbbrev}},
-          {REFERENCE_USR, {"USR", &SymbolIDAbbrev}},
-          {REFERENCE_NAME, {"Name", &StringAbbrev}},
-          {REFERENCE_TYPE, {"RefType", &IntAbbrev}},
-          {REFERENCE_FIELD, {"Field", &IntAbbrev}}};
-      assert(Inits.size() == RecordIdCount);
-      for (const auto &Init : Inits) {
-        RecordIdNameMap[Init.first] = Init.second;
-        assert((Init.second.Name.size() + 1) <= BitCodeConstants::RecordSize);
-      }
-      assert(RecordIdNameMap.size() == RecordIdCount);
-      return RecordIdNameMap;
-    }();
-
-static const std::vector<std::pair<BlockId, std::vector<RecordId>>>
-    RecordsByBlock{
-        // Version Block
-        {BI_VERSION_BLOCK_ID, {VERSION}},
-        // Comment Block
-        {BI_COMMENT_BLOCK_ID,
-         {COMMENT_KIND, COMMENT_TEXT, COMMENT_NAME, COMMENT_DIRECTION,
-          COMMENT_PARAMNAME, COMMENT_CLOSENAME, COMMENT_SELFCLOSING,
-          COMMENT_EXPLICIT, COMMENT_ATTRKEY, COMMENT_ATTRVAL, COMMENT_ARG}},
-        // Type Block
-        {BI_TYPE_BLOCK_ID, {}},
-        // FieldType Block
-        {BI_FIELD_TYPE_BLOCK_ID, {FIELD_TYPE_NAME}},
-        // MemberType Block
-        {BI_MEMBER_TYPE_BLOCK_ID, {MEMBER_TYPE_NAME, MEMBER_TYPE_ACCESS}},
-        // Enum Block
-        {BI_ENUM_BLOCK_ID,
-         {ENUM_USR, ENUM_NAME, ENUM_DEFLOCATION, ENUM_LOCATION, ENUM_MEMBER,
-          ENUM_SCOPED}},
-        // Namespace Block
-        {BI_NAMESPACE_BLOCK_ID, {NAMESPACE_USR, NAMESPACE_NAME}},
-        // Record Block
-        {BI_RECORD_BLOCK_ID,
-         {RECORD_USR, RECORD_NAME, RECORD_DEFLOCATION, RECORD_LOCATION,
-          RECORD_TAG_TYPE}},
-        // Function Block
-        {BI_FUNCTION_BLOCK_ID,
-         {FUNCTION_USR, FUNCTION_NAME, FUNCTION_DEFLOCATION, FUNCTION_LOCATION,
-          FUNCTION_ACCESS, FUNCTION_IS_METHOD}},
-        // Reference Block
-        {BI_REFERENCE_BLOCK_ID,
-         {REFERENCE_USR, REFERENCE_NAME, REFERENCE_TYPE, REFERENCE_FIELD}}};
-
-// AbbreviationMap
-
-constexpr char BitCodeConstants::Signature[];
-
-void ClangDocBitcodeWriter::AbbreviationMap::add(RecordId RID,
-                                                 unsigned AbbrevID) {
-  assert(RecordIdNameMap[RID] && "Unknown RecordId.");
-  assert(Abbrevs.find(RID) == Abbrevs.end() && "Abbreviation already added.");
-  Abbrevs[RID] = AbbrevID;
-}
-
-unsigned ClangDocBitcodeWriter::AbbreviationMap::get(RecordId RID) const {
-  assert(RecordIdNameMap[RID] && "Unknown RecordId.");
-  assert(Abbrevs.find(RID) != Abbrevs.end() && "Unknown abbreviation.");
-  return Abbrevs.lookup(RID);
-}
-
-// Validation and Overview Blocks
-
-/// \brief Emits the magic number header to check that its the right format,
-/// in this case, 'DOCS'.
-void ClangDocBitcodeWriter::emitHeader() {
-  for (char C : BitCodeConstants::Signature)
-    Stream.Emit((unsigned)C, BitCodeConstants::SignatureBitSize);
-}
-
-void ClangDocBitcodeWriter::emitVersionBlock() {
-  StreamSubBlockGuard Block(Stream, BI_VERSION_BLOCK_ID);
-  emitRecord(VersionNumber, VERSION);
-}
-
-/// \brief Emits a block ID and the block name to the BLOCKINFO block.
-void ClangDocBitcodeWriter::emitBlockID(BlockId BID) {
-  const auto &BlockIdName = BlockIdNameMap[BID];
-  assert(BlockIdName.data() && BlockIdName.size() && "Unknown BlockId.");
-
-  Record.clear();
-  Record.push_back(BID);
-  Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
-  Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME,
-                    ArrayRef<unsigned char>(BlockIdName.bytes_begin(),
-                                            BlockIdName.bytes_end()));
-}
-
-/// \brief Emits a record name to the BLOCKINFO block.
-void ClangDocBitcodeWriter::emitRecordID(RecordId ID) {
-  assert(RecordIdNameMap[ID] && "Unknown RecordId.");
-  prepRecordData(ID);
-  Record.append(RecordIdNameMap[ID].Name.begin(),
-                RecordIdNameMap[ID].Name.end());
-  Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
-}
-
-// Abbreviations
-
-void ClangDocBitcodeWriter::emitAbbrev(RecordId ID, BlockId Block) {
-  assert(RecordIdNameMap[ID] && "Unknown abbreviation.");
-  auto Abbrev = std::make_shared<llvm::BitCodeAbbrev>();
-  Abbrev->Add(llvm::BitCodeAbbrevOp(ID));
-  RecordIdNameMap[ID].Abbrev(Abbrev);
-  Abbrevs.add(ID, Stream.EmitBlockInfoAbbrev(Block, std::move(Abbrev)));
-}
-
-// Records
-
-void ClangDocBitcodeWriter::emitRecord(const SymbolID &Sym, RecordId ID) {
-  assert(RecordIdNameMap[ID] && "Unknown RecordId.");
-  assert(RecordIdNameMap[ID].Abbrev == &SymbolIDAbbrev &&
-         "Abbrev type mismatch.");
-  if (!prepRecordData(ID, Sym != EmptySID))
-    return;
-  assert(Sym.size() == 20);
-  Record.push_back(Sym.size());
-  Record.append(Sym.begin(), Sym.end());
-  Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
-}
-
-void ClangDocBitcodeWriter::emitRecord(llvm::StringRef Str, RecordId ID) {
-  assert(RecordIdNameMap[ID] && "Unknown RecordId.");
-  assert(RecordIdNameMap[ID].Abbrev == &StringAbbrev &&
-         "Abbrev type mismatch.");
-  if (!prepRecordData(ID, !Str.empty()))
-    return;
-  assert(Str.size() < (1U << BitCodeConstants::StringLengthSize));
-  Record.push_back(Str.size());
-  Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, Str);
-}
-
-void ClangDocBitcodeWriter::emitRecord(const Location &Loc, RecordId ID) {
-  assert(RecordIdNameMap[ID] && "Unknown RecordId.");
-  assert(RecordIdNameMap[ID].Abbrev == &LocationAbbrev &&
-         "Abbrev type mismatch.");
-  if (!prepRecordData(ID, true))
-    return;
-  // FIXME: Assert that the line number is of the appropriate size.
-  Record.push_back(Loc.LineNumber);
-  assert(Loc.Filename.size() < (1U << BitCodeConstants::StringLengthSize));
-  // Record.push_back(Loc.Filename.size());
-  // Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, Loc.Filename);
-  Record.push_back(4);
-  Stream.EmitRecordWithBlob(Abbrevs.get(ID), Record, "test");
-}
-
-void ClangDocBitcodeWriter::emitRecord(bool Val, RecordId ID) {
-  assert(RecordIdNameMap[ID] && "Unknown RecordId.");
-  assert(RecordIdNameMap[ID].Abbrev == &BoolAbbrev && "Abbrev type mismatch.");
-  if (!prepRecordData(ID, Val))
-    return;
-  Record.push_back(Val);
-  Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
-}
-
-void ClangDocBitcodeWriter::emitRecord(int Val, RecordId ID) {
-  assert(RecordIdNameMap[ID] && "Unknown RecordId.");
-  assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch.");
-  if (!prepRecordData(ID, Val))
-    return;
-  // FIXME: Assert that the integer is of the appropriate size.
-  Record.push_back(Val);
-  Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
-}
-
-void ClangDocBitcodeWriter::emitRecord(unsigned Val, RecordId ID) {
-  assert(RecordIdNameMap[ID] && "Unknown RecordId.");
-  assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch.");
-  if (!prepRecordData(ID, Val))
-    return;
-  assert(Val < (1U << BitCodeConstants::IntSize));
-  Record.push_back(Val);
-  Stream.EmitRecordWithAbbrev(Abbrevs.get(ID), Record);
-}
-
-bool ClangDocBitcodeWriter::prepRecordData(RecordId ID, bool ShouldEmit) {
-  assert(RecordIdNameMap[ID] && "Unknown RecordId.");
-  if (!ShouldEmit)
-    return false;
-  Record.clear();
-  Record.push_back(ID);
-  return true;
-}
-
-// BlockInfo Block
-
-void ClangDocBitcodeWriter::emitBlockInfoBlock() {
-  Stream.EnterBlockInfoBlock();
-  for (const auto &Block : RecordsByBlock) {
-    assert(Block.second.size() < (1U << BitCodeConstants::SubblockIDSize));
-    emitBlockInfo(Block.first, Block.second);
-  }
-  Stream.ExitBlock();
-}
-
-void ClangDocBitcodeWriter::emitBlockInfo(BlockId BID,
-                                          const std::vector<RecordId> &RIDs) {
-  assert(RIDs.size() < (1U << BitCodeConstants::SubblockIDSize));
-  emitBlockID(BID);
-  for (RecordId RID : RIDs) {
-    emitRecordID(RID);
-    emitAbbrev(RID, BID);
-  }
-}
-
-// Block emission
-
-void ClangDocBitcodeWriter::emitBlock(const Reference &R, FieldId Field) {
-  if (R.USR == EmptySID && R.Name.empty())
-    return;
-  StreamSubBlockGuard Block(Stream, BI_REFERENCE_BLOCK_ID);
-  emitRecord(R.USR, REFERENCE_USR);
-  emitRecord(R.Name, REFERENCE_NAME);
-  emitRecord((unsigned)R.RefType, REFERENCE_TYPE);
-  emitRecord((unsigned)Field, REFERENCE_FIELD);
-}
-
-void ClangDocBitcodeWriter::emitBlock(const TypeInfo &T) {
-  StreamSubBlockGuard Block(Stream, BI_TYPE_BLOCK_ID);
-  emitBlock(T.Type, FieldId::F_type);
-}
-
-void ClangDocBitcodeWriter::emitBlock(const FieldTypeInfo &T) {
-  StreamSubBlockGuard Block(Stream, BI_FIELD_TYPE_BLOCK_ID);
-  emitBlock(T.Type, FieldId::F_type);
-  emitRecord(T.Name, FIELD_TYPE_NAME);
-}
-
-void ClangDocBitcodeWriter::emitBlock(const MemberTypeInfo &T) {
-  StreamSubBlockGuard Block(Stream, BI_MEMBER_TYPE_BLOCK_ID);
-  emitBlock(T.Type, FieldId::F_type);
-  emitRecord(T.Name, MEMBER_TYPE_NAME);
-  emitRecord(T.Access, MEMBER_TYPE_ACCESS);
-}
-
-void ClangDocBitcodeWriter::emitBlock(const CommentInfo &I) {
-  StreamSubBlockGuard Block(Stream, BI_COMMENT_BLOCK_ID);
-  for (const auto &L : std::vector<std::pair<llvm::StringRef, RecordId>>{
-           {I.Kind, COMMENT_KIND},
-           {I.Text, COMMENT_TEXT},
-           {I.Name, COMMENT_NAME},
-           {I.Direction, COMMENT_DIRECTION},
-           {I.ParamName, COMMENT_PARAMNAME},
-           {I.CloseName, COMMENT_CLOSENAME}})
-    emitRecord(L.first, L.second);
-  emitRecord(I.SelfClosing, COMMENT_SELFCLOSING);
-  emitRecord(I.Explicit, COMMENT_EXPLICIT);
-  for (const auto &A : I.AttrKeys)
-    emitRecord(A, COMMENT_ATTRKEY);
-  for (const auto &A : I.AttrValues)
-    emitRecord(A, COMMENT_ATTRVAL);
-  for (const auto &A : I.Args)
-    emitRecord(A, COMMENT_ARG);
-  for (const auto &C : I.Children)
-    emitBlock(*C);
-}
-
-void ClangDocBitcodeWriter::emitBlock(const NamespaceInfo &I) {
-  StreamSubBlockGuard Block(Stream, BI_NAMESPACE_BLOCK_ID);
-  emitRecord(I.USR, NAMESPACE_USR);
-  emitRecord(I.Name, NAMESPACE_NAME);
-  for (const auto &N : I.Namespace)
-    emitBlock(N, FieldId::F_namespace);
-  for (const auto &CI : I.Description)
-    emitBlock(CI);
-}
-
-void ClangDocBitcodeWriter::emitBlock(const EnumInfo &I) {
-  StreamSubBlockGuard Block(Stream, BI_ENUM_BLOCK_ID);
-  emitRecord(I.USR, ENUM_USR);
-  emitRecord(I.Name, ENUM_NAME);
-  for (const auto &N : I.Namespace)
-    emitBlock(N, FieldId::F_namespace);
-  for (const auto &CI : I.Description)
-    emitBlock(CI);
-  if (I.DefLoc)
-    emitRecord(I.DefLoc.getValue(), ENUM_DEFLOCATION);
-  for (const auto &L : I.Loc)
-    emitRecord(L, ENUM_LOCATION);
-  emitRecord(I.Scoped, ENUM_SCOPED);
-  for (const auto &N : I.Members)
-    emitRecord(N, ENUM_MEMBER);
-}
-
-void ClangDocBitcodeWriter::emitBlock(const RecordInfo &I) {
-  StreamSubBlockGuard Block(Stream, BI_RECORD_BLOCK_ID);
-  emitRecord(I.USR, RECORD_USR);
-  emitRecord(I.Name, RECORD_NAME);
-  for (const auto &N : I.Namespace)
-    emitBlock(N, FieldId::F_namespace);
-  for (const auto &CI : I.Description)
-    emitBlock(CI);
-  if (I.DefLoc)
-    emitRecord(I.DefLoc.getValue(), RECORD_DEFLOCATION);
-  for (const auto &L : I.Loc)
-    emitRecord(L, RECORD_LOCATION);
-  emitRecord(I.TagType, RECORD_TAG_TYPE);
-  for (const auto &N : I.Members)
-    emitBlock(N);
-  for (const auto &P : I.Parents)
-    emitBlock(P, FieldId::F_parent);
-  for (const auto &P : I.VirtualParents)
-    emitBlock(P, FieldId::F_vparent);
-}
-
-void ClangDocBitcodeWriter::emitBlock(const FunctionInfo &I) {
-  StreamSubBlockGuard Block(Stream, BI_FUNCTION_BLOCK_ID);
-  emitRecord(I.USR, FUNCTION_USR);
-  emitRecord(I.Name, FUNCTION_NAME);
-  for (const auto &N : I.Namespace)
-    emitBlock(N, FieldId::F_namespace);
-  for (const auto &CI : I.Description)
-    emitBlock(CI);
-  emitRecord(I.IsMethod, FUNCTION_IS_METHOD);
-  if (I.DefLoc)
-    emitRecord(I.DefLoc.getValue(), FUNCTION_DEFLOCATION);
-  for (const auto &L : I.Loc)
-    emitRecord(L, FUNCTION_LOCATION);
-  emitBlock(I.Parent, FieldId::F_parent);
-  emitBlock(I.ReturnType);
-  for (const auto &N : I.Params)
-    emitBlock(N);
-}
-
-bool ClangDocBitcodeWriter::dispatchInfoForWrite(Info *I) {
-  switch (I->IT) {
-  case InfoType::IT_namespace:
-    emitBlock(*static_cast<clang::doc::NamespaceInfo *>(I));
-    break;
-  case InfoType::IT_record:
-    emitBlock(*static_cast<clang::doc::RecordInfo *>(I));
-    break;
-  case InfoType::IT_enum:
-    emitBlock(*static_cast<clang::doc::EnumInfo *>(I));
-    break;
-  case InfoType::IT_function:
-    emitBlock(*static_cast<clang::doc::FunctionInfo *>(I));
-    break;
-  default:
-    llvm::errs() << "Unexpected info, unable to write.\n";
-    return true;
-  }
-  return false;
-}
-
-} // namespace doc
-} // namespace clang

clang-tools-extra/clang-doc/BitcodeWriter.h

@@ -1,201 +0,0 @@
-//===--  BitcodeWriter.h - ClangDoc Bitcode Writer --------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements a writer for serializing the clang-doc internal
-// representation to LLVM bitcode. The writer takes in a stream and emits the
-// generated bitcode to that stream.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEWRITER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEWRITER_H
-
-#include "Representation.h"
-#include "clang/AST/AST.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Bitcode/BitstreamWriter.h"
-#include <initializer_list>
-#include <vector>
-
-namespace clang {
-namespace doc {
-
-// Current version number of clang-doc bitcode.
-// Should be bumped when removing or changing BlockIds, RecordIds, or
-// BitCodeConstants, though they can be added without breaking it.
-static const unsigned VersionNumber = 2;
-
-struct BitCodeConstants {
-  static constexpr unsigned RecordSize = 32U;
-  static constexpr unsigned SignatureBitSize = 8U;
-  static constexpr unsigned SubblockIDSize = 4U;
-  static constexpr unsigned BoolSize = 1U;
-  static constexpr unsigned IntSize = 16U;
-  static constexpr unsigned StringLengthSize = 16U;
-  static constexpr unsigned FilenameLengthSize = 16U;
-  static constexpr unsigned LineNumberSize = 16U;
-  static constexpr unsigned ReferenceTypeSize = 8U;
-  static constexpr unsigned USRLengthSize = 6U;
-  static constexpr unsigned USRBitLengthSize = 8U;
-  static constexpr char Signature[4] = {'D', 'O', 'C', 'S'};
-  static constexpr int USRHashSize = 20;
-};
-
-// New Ids need to be added to both the enum here and the relevant IdNameMap in
-// the implementation file.
-enum BlockId {
-  BI_VERSION_BLOCK_ID = llvm::bitc::FIRST_APPLICATION_BLOCKID,
-  BI_NAMESPACE_BLOCK_ID,
-  BI_ENUM_BLOCK_ID,
-  BI_TYPE_BLOCK_ID,
-  BI_FIELD_TYPE_BLOCK_ID,
-  BI_MEMBER_TYPE_BLOCK_ID,
-  BI_RECORD_BLOCK_ID,
-  BI_FUNCTION_BLOCK_ID,
-  BI_COMMENT_BLOCK_ID,
-  BI_REFERENCE_BLOCK_ID,
-  BI_LAST,
-  BI_FIRST = BI_VERSION_BLOCK_ID
-};
-
-// New Ids need to be added to the enum here, and to the relevant IdNameMap and
-// initialization list in the implementation file.
-#define INFORECORDS(X) X##_USR, X##_NAME
-
-enum RecordId {
-  VERSION = 1,
-  INFORECORDS(FUNCTION),
-  FUNCTION_DEFLOCATION,
-  FUNCTION_LOCATION,
-  FUNCTION_ACCESS,
-  FUNCTION_IS_METHOD,
-  COMMENT_KIND,
-  COMMENT_TEXT,
-  COMMENT_NAME,
-  COMMENT_DIRECTION,
-  COMMENT_PARAMNAME,
-  COMMENT_CLOSENAME,
-  COMMENT_SELFCLOSING,
-  COMMENT_EXPLICIT,
-  COMMENT_ATTRKEY,
-  COMMENT_ATTRVAL,
-  COMMENT_ARG,
-  FIELD_TYPE_NAME,
-  MEMBER_TYPE_NAME,
-  MEMBER_TYPE_ACCESS,
-  INFORECORDS(NAMESPACE),
-  INFORECORDS(ENUM),
-  ENUM_DEFLOCATION,
-  ENUM_LOCATION,
-  ENUM_MEMBER,
-  ENUM_SCOPED,
-  INFORECORDS(RECORD),
-  RECORD_DEFLOCATION,
-  RECORD_LOCATION,
-  RECORD_TAG_TYPE,
-  REFERENCE_USR,
-  REFERENCE_NAME,
-  REFERENCE_TYPE,
-  REFERENCE_FIELD,
-  RI_LAST,
-  RI_FIRST = VERSION
-};
-
-static constexpr unsigned BlockIdCount = BI_LAST - BI_FIRST;
-static constexpr unsigned RecordIdCount = RI_LAST - RI_FIRST;
-
-#undef INFORECORDS
-
-// Identifiers for differentiating between subblocks
-enum class FieldId { F_default, F_namespace, F_parent, F_vparent, F_type };
-
-class ClangDocBitcodeWriter {
-public:
-  ClangDocBitcodeWriter(llvm::BitstreamWriter &Stream) : Stream(Stream) {
-    emitHeader();
-    emitBlockInfoBlock();
-    emitVersionBlock();
-  }
-
-  // Write a specific info to a bitcode stream.
-  bool dispatchInfoForWrite(Info *I);
-
-  // Block emission of different info types.
-  void emitBlock(const NamespaceInfo &I);
-  void emitBlock(const RecordInfo &I);
-  void emitBlock(const FunctionInfo &I);
-  void emitBlock(const EnumInfo &I);
-  void emitBlock(const TypeInfo &B);
-  void emitBlock(const FieldTypeInfo &B);
-  void emitBlock(const MemberTypeInfo &B);
-  void emitBlock(const CommentInfo &B);
-  void emitBlock(const Reference &B, FieldId F);
-
-private:
-  class AbbreviationMap {
-    llvm::DenseMap<unsigned, unsigned> Abbrevs;
-
-  public:
-    AbbreviationMap() : Abbrevs(RecordIdCount) {}
-
-    void add(RecordId RID, unsigned AbbrevID);
-    unsigned get(RecordId RID) const;
-  };
-
-  class StreamSubBlockGuard {
-    llvm::BitstreamWriter &Stream;
-
-  public:
-    StreamSubBlockGuard(llvm::BitstreamWriter &Stream_, BlockId ID)
-        : Stream(Stream_) {
-      // NOTE: SubBlockIDSize could theoretically be calculated on the fly,
-      // based on the initialization list of records in each block.
-      Stream.EnterSubblock(ID, BitCodeConstants::SubblockIDSize);
-    }
-
-    StreamSubBlockGuard(const StreamSubBlockGuard &) = delete;
-    StreamSubBlockGuard &operator=(const StreamSubBlockGuard &) = delete;
-
-    ~StreamSubBlockGuard() { Stream.ExitBlock(); }
-  };
-
-  // Emission of validation and overview blocks.
-  void emitHeader();
-  void emitVersionBlock();
-  void emitRecordID(RecordId ID);
-  void emitBlockID(BlockId ID);
-  void emitBlockInfoBlock();
-  void emitBlockInfo(BlockId BID, const std::vector<RecordId> &RIDs);
-
-  // Emission of individual record types.
-  void emitRecord(StringRef Str, RecordId ID);
-  void emitRecord(const SymbolID &Str, RecordId ID);
-  void emitRecord(const Location &Loc, RecordId ID);
-  void emitRecord(const Reference &Ref, RecordId ID);
-  void emitRecord(bool Value, RecordId ID);
-  void emitRecord(int Value, RecordId ID);
-  void emitRecord(unsigned Value, RecordId ID);
-  bool prepRecordData(RecordId ID, bool ShouldEmit = true);
-
-  // Emission of appropriate abbreviation type.
-  void emitAbbrev(RecordId ID, BlockId Block);
-
-  // Static size is the maximum length of the block/record names we're pushing
-  // to this + 1. Longest is currently `MemberTypeBlock` at 15 chars.
-  SmallVector<uint32_t, BitCodeConstants::RecordSize> Record;
-  llvm::BitstreamWriter &Stream;
-  AbbreviationMap Abbrevs;
-};
-
-} // namespace doc
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_BITCODEWRITER_H

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

@@ -1,29 +0,0 @@
-set(LLVM_LINK_COMPONENTS
-  support
-  BitReader
-  BitWriter
-  )
-
-add_clang_library(clangDoc
-  BitcodeReader.cpp
-  BitcodeWriter.cpp
-  ClangDoc.cpp
-  Generators.cpp
-  Mapper.cpp
-  Representation.cpp
-  Serialize.cpp
-  YAMLGenerator.cpp
-
-  LINK_LIBS
-  clangAnalysis
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangFrontend
-  clangIndex
-  clangLex
-  clangTooling
-  clangToolingCore
-  )
-
-add_subdirectory(tool)

clang-tools-extra/clang-doc/ClangDoc.cpp

@@ -1,62 +0,0 @@
-//===-- ClangDoc.cpp - ClangDoc ---------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the main entry point for the clang-doc tool. It runs
-// the clang-doc mapper on a given set of source code files using a
-// FrontendActionFactory.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ClangDoc.h"
-#include "Mapper.h"
-#include "Representation.h"
-#include "clang/AST/AST.h"
-#include "clang/AST/ASTConsumer.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/RecursiveASTVisitor.h"
-#include "clang/Frontend/ASTConsumers.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/FrontendActions.h"
-
-namespace clang {
-namespace doc {
-
-class MapperActionFactory : public tooling::FrontendActionFactory {
-public:
-  MapperActionFactory(ClangDocContext CDCtx) : CDCtx(CDCtx) {}
-  clang::FrontendAction *create() override;
-
-private:
-  ClangDocContext CDCtx;
-};
-
-clang::FrontendAction *MapperActionFactory::create() {
-  class ClangDocAction : public clang::ASTFrontendAction {
-  public:
-    ClangDocAction(ClangDocContext CDCtx) : CDCtx(CDCtx) {}
-
-    std::unique_ptr<clang::ASTConsumer>
-    CreateASTConsumer(clang::CompilerInstance &Compiler,
-                      llvm::StringRef InFile) override {
-      return llvm::make_unique<MapASTVisitor>(&Compiler.getASTContext(), CDCtx);
-    }
-
-  private:
-    ClangDocContext CDCtx;
-  };
-  return new ClangDocAction(CDCtx);
-}
-
-std::unique_ptr<tooling::FrontendActionFactory>
-newMapperActionFactory(ClangDocContext CDCtx) {
-  return llvm::make_unique<MapperActionFactory>(CDCtx);
-}
-
-} // namespace doc
-} // namespace clang

clang-tools-extra/clang-doc/ClangDoc.h

@@ -1,34 +0,0 @@
-//===-- ClangDoc.h - ClangDoc -----------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file exposes a method to craete the FrontendActionFactory for the
-// clang-doc tool. The factory runs the clang-doc mapper on a given set of
-// source code files, storing the results key-value pairs in its
-// ExecutionContext.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANGDOC_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANGDOC_H
-
-#include "Representation.h"
-#include "clang/Tooling/Execution.h"
-#include "clang/Tooling/StandaloneExecution.h"
-#include "clang/Tooling/Tooling.h"
-
-namespace clang {
-namespace doc {
-
-std::unique_ptr<tooling::FrontendActionFactory>
-newMapperActionFactory(ClangDocContext CDCtx);
-
-} // namespace doc
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_CLANGDOC_H

clang-tools-extra/clang-doc/Generators.cpp

@@ -1,36 +0,0 @@
-//===---- Generator.cpp - Generator Registry ---------------------*- C++-*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Generators.h"
-
-LLVM_INSTANTIATE_REGISTRY(clang::doc::GeneratorRegistry)
-
-namespace clang {
-namespace doc {
-
-llvm::Expected<std::unique_ptr<Generator>>
-findGeneratorByName(llvm::StringRef Format) {
-  for (auto I = GeneratorRegistry::begin(), E = GeneratorRegistry::end();
-       I != E; ++I) {
-    if (I->getName() != Format)
-      continue;
-    return I->instantiate();
-  }
-  return llvm::make_error<llvm::StringError>("Can't find generator: " + Format,
-                                             llvm::inconvertibleErrorCode());
-}
-
-// This anchor is used to force the linker to link in the generated object file
-// and thus register the generators.
-extern volatile int YAMLGeneratorAnchorSource;
-static int LLVM_ATTRIBUTE_UNUSED YAMLGeneratorAnchorDest =
-    YAMLGeneratorAnchorSource;
-
-} // namespace doc
-} // namespace clang

clang-tools-extra/clang-doc/Generators.h

@@ -1,41 +0,0 @@
-//===-- Generators.h - ClangDoc Generator ----------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Generator classes for converting declaration information into documentation
-// in a specified format.
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_GENERATOR_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_GENERATOR_H
-
-#include "Representation.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/Registry.h"
-
-namespace clang {
-namespace doc {
-
-// Abstract base class for generators.
-// This is expected to be implemented and exposed via the GeneratorRegistry.
-class Generator {
-public:
-  virtual ~Generator() = default;
-
-  // Write out the decl info in the specified format.
-  virtual bool generateDocForInfo(Info *I, llvm::raw_ostream &OS) = 0;
-};
-
-typedef llvm::Registry<Generator> GeneratorRegistry;
-
-llvm::Expected<std::unique_ptr<Generator>>
-findGeneratorByName(llvm::StringRef Format);
-
-} // namespace doc
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_GENERATOR_H

clang-tools-extra/clang-doc/Mapper.cpp

@@ -1,90 +0,0 @@
-//===-- Mapper.cpp - ClangDoc Mapper ----------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Mapper.h"
-#include "BitcodeWriter.h"
-#include "Serialize.h"
-#include "clang/AST/Comment.h"
-#include "clang/Index/USRGeneration.h"
-#include "llvm/ADT/StringExtras.h"
-
-using clang::comments::FullComment;
-
-namespace clang {
-namespace doc {
-
-void MapASTVisitor::HandleTranslationUnit(ASTContext &Context) {
-  TraverseDecl(Context.getTranslationUnitDecl());
-}
-
-template <typename T> bool MapASTVisitor::mapDecl(const T *D) {
-  // If we're looking a decl not in user files, skip this decl.
-  if (D->getASTContext().getSourceManager().isInSystemHeader(D->getLocation()))
-    return true;
-
-  llvm::SmallString<128> USR;
-  // If there is an error generating a USR for the decl, skip this decl.
-  if (index::generateUSRForDecl(D, USR))
-    return true;
-
-  std::string info = serialize::emitInfo(
-      D, getComment(D, D->getASTContext()), getLine(D, D->getASTContext()),
-      getFile(D, D->getASTContext()), CDCtx.PublicOnly);
-
-  if (info != "")
-    CDCtx.ECtx->reportResult(
-        llvm::toHex(llvm::toStringRef(serialize::hashUSR(USR))), info);
-
-  return true;
-}
-
-bool MapASTVisitor::VisitNamespaceDecl(const NamespaceDecl *D) {
-  return mapDecl(D);
-}
-
-bool MapASTVisitor::VisitRecordDecl(const RecordDecl *D) { return mapDecl(D); }
-
-bool MapASTVisitor::VisitEnumDecl(const EnumDecl *D) { return mapDecl(D); }
-
-bool MapASTVisitor::VisitCXXMethodDecl(const CXXMethodDecl *D) {
-  return mapDecl(D);
-}
-
-bool MapASTVisitor::VisitFunctionDecl(const FunctionDecl *D) {
-  // Don't visit CXXMethodDecls twice
-  if (dyn_cast<CXXMethodDecl>(D))
-    return true;
-  return mapDecl(D);
-}
-
-comments::FullComment *
-MapASTVisitor::getComment(const NamedDecl *D, const ASTContext &Context) const {
-  RawComment *Comment = Context.getRawCommentForDeclNoCache(D);
-  // FIXME: Move setAttached to the initial comment parsing.
-  if (Comment) {
-    Comment->setAttached();
-    return Comment->parse(Context, nullptr, D);
-  }
-  return nullptr;
-}
-
-int MapASTVisitor::getLine(const NamedDecl *D,
-                           const ASTContext &Context) const {
-  return Context.getSourceManager().getPresumedLoc(D->getLocStart()).getLine();
-}
-
-llvm::StringRef MapASTVisitor::getFile(const NamedDecl *D,
-                                       const ASTContext &Context) const {
-  return Context.getSourceManager()
-      .getPresumedLoc(D->getLocStart())
-      .getFilename();
-}
-
-} // namespace doc
-} // namespace clang

clang-tools-extra/clang-doc/Mapper.h

@@ -1,58 +0,0 @@
-//===-- Mapper.h - ClangDoc Mapper ------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the Mapper piece of the clang-doc tool. It implements
-// a RecursiveASTVisitor to look at each declaration and populate the info
-// into the internal representation. Each seen declaration is serialized to
-// to bitcode and written out to the ExecutionContext as a KV pair where the
-// key is the declaration's USR and the value is the serialized bitcode.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_MAPPER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_MAPPER_H
-
-#include "Representation.h"
-#include "clang/AST/RecursiveASTVisitor.h"
-#include "clang/Tooling/Execution.h"
-
-using namespace clang::comments;
-using namespace clang::tooling;
-
-namespace clang {
-namespace doc {
-
-class MapASTVisitor : public clang::RecursiveASTVisitor<MapASTVisitor>,
-                      public ASTConsumer {
-public:
-  explicit MapASTVisitor(ASTContext *Ctx, ClangDocContext CDCtx)
-      : CDCtx(CDCtx) {}
-
-  void HandleTranslationUnit(ASTContext &Context) override;
-  bool VisitNamespaceDecl(const NamespaceDecl *D);
-  bool VisitRecordDecl(const RecordDecl *D);
-  bool VisitEnumDecl(const EnumDecl *D);
-  bool VisitCXXMethodDecl(const CXXMethodDecl *D);
-  bool VisitFunctionDecl(const FunctionDecl *D);
-
-private:
-  template <typename T> bool mapDecl(const T *D);
-
-  int getLine(const NamedDecl *D, const ASTContext &Context) const;
-  StringRef getFile(const NamedDecl *D, const ASTContext &Context) const;
-  comments::FullComment *getComment(const NamedDecl *D,
-                                    const ASTContext &Context) const;
-
-  ClangDocContext CDCtx;
-};
-
-} // namespace doc
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_MAPPER_H

clang-tools-extra/clang-doc/Representation.cpp

@@ -1,131 +0,0 @@
-///===-- Representation.cpp - ClangDoc Representation -----------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the merging of different types of infos. The data in the
-// calling Info is preserved during a merge unless that field is empty or
-// default. In that case, the data from the parameter Info is used to replace
-// the empty or default data.
-//
-// For most fields, the first decl seen provides the data. Exceptions to this
-// include the location and description fields, which are collections of data on
-// all decls related to a given definition. All other fields are ignored in new
-// decls unless the first seen decl didn't, for whatever reason, incorporate
-// data on that field (e.g. a forward declared class wouldn't have information
-// on members on the forward declaration, but would have the class name).
-//
-//===----------------------------------------------------------------------===//
-#include "Representation.h"
-#include "llvm/Support/Error.h"
-
-namespace clang {
-namespace doc {
-
-static const SymbolID EmptySID = SymbolID();
-
-template <typename T>
-std::unique_ptr<Info> reduce(std::vector<std::unique_ptr<Info>> &Values) {
-  std::unique_ptr<Info> Merged = llvm::make_unique<T>();
-  T *Tmp = static_cast<T *>(Merged.get());
-  for (auto &I : Values)
-    Tmp->merge(std::move(*static_cast<T *>(I.get())));
-  return Merged;
-}
-
-// Dispatch function.
-llvm::Expected<std::unique_ptr<Info>>
-mergeInfos(std::vector<std::unique_ptr<Info>> &Values) {
-  if (Values.empty())
-    return llvm::make_error<llvm::StringError>("No info values to merge.\n",
-                                               llvm::inconvertibleErrorCode());
-
-  switch (Values[0]->IT) {
-  case InfoType::IT_namespace:
-    return reduce<NamespaceInfo>(Values);
-  case InfoType::IT_record:
-    return reduce<RecordInfo>(Values);
-  case InfoType::IT_enum:
-    return reduce<EnumInfo>(Values);
-  case InfoType::IT_function:
-    return reduce<FunctionInfo>(Values);
-  default:
-    return llvm::make_error<llvm::StringError>("Unexpected info type.\n",
-                                               llvm::inconvertibleErrorCode());
-  }
-}
-
-void Info::mergeBase(Info &&Other) {
-  assert(mergeable(Other));
-  if (USR == EmptySID)
-    USR = Other.USR;
-  if (Name == "")
-    Name = Other.Name;
-  if (Namespace.empty())
-    Namespace = std::move(Other.Namespace);
-  // Unconditionally extend the description, since each decl may have a comment.
-  std::move(Other.Description.begin(), Other.Description.end(),
-            std::back_inserter(Description));
-}
-
-bool Info::mergeable(const Info &Other) {
-  return IT == Other.IT && (USR == EmptySID || USR == Other.USR);
-}
-
-void SymbolInfo::merge(SymbolInfo &&Other) {
-  assert(mergeable(Other));
-  if (!DefLoc)
-    DefLoc = std::move(Other.DefLoc);
-  // Unconditionally extend the list of locations, since we want all of them.
-  std::move(Other.Loc.begin(), Other.Loc.end(), std::back_inserter(Loc));
-  mergeBase(std::move(Other));
-}
-
-void NamespaceInfo::merge(NamespaceInfo &&Other) {
-  assert(mergeable(Other));
-  mergeBase(std::move(Other));
-}
-
-void RecordInfo::merge(RecordInfo &&Other) {
-  assert(mergeable(Other));
-  if (!TagType)
-    TagType = Other.TagType;
-  if (Members.empty())
-    Members = std::move(Other.Members);
-  if (Parents.empty())
-    Parents = std::move(Other.Parents);
-  if (VirtualParents.empty())
-    VirtualParents = std::move(Other.VirtualParents);
-  SymbolInfo::merge(std::move(Other));
-}
-
-void EnumInfo::merge(EnumInfo &&Other) {
-  assert(mergeable(Other));
-  if (!Scoped)
-    Scoped = Other.Scoped;
-  if (Members.empty())
-    Members = std::move(Other.Members);
-  SymbolInfo::merge(std::move(Other));
-}
-
-void FunctionInfo::merge(FunctionInfo &&Other) {
-  assert(mergeable(Other));
-  if (!IsMethod)
-    IsMethod = Other.IsMethod;
-  if (!Access)
-    Access = Other.Access;
-  if (ReturnType.Type.USR == EmptySID && ReturnType.Type.Name == "")
-    ReturnType = std::move(Other.ReturnType);
-  if (Parent.USR == EmptySID && Parent.Name == "")
-    Parent = std::move(Other.Parent);
-  if (Params.empty())
-    Params = std::move(Other.Params);
-  SymbolInfo::merge(std::move(Other));
-}
-
-} // namespace doc
-} // namespace clang

clang-tools-extra/clang-doc/Representation.h

@@ -1,251 +0,0 @@
-///===-- Representation.h - ClangDoc Representation -------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the internal representations of different declaration
-// types for the clang-doc tool.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_REPRESENTATION_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_REPRESENTATION_H
-
-#include "clang/AST/Type.h"
-#include "clang/Basic/Specifiers.h"
-#include "clang/Tooling/StandaloneExecution.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringExtras.h"
-#include <array>
-#include <string>
-
-namespace clang {
-namespace doc {
-
-// SHA1'd hash of a USR.
-using SymbolID = std::array<uint8_t, 20>;
-
-struct Info;
-enum class InfoType {
-  IT_default,
-  IT_namespace,
-  IT_record,
-  IT_function,
-  IT_enum
-};
-
-// A representation of a parsed comment.
-struct CommentInfo {
-  CommentInfo() = default;
-  CommentInfo(CommentInfo &Other) = delete;
-  CommentInfo(CommentInfo &&Other) = default;
-
-  SmallString<16> Kind; // Kind of comment (TextComment, InlineCommandComment,
-                        // HTMLStartTagComment, HTMLEndTagComment,
-                        // BlockCommandComment, ParamCommandComment,
-                        // TParamCommandComment, VerbatimBlockComment,
-                        // VerbatimBlockLineComment, VerbatimLineComment).
-  SmallString<64> Text; // Text of the comment.
-  SmallString<16> Name; // Name of the comment (for Verbatim and HTML).
-  SmallString<8> Direction;  // Parameter direction (for (T)ParamCommand).
-  SmallString<16> ParamName; // Parameter name (for (T)ParamCommand).
-  SmallString<16> CloseName; // Closing tag name (for VerbatimBlock).
-  bool SelfClosing = false;  // Indicates if tag is self-closing (for HTML).
-  bool Explicit = false; // Indicates if the direction of a param is explicit
-                         // (for (T)ParamCommand).
-  llvm::SmallVector<SmallString<16>, 4>
-      AttrKeys; // List of attribute keys (for HTML).
-  llvm::SmallVector<SmallString<16>, 4>
-      AttrValues; // List of attribute values for each key (for HTML).
-  llvm::SmallVector<SmallString<16>, 4>
-      Args; // List of arguments to commands (for InlineCommand).
-  std::vector<std::unique_ptr<CommentInfo>>
-      Children; // List of child comments for this CommentInfo.
-};
-
-struct Reference {
-  Reference() = default;
-  Reference(llvm::StringRef Name) : Name(Name) {}
-  Reference(SymbolID USR, StringRef Name, InfoType IT)
-      : USR(USR), Name(Name), RefType(IT) {}
-
-  bool operator==(const Reference &Other) const {
-    return std::tie(USR, Name, RefType) ==
-           std::tie(Other.USR, Other.Name, Other.RefType);
-  }
-
-  SymbolID USR = SymbolID(); // Unique identifer for referenced decl
-  SmallString<16> Name;      // Name of type (possibly unresolved).
-  InfoType RefType = InfoType::IT_default; // Indicates the type of this
-                                           // Reference (namespace, record,
-                                           // function, enum, default).
-};
-
-// A base struct for TypeInfos
-struct TypeInfo {
-  TypeInfo() = default;
-  TypeInfo(SymbolID Type, StringRef Field, InfoType IT)
-      : Type(Type, Field, IT) {}
-  TypeInfo(llvm::StringRef RefName) : Type(RefName) {}
-
-  bool operator==(const TypeInfo &Other) const { return Type == Other.Type; }
-
-  Reference Type; // Referenced type in this info.
-};
-
-// Info for field types.
-struct FieldTypeInfo : public TypeInfo {
-  FieldTypeInfo() = default;
-  FieldTypeInfo(SymbolID Type, StringRef Field, InfoType IT,
-                llvm::StringRef Name)
-      : TypeInfo(Type, Field, IT), Name(Name) {}
-  FieldTypeInfo(llvm::StringRef RefName, llvm::StringRef Name)
-      : TypeInfo(RefName), Name(Name) {}
-
-  bool operator==(const FieldTypeInfo &Other) const {
-    return std::tie(Type, Name) == std::tie(Other.Type, Other.Name);
-  }
-
-  SmallString<16> Name; // Name associated with this info.
-};
-
-// Info for member types.
-struct MemberTypeInfo : public FieldTypeInfo {
-  MemberTypeInfo() = default;
-  MemberTypeInfo(SymbolID Type, StringRef Field, InfoType IT,
-                 llvm::StringRef Name, AccessSpecifier Access)
-      : FieldTypeInfo(Type, Field, IT, Name), Access(Access) {}
-  MemberTypeInfo(llvm::StringRef RefName, llvm::StringRef Name,
-                 AccessSpecifier Access)
-      : FieldTypeInfo(RefName, Name), Access(Access) {}
-
-  bool operator==(const MemberTypeInfo &Other) const {
-    return std::tie(Type, Name, Access) ==
-           std::tie(Other.Type, Other.Name, Other.Access);
-  }
-
-  AccessSpecifier Access = AccessSpecifier::AS_none; // Access level associated
-                                                     // with this info (public,
-                                                     // protected, private,
-                                                     // none).
-};
-
-struct Location {
-  Location() = default;
-  Location(int LineNumber, SmallString<16> Filename)
-      : LineNumber(LineNumber), Filename(std::move(Filename)) {}
-
-  bool operator==(const Location &Other) const {
-    return std::tie(LineNumber, Filename) ==
-           std::tie(Other.LineNumber, Other.Filename);
-  }
-
-  int LineNumber;           // Line number of this Location.
-  SmallString<32> Filename; // File for this Location.
-};
-
-/// A base struct for Infos.
-struct Info {
-  Info() = default;
-  Info(InfoType IT) : IT(IT) {}
-  Info(const Info &Other) = delete;
-  Info(Info &&Other) = default;
-
-  SymbolID USR =
-      SymbolID(); // Unique identifier for the decl described by this Info.
-  const InfoType IT = InfoType::IT_default; // InfoType of this particular Info.
-  SmallString<16> Name;                     // Unqualified name of the decl.
-  llvm::SmallVector<Reference, 4>
-      Namespace; // List of parent namespaces for this decl.
-  std::vector<CommentInfo> Description; // Comment description of this decl.
-
-  void mergeBase(Info &&I);
-  bool mergeable(const Info &Other);
-};
-
-// Info for namespaces.
-struct NamespaceInfo : public Info {
-  NamespaceInfo() : Info(InfoType::IT_namespace) {}
-
-  void merge(NamespaceInfo &&I);
-};
-
-// Info for symbols.
-struct SymbolInfo : public Info {
-  SymbolInfo(InfoType IT) : Info(IT) {}
-
-  void merge(SymbolInfo &&I);
-
-  llvm::Optional<Location> DefLoc;    // Location where this decl is defined.
-  llvm::SmallVector<Location, 2> Loc; // Locations where this decl is declared.
-};
-
-// TODO: Expand to allow for documenting templating and default args.
-// Info for functions.
-struct FunctionInfo : public SymbolInfo {
-  FunctionInfo() : SymbolInfo(InfoType::IT_function) {}
-
-  void merge(FunctionInfo &&I);
-
-  bool IsMethod = false; // Indicates whether this function is a class method.
-  Reference Parent;      // Reference to the parent class decl for this method.
-  TypeInfo ReturnType;   // Info about the return type of this function.
-  llvm::SmallVector<FieldTypeInfo, 4> Params; // List of parameters.
-  // Access level for this method (public, private, protected, none).
-  AccessSpecifier Access = AccessSpecifier::AS_none;
-};
-
-// TODO: Expand to allow for documenting templating, inheritance access,
-// friend classes
-// Info for types.
-struct RecordInfo : public SymbolInfo {
-  RecordInfo() : SymbolInfo(InfoType::IT_record) {}
-
-  void merge(RecordInfo &&I);
-
-  TagTypeKind TagType = TagTypeKind::TTK_Struct; // Type of this record
-                                                 // (struct, class, union,
-                                                 // interface).
-  llvm::SmallVector<MemberTypeInfo, 4>
-      Members;                             // List of info about record members.
-  llvm::SmallVector<Reference, 4> Parents; // List of base/parent records
-                                           // (does not include virtual
-                                           // parents).
-  llvm::SmallVector<Reference, 4>
-      VirtualParents; // List of virtual base/parent records.
-};
-
-// TODO: Expand to allow for documenting templating.
-// Info for types.
-struct EnumInfo : public SymbolInfo {
-  EnumInfo() : SymbolInfo(InfoType::IT_enum) {}
-
-  void merge(EnumInfo &&I);
-
-  bool Scoped =
-      false; // Indicates whether this enum is scoped (e.g. enum class).
-  llvm::SmallVector<SmallString<16>, 4> Members; // List of enum members.
-};
-
-// TODO: Add functionality to include separate markdown pages.
-
-// A standalone function to call to merge a vector of infos into one.
-// This assumes that all infos in the vector are of the same type, and will fail
-// if they are different.
-llvm::Expected<std::unique_ptr<Info>>
-mergeInfos(std::vector<std::unique_ptr<Info>> &Values);
-
-struct ClangDocContext {
-  tooling::ExecutionContext *ECtx;
-  bool PublicOnly;
-};
-
-} // namespace doc
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_REPRESENTATION_H

clang-tools-extra/clang-doc/Serialize.cpp

@@ -1,368 +0,0 @@
-//===-- Serializer.cpp - ClangDoc Serializer --------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Serialize.h"
-#include "BitcodeWriter.h"
-#include "clang/AST/Comment.h"
-#include "clang/Index/USRGeneration.h"
-#include "llvm/ADT/Hashing.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/SHA1.h"
-
-using clang::comments::FullComment;
-
-namespace clang {
-namespace doc {
-namespace serialize {
-
-SymbolID hashUSR(llvm::StringRef USR) {
-  return llvm::SHA1::hash(arrayRefFromStringRef(USR));
-}
-
-class ClangDocCommentVisitor
-    : public ConstCommentVisitor<ClangDocCommentVisitor> {
-public:
-  ClangDocCommentVisitor(CommentInfo &CI) : CurrentCI(CI) {}
-
-  void parseComment(const comments::Comment *C);
-
-  void visitTextComment(const TextComment *C);
-  void visitInlineCommandComment(const InlineCommandComment *C);
-  void visitHTMLStartTagComment(const HTMLStartTagComment *C);
-  void visitHTMLEndTagComment(const HTMLEndTagComment *C);
-  void visitBlockCommandComment(const BlockCommandComment *C);
-  void visitParamCommandComment(const ParamCommandComment *C);
-  void visitTParamCommandComment(const TParamCommandComment *C);
-  void visitVerbatimBlockComment(const VerbatimBlockComment *C);
-  void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C);
-  void visitVerbatimLineComment(const VerbatimLineComment *C);
-
-private:
-  std::string getCommandName(unsigned CommandID) const;
-  bool isWhitespaceOnly(StringRef S) const;
-
-  CommentInfo &CurrentCI;
-};
-
-void ClangDocCommentVisitor::parseComment(const comments::Comment *C) {
-  CurrentCI.Kind = C->getCommentKindName();
-  ConstCommentVisitor<ClangDocCommentVisitor>::visit(C);
-  for (comments::Comment *Child :
-       llvm::make_range(C->child_begin(), C->child_end())) {
-    CurrentCI.Children.emplace_back(llvm::make_unique<CommentInfo>());
-    ClangDocCommentVisitor Visitor(*CurrentCI.Children.back());
-    Visitor.parseComment(Child);
-  }
-}
-
-void ClangDocCommentVisitor::visitTextComment(const TextComment *C) {
-  if (!isWhitespaceOnly(C->getText()))
-    CurrentCI.Text = C->getText();
-}
-
-void ClangDocCommentVisitor::visitInlineCommandComment(
-    const InlineCommandComment *C) {
-  CurrentCI.Name = getCommandName(C->getCommandID());
-  for (unsigned I = 0, E = C->getNumArgs(); I != E; ++I)
-    CurrentCI.Args.push_back(C->getArgText(I));
-}
-
-void ClangDocCommentVisitor::visitHTMLStartTagComment(
-    const HTMLStartTagComment *C) {
-  CurrentCI.Name = C->getTagName();
-  CurrentCI.SelfClosing = C->isSelfClosing();
-  for (unsigned I = 0, E = C->getNumAttrs(); I < E; ++I) {
-    const HTMLStartTagComment::Attribute &Attr = C->getAttr(I);
-    CurrentCI.AttrKeys.push_back(Attr.Name);
-    CurrentCI.AttrValues.push_back(Attr.Value);
-  }
-}
-
-void ClangDocCommentVisitor::visitHTMLEndTagComment(
-    const HTMLEndTagComment *C) {
-  CurrentCI.Name = C->getTagName();
-  CurrentCI.SelfClosing = true;
-}
-
-void ClangDocCommentVisitor::visitBlockCommandComment(
-    const BlockCommandComment *C) {
-  CurrentCI.Name = getCommandName(C->getCommandID());
-  for (unsigned I = 0, E = C->getNumArgs(); I < E; ++I)
-    CurrentCI.Args.push_back(C->getArgText(I));
-}
-
-void ClangDocCommentVisitor::visitParamCommandComment(
-    const ParamCommandComment *C) {
-  CurrentCI.Direction =
-      ParamCommandComment::getDirectionAsString(C->getDirection());
-  CurrentCI.Explicit = C->isDirectionExplicit();
-  if (C->hasParamName())
-    CurrentCI.ParamName = C->getParamNameAsWritten();
-}
-
-void ClangDocCommentVisitor::visitTParamCommandComment(
-    const TParamCommandComment *C) {
-  if (C->hasParamName())
-    CurrentCI.ParamName = C->getParamNameAsWritten();
-}
-
-void ClangDocCommentVisitor::visitVerbatimBlockComment(
-    const VerbatimBlockComment *C) {
-  CurrentCI.Name = getCommandName(C->getCommandID());
-  CurrentCI.CloseName = C->getCloseName();
-}
-
-void ClangDocCommentVisitor::visitVerbatimBlockLineComment(
-    const VerbatimBlockLineComment *C) {
-  if (!isWhitespaceOnly(C->getText()))
-    CurrentCI.Text = C->getText();
-}
-
-void ClangDocCommentVisitor::visitVerbatimLineComment(
-    const VerbatimLineComment *C) {
-  if (!isWhitespaceOnly(C->getText()))
-    CurrentCI.Text = C->getText();
-}
-
-bool ClangDocCommentVisitor::isWhitespaceOnly(llvm::StringRef S) const {
-  return std::all_of(S.begin(), S.end(), isspace);
-}
-
-std::string ClangDocCommentVisitor::getCommandName(unsigned CommandID) const {
-  const CommandInfo *Info = CommandTraits::getBuiltinCommandInfo(CommandID);
-  if (Info)
-    return Info->Name;
-  // TODO: Add parsing for \file command.
-  return "<not a builtin command>";
-}
-
-// Serializing functions.
-
-template <typename T> static std::string serialize(T &I) {
-  SmallString<2048> Buffer;
-  llvm::BitstreamWriter Stream(Buffer);
-  ClangDocBitcodeWriter Writer(Stream);
-  Writer.emitBlock(I);
-  return Buffer.str().str();
-}
-
-static void parseFullComment(const FullComment *C, CommentInfo &CI) {
-  ClangDocCommentVisitor Visitor(CI);
-  Visitor.parseComment(C);
-}
-
-static SymbolID getUSRForDecl(const Decl *D) {
-  llvm::SmallString<128> USR;
-  if (index::generateUSRForDecl(D, USR))
-    return SymbolID();
-  return hashUSR(USR);
-}
-
-static RecordDecl *getDeclForType(const QualType &T) {
-  auto *Ty = T->getAs<RecordType>();
-  if (!Ty)
-    return nullptr;
-  return Ty->getDecl()->getDefinition();
-}
-
-static bool isPublic(const clang::AccessSpecifier AS,
-                     const clang::Linkage Link) {
-  if (AS == clang::AccessSpecifier::AS_private)
-    return false;
-  else if ((Link == clang::Linkage::ModuleLinkage) ||
-           (Link == clang::Linkage::ExternalLinkage))
-    return true;
-  return false; // otherwise, linkage is some form of internal linkage
-}
-
-static void parseFields(RecordInfo &I, const RecordDecl *D, bool PublicOnly) {
-  for (const FieldDecl *F : D->fields()) {
-    if (PublicOnly && !isPublic(F->getAccessUnsafe(), F->getLinkageInternal()))
-      continue;
-    if (const auto *T = getDeclForType(F->getTypeSourceInfo()->getType())) {
-      // Use getAccessUnsafe so that we just get the default AS_none if it's not
-      // valid, as opposed to an assert.
-      if (const auto *N = dyn_cast<EnumDecl>(T)) {
-        I.Members.emplace_back(getUSRForDecl(T), N->getNameAsString(),
-                               InfoType::IT_enum, F->getNameAsString(),
-                               N->getAccessUnsafe());
-        continue;
-      } else if (const auto *N = dyn_cast<RecordDecl>(T)) {
-        I.Members.emplace_back(getUSRForDecl(T), N->getNameAsString(),
-                               InfoType::IT_record, F->getNameAsString(),
-                               N->getAccessUnsafe());
-        continue;
-      }
-    }
-    I.Members.emplace_back(F->getTypeSourceInfo()->getType().getAsString(),
-                           F->getNameAsString(), F->getAccessUnsafe());
-  }
-}
-
-static void parseEnumerators(EnumInfo &I, const EnumDecl *D) {
-  for (const EnumConstantDecl *E : D->enumerators())
-    I.Members.emplace_back(E->getNameAsString());
-}
-
-static void parseParameters(FunctionInfo &I, const FunctionDecl *D) {
-  for (const ParmVarDecl *P : D->parameters()) {
-    if (const auto *T = getDeclForType(P->getOriginalType())) {
-      if (const auto *N = dyn_cast<EnumDecl>(T)) {
-        I.Params.emplace_back(getUSRForDecl(N), N->getNameAsString(),
-                              InfoType::IT_enum, P->getNameAsString());
-        continue;
-      } else if (const auto *N = dyn_cast<RecordDecl>(T)) {
-        I.Params.emplace_back(getUSRForDecl(N), N->getNameAsString(),
-                              InfoType::IT_record, P->getNameAsString());
-        continue;
-      }
-    }
-    I.Params.emplace_back(P->getOriginalType().getAsString(),
-                          P->getNameAsString());
-  }
-}
-
-static void parseBases(RecordInfo &I, const CXXRecordDecl *D) {
-  for (const CXXBaseSpecifier &B : D->bases()) {
-    if (B.isVirtual())
-      continue;
-    if (const auto *P = getDeclForType(B.getType()))
-      I.Parents.emplace_back(getUSRForDecl(P), P->getNameAsString(),
-                             InfoType::IT_record);
-    else
-      I.Parents.emplace_back(B.getType().getAsString());
-  }
-  for (const CXXBaseSpecifier &B : D->vbases()) {
-    if (const auto *P = getDeclForType(B.getType()))
-      I.VirtualParents.emplace_back(getUSRForDecl(P), P->getNameAsString(),
-                                    InfoType::IT_record);
-    else
-      I.VirtualParents.emplace_back(B.getType().getAsString());
-  }
-}
-
-template <typename T>
-static void
-populateParentNamespaces(llvm::SmallVector<Reference, 4> &Namespaces,
-                         const T *D) {
-  const auto *DC = dyn_cast<DeclContext>(D);
-  while ((DC = DC->getParent())) {
-    if (const auto *N = dyn_cast<NamespaceDecl>(DC))
-      Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
-                              InfoType::IT_namespace);
-    else if (const auto *N = dyn_cast<RecordDecl>(DC))
-      Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
-                              InfoType::IT_record);
-    else if (const auto *N = dyn_cast<FunctionDecl>(DC))
-      Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
-                              InfoType::IT_function);
-    else if (const auto *N = dyn_cast<EnumDecl>(DC))
-      Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
-                              InfoType::IT_enum);
-  }
-}
-
-template <typename T>
-static void populateInfo(Info &I, const T *D, const FullComment *C) {
-  I.USR = getUSRForDecl(D);
-  I.Name = D->getNameAsString();
-  populateParentNamespaces(I.Namespace, D);
-  if (C) {
-    I.Description.emplace_back();
-    parseFullComment(C, I.Description.back());
-  }
-}
-
-template <typename T>
-static void populateSymbolInfo(SymbolInfo &I, const T *D, const FullComment *C,
-                               int LineNumber, StringRef Filename) {
-  populateInfo(I, D, C);
-  if (D->isThisDeclarationADefinition())
-    I.DefLoc.emplace(LineNumber, Filename);
-  else
-    I.Loc.emplace_back(LineNumber, Filename);
-}
-
-static void populateFunctionInfo(FunctionInfo &I, const FunctionDecl *D,
-                                 const FullComment *FC, int LineNumber,
-                                 StringRef Filename) {
-  populateSymbolInfo(I, D, FC, LineNumber, Filename);
-  if (const auto *T = getDeclForType(D->getReturnType())) {
-    if (dyn_cast<EnumDecl>(T))
-      I.ReturnType =
-          TypeInfo(getUSRForDecl(T), T->getNameAsString(), InfoType::IT_enum);
-    else if (dyn_cast<RecordDecl>(T))
-      I.ReturnType =
-          TypeInfo(getUSRForDecl(T), T->getNameAsString(), InfoType::IT_record);
-  } else {
-    I.ReturnType = TypeInfo(D->getReturnType().getAsString());
-  }
-  parseParameters(I, D);
-}
-
-std::string emitInfo(const NamespaceDecl *D, const FullComment *FC,
-                     int LineNumber, llvm::StringRef File, bool PublicOnly) {
-  if (PublicOnly && ((D->isAnonymousNamespace()) ||
-                     !isPublic(D->getAccess(), D->getLinkageInternal())))
-    return "";
-  NamespaceInfo I;
-  populateInfo(I, D, FC);
-  return serialize(I);
-}
-
-std::string emitInfo(const RecordDecl *D, const FullComment *FC, int LineNumber,
-                     llvm::StringRef File, bool PublicOnly) {
-  if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
-    return "";
-  RecordInfo I;
-  populateSymbolInfo(I, D, FC, LineNumber, File);
-  I.TagType = D->getTagKind();
-  parseFields(I, D, PublicOnly);
-  if (const auto *C = dyn_cast<CXXRecordDecl>(D))
-    parseBases(I, C);
-  return serialize(I);
-}
-
-std::string emitInfo(const FunctionDecl *D, const FullComment *FC,
-                     int LineNumber, llvm::StringRef File, bool PublicOnly) {
-  if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
-    return "";
-  FunctionInfo I;
-  populateFunctionInfo(I, D, FC, LineNumber, File);
-  I.Access = clang::AccessSpecifier::AS_none;
-  return serialize(I);
-}
-
-std::string emitInfo(const CXXMethodDecl *D, const FullComment *FC,
-                     int LineNumber, llvm::StringRef File, bool PublicOnly) {
-  if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
-    return "";
-  FunctionInfo I;
-  populateFunctionInfo(I, D, FC, LineNumber, File);
-  I.IsMethod = true;
-  I.Parent = Reference{getUSRForDecl(D->getParent()),
-                       D->getParent()->getNameAsString(), InfoType::IT_record};
-  I.Access = D->getAccess();
-  return serialize(I);
-}
-
-std::string emitInfo(const EnumDecl *D, const FullComment *FC, int LineNumber,
-                     llvm::StringRef File, bool PublicOnly) {
-  if (PublicOnly && !isPublic(D->getAccess(), D->getLinkageInternal()))
-    return "";
-  EnumInfo I;
-  populateSymbolInfo(I, D, FC, LineNumber, File);
-  I.Scoped = D->isScoped();
-  parseEnumerators(I, D);
-  return serialize(I);
-}
-
-} // namespace serialize
-} // namespace doc
-} // namespace clang

clang-tools-extra/clang-doc/Serialize.h

@@ -1,53 +0,0 @@
-//===-- Serializer.h - ClangDoc Serializer ----------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the serializing functions fro the clang-doc tool. Given
-// a particular declaration, it collects the appropriate information and returns
-// a serialized bitcode string for the declaration.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_SERIALIZE_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_SERIALIZE_H
-
-#include "Representation.h"
-#include "clang/AST/AST.h"
-#include "clang/AST/CommentVisitor.h"
-#include <string>
-#include <vector>
-
-using namespace clang::comments;
-
-namespace clang {
-namespace doc {
-namespace serialize {
-
-std::string emitInfo(const NamespaceDecl *D, const FullComment *FC,
-                     int LineNumber, StringRef File, bool PublicOnly);
-std::string emitInfo(const RecordDecl *D, const FullComment *FC, int LineNumber,
-                     StringRef File, bool PublicOnly);
-std::string emitInfo(const EnumDecl *D, const FullComment *FC, int LineNumber,
-                     StringRef File, bool PublicOnly);
-std::string emitInfo(const FunctionDecl *D, const FullComment *FC,
-                     int LineNumber, StringRef File, bool PublicOnly);
-std::string emitInfo(const CXXMethodDecl *D, const FullComment *FC,
-                     int LineNumber, StringRef File, bool PublicOnly);
-
-// Function to hash a given USR value for storage.
-// As USRs (Unified Symbol Resolution) could be large, especially for functions
-// with long type arguments, we use 160-bits SHA1(USR) values to
-// guarantee the uniqueness of symbols while using a relatively small amount of
-// memory (vs storing USRs directly).
-SymbolID hashUSR(llvm::StringRef USR);
-
-} // namespace serialize
-} // namespace doc
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_DOC_SERIALIZE_H

clang-tools-extra/clang-doc/YAMLGenerator.cpp

@@ -1,268 +0,0 @@
-//===--  ClangDocYAML.cpp - ClangDoc YAML -----------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// Implementation of the YAML generator, converting decl info into YAML output.
-//===----------------------------------------------------------------------===//
-
-#include "Generators.h"
-#include "llvm/Support/YAMLTraits.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace clang::doc;
-
-LLVM_YAML_IS_SEQUENCE_VECTOR(FieldTypeInfo)
-LLVM_YAML_IS_SEQUENCE_VECTOR(MemberTypeInfo)
-LLVM_YAML_IS_SEQUENCE_VECTOR(Reference)
-LLVM_YAML_IS_SEQUENCE_VECTOR(Location)
-LLVM_YAML_IS_SEQUENCE_VECTOR(CommentInfo)
-LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<CommentInfo>)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::SmallString<16>)
-
-namespace llvm {
-namespace yaml {
-
-// Enumerations to YAML output.
-
-template <> struct ScalarEnumerationTraits<clang::AccessSpecifier> {
-  static void enumeration(IO &IO, clang::AccessSpecifier &Value) {
-    IO.enumCase(Value, "Public", clang::AccessSpecifier::AS_public);
-    IO.enumCase(Value, "Protected", clang::AccessSpecifier::AS_protected);
-    IO.enumCase(Value, "Private", clang::AccessSpecifier::AS_private);
-    IO.enumCase(Value, "None", clang::AccessSpecifier::AS_none);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<clang::TagTypeKind> {
-  static void enumeration(IO &IO, clang::TagTypeKind &Value) {
-    IO.enumCase(Value, "Struct", clang::TagTypeKind::TTK_Struct);
-    IO.enumCase(Value, "Interface", clang::TagTypeKind::TTK_Interface);
-    IO.enumCase(Value, "Union", clang::TagTypeKind::TTK_Union);
-    IO.enumCase(Value, "Class", clang::TagTypeKind::TTK_Class);
-    IO.enumCase(Value, "Enum", clang::TagTypeKind::TTK_Enum);
-  }
-};
-
-template <> struct ScalarEnumerationTraits<InfoType> {
-  static void enumeration(IO &IO, InfoType &Value) {
-    IO.enumCase(Value, "Namespace", InfoType::IT_namespace);
-    IO.enumCase(Value, "Record", InfoType::IT_record);
-    IO.enumCase(Value, "Function", InfoType::IT_function);
-    IO.enumCase(Value, "Enum", InfoType::IT_enum);
-    IO.enumCase(Value, "Default", InfoType::IT_default);
-  }
-};
-
-// Scalars to YAML output.
-template <unsigned U> struct ScalarTraits<SmallString<U>> {
-
-  static void output(const SmallString<U> &S, void *, llvm::raw_ostream &OS) {
-    for (const auto &C : S)
-      OS << C;
-  }
-
-  static StringRef input(StringRef Scalar, void *, SmallString<U> &Value) {
-    Value.assign(Scalar.begin(), Scalar.end());
-    return StringRef();
-  }
-
-  static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
-};
-
-template <> struct ScalarTraits<std::array<unsigned char, 20>> {
-
-  static void output(const std::array<unsigned char, 20> &S, void *,
-                     llvm::raw_ostream &OS) {
-    OS << toHex(toStringRef(S));
-  }
-
-  static StringRef input(StringRef Scalar, void *,
-                         std::array<unsigned char, 20> &Value) {
-    if (Scalar.size() != 40)
-      return "Error: Incorrect scalar size for USR.";
-    Value = StringToSymbol(Scalar);
-    return StringRef();
-  }
-
-  static SymbolID StringToSymbol(llvm::StringRef Value) {
-    SymbolID USR;
-    std::string HexString = fromHex(Value);
-    std::copy(HexString.begin(), HexString.end(), USR.begin());
-    return SymbolID(USR);
-  }
-
-  static QuotingType mustQuote(StringRef) { return QuotingType::Single; }
-};
-
-// Helper functions to map infos to YAML.
-
-static void TypeInfoMapping(IO &IO, TypeInfo &I) {
-  IO.mapOptional("Type", I.Type, Reference());
-}
-
-static void FieldTypeInfoMapping(IO &IO, FieldTypeInfo &I) {
-  TypeInfoMapping(IO, I);
-  IO.mapOptional("Name", I.Name, SmallString<16>());
-}
-
-static void InfoMapping(IO &IO, Info &I) {
-  IO.mapRequired("USR", I.USR);
-  IO.mapOptional("Name", I.Name, SmallString<16>());
-  IO.mapOptional("Namespace", I.Namespace, llvm::SmallVector<Reference, 4>());
-  IO.mapOptional("Description", I.Description);
-}
-
-static void SymbolInfoMapping(IO &IO, SymbolInfo &I) {
-  InfoMapping(IO, I);
-  IO.mapOptional("DefLocation", I.DefLoc, Optional<Location>());
-  IO.mapOptional("Location", I.Loc, llvm::SmallVector<Location, 2>());
-}
-
-static void CommentInfoMapping(IO &IO, CommentInfo &I) {
-  IO.mapOptional("Kind", I.Kind, SmallString<16>());
-  IO.mapOptional("Text", I.Text, SmallString<64>());
-  IO.mapOptional("Name", I.Name, SmallString<16>());
-  IO.mapOptional("Direction", I.Direction, SmallString<8>());
-  IO.mapOptional("ParamName", I.ParamName, SmallString<16>());
-  IO.mapOptional("CloseName", I.CloseName, SmallString<16>());
-  IO.mapOptional("SelfClosing", I.SelfClosing, false);
-  IO.mapOptional("Explicit", I.Explicit, false);
-  IO.mapOptional("Args", I.Args, llvm::SmallVector<SmallString<16>, 4>());
-  IO.mapOptional("AttrKeys", I.AttrKeys,
-                 llvm::SmallVector<SmallString<16>, 4>());
-  IO.mapOptional("AttrValues", I.AttrValues,
-                 llvm::SmallVector<SmallString<16>, 4>());
-  IO.mapOptional("Children", I.Children);
-}
-
-// Template specialization to YAML traits for Infos.
-
-template <> struct MappingTraits<Location> {
-  static void mapping(IO &IO, Location &Loc) {
-    IO.mapOptional("LineNumber", Loc.LineNumber, 0);
-    IO.mapOptional("Filename", Loc.Filename, SmallString<32>());
-  }
-};
-
-template <> struct MappingTraits<Reference> {
-  static void mapping(IO &IO, Reference &Ref) {
-    IO.mapOptional("Type", Ref.RefType, InfoType::IT_default);
-    IO.mapOptional("Name", Ref.Name, SmallString<16>());
-    IO.mapOptional("USR", Ref.USR, SymbolID());
-  }
-};
-
-template <> struct MappingTraits<TypeInfo> {
-  static void mapping(IO &IO, TypeInfo &I) { TypeInfoMapping(IO, I); }
-};
-
-template <> struct MappingTraits<FieldTypeInfo> {
-  static void mapping(IO &IO, FieldTypeInfo &I) {
-    TypeInfoMapping(IO, I);
-    IO.mapOptional("Name", I.Name, SmallString<16>());
-  }
-};
-
-template <> struct MappingTraits<MemberTypeInfo> {
-  static void mapping(IO &IO, MemberTypeInfo &I) {
-    FieldTypeInfoMapping(IO, I);
-    IO.mapOptional("Access", I.Access, clang::AccessSpecifier::AS_none);
-  }
-};
-
-template <> struct MappingTraits<NamespaceInfo> {
-  static void mapping(IO &IO, NamespaceInfo &I) { InfoMapping(IO, I); }
-};
-
-template <> struct MappingTraits<RecordInfo> {
-  static void mapping(IO &IO, RecordInfo &I) {
-    SymbolInfoMapping(IO, I);
-    IO.mapOptional("TagType", I.TagType, clang::TagTypeKind::TTK_Struct);
-    IO.mapOptional("Members", I.Members);
-    IO.mapOptional("Parents", I.Parents, llvm::SmallVector<Reference, 4>());
-    IO.mapOptional("VirtualParents", I.VirtualParents,
-                   llvm::SmallVector<Reference, 4>());
-  }
-};
-
-template <> struct MappingTraits<EnumInfo> {
-  static void mapping(IO &IO, EnumInfo &I) {
-    SymbolInfoMapping(IO, I);
-    IO.mapOptional("Scoped", I.Scoped, false);
-    IO.mapOptional("Members", I.Members);
-  }
-};
-
-template <> struct MappingTraits<FunctionInfo> {
-  static void mapping(IO &IO, FunctionInfo &I) {
-    SymbolInfoMapping(IO, I);
-    IO.mapOptional("IsMethod", I.IsMethod, false);
-    IO.mapOptional("Parent", I.Parent, Reference());
-    IO.mapOptional("Params", I.Params);
-    IO.mapOptional("ReturnType", I.ReturnType);
-    IO.mapOptional("Access", I.Access, clang::AccessSpecifier::AS_none);
-  }
-};
-
-template <> struct MappingTraits<CommentInfo> {
-  static void mapping(IO &IO, CommentInfo &I) { CommentInfoMapping(IO, I); }
-};
-
-template <> struct MappingTraits<std::unique_ptr<CommentInfo>> {
-  static void mapping(IO &IO, std::unique_ptr<CommentInfo> &I) {
-    if (I)
-      CommentInfoMapping(IO, *I);
-  }
-};
-
-} // end namespace yaml
-} // end namespace llvm
-
-namespace clang {
-namespace doc {
-
-/// Generator for YAML documentation.
-class YAMLGenerator : public Generator {
-public:
-  static const char *Format;
-
-  bool generateDocForInfo(Info *I, llvm::raw_ostream &OS) override;
-};
-
-const char *YAMLGenerator::Format = "yaml";
-
-bool YAMLGenerator::generateDocForInfo(Info *I, llvm::raw_ostream &OS) {
-  llvm::yaml::Output InfoYAML(OS);
-  switch (I->IT) {
-  case InfoType::IT_namespace:
-    InfoYAML << *static_cast<clang::doc::NamespaceInfo *>(I);
-    break;
-  case InfoType::IT_record:
-    InfoYAML << *static_cast<clang::doc::RecordInfo *>(I);
-    break;
-  case InfoType::IT_enum:
-    InfoYAML << *static_cast<clang::doc::EnumInfo *>(I);
-    break;
-  case InfoType::IT_function:
-    InfoYAML << *static_cast<clang::doc::FunctionInfo *>(I);
-    break;
-  case InfoType::IT_default:
-    llvm::errs() << "Unexpected info type in index.\n";
-    return true;
-  }
-  return false;
-}
-
-static GeneratorRegistry::Add<YAMLGenerator> YAML(YAMLGenerator::Format,
-                                                  "Generator for YAML output.");
-
-// This anchor is used to force the linker to link in the generated object file
-// and thus register the generator.
-volatile int YAMLGeneratorAnchorSource = 0;
-
-} // namespace doc
-} // namespace clang

clang-tools-extra/clang-doc/gen_tests.py

@@ -1,200 +0,0 @@
-#!/usr/bin/env python3
-#
-#===- gen_tests.py - clang-doc test generator ----------------*- python -*--===#
-#
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-#===------------------------------------------------------------------------===#
-"""
-clang-doc test generator
-==========================
-
-Generates tests for clang-doc given a certain set of flags, a prefix for the
-test file, and a given clang-doc binary. Please check emitted tests for
-accuracy before using.
-
-To generate all current tests:
-- Generate mapper tests:
-    gen_tests.py -flag='--dump-mapper' -flag='--doxygen' -prefix mapper
-
-- Generate reducer tests:
-    gen_tests.py -flag='--dump-intermediate' -flag='--doxygen' -prefix bc
-    
-- Generate yaml tests:
-    gen_tests.py -flag='--format=yaml' -flag='--doxygen' -prefix yaml
-    
-This script was written on/for Linux, and has not been tested on any other
-platform and so it may not work.
-
-"""
-
-import argparse
-import glob
-import os
-import shutil
-import subprocess
-
-RUN_CLANG_DOC = """
-// RUN: clang-doc {0} -p %t %t/test.cpp -output=%t/docs
-"""
-RUN = """
-// RUN: {0} %t/{1} | FileCheck %s --check-prefix CHECK-{2}
-"""
-
-CHECK = '// CHECK-{0}: '
-
-CHECK_NEXT = '// CHECK-{0}-NEXT: '
-
-
-def clear_test_prefix_files(prefix, tests_path):
-    if os.path.isdir(tests_path):
-        for root, dirs, files in os.walk(tests_path):
-            for filename in files:
-                if filename.startswith(prefix):
-                    os.remove(os.path.join(root, filename))
-
-
-def copy_to_test_file(test_case_path, test_cases_path):
-    # Copy file to 'test.cpp' to preserve file-dependent USRs
-    test_file = os.path.join(test_cases_path, 'test.cpp')
-    shutil.copyfile(test_case_path, test_file)
-    return test_file
-
-
-def run_clang_doc(args, out_dir, test_file):
-    # Run clang-doc.
-    current_cmd = [args.clangdoc]
-    current_cmd.extend(args.flags)
-    current_cmd.append('--output=' + out_dir)
-    current_cmd.append(test_file)
-    print('Running ' + ' '.join(current_cmd))
-    return_code = subprocess.call(current_cmd)
-    if return_code:
-        return 1
-    return 0
-
-
-def get_test_case_code(test_case_path, flags):
-    # Get the test case code
-    code = ''
-    with open(test_case_path, 'r') as code_file:
-        code = code_file.read()
-
-    code += RUN_CLANG_DOC.format(flags)
-    return code
-
-
-def get_output(root, out_file, case_out_path, flags, checkname, bcanalyzer):
-    output = ''
-    run_cmd = ''
-    if '--dump-mapper' in flags or '--dump-intermediate' in flags:
-        # Run llvm-bcanalyzer
-        output = subprocess.check_output(
-            [bcanalyzer, '--dump',
-             os.path.join(root, out_file)])
-        output = output[:output.find('Summary of ')].rstrip()
-        run_cmd = RUN.format('llvm-bcanalyzer --dump',
-                             os.path.join('docs', 'bc', out_file), checkname)
-    else:
-        # Run cat
-        output = subprocess.check_output(['cat', os.path.join(root, out_file)])
-        run_cmd = RUN.format(
-            'cat',
-            os.path.join('docs', os.path.relpath(root, case_out_path),
-                         out_file), checkname)
-
-    # Format output.
-    output = output.replace('blob data = \'test\'', 'blob data = \'{{.*}}\'')
-    output = CHECK.format(checkname) + output.rstrip()
-    output = run_cmd + output.replace('\n',
-                                      '\n' + CHECK_NEXT.format(checkname))
-
-    return output + '\n'
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Generate clang-doc tests.')
-    parser.add_argument(
-        '-flag',
-        action='append',
-        default=[],
-        dest='flags',
-        help='Flags to pass to clang-doc.')
-    parser.add_argument(
-        '-prefix',
-        type=str,
-        default='',
-        dest='prefix',
-        help='Prefix for this test group.')
-    parser.add_argument(
-        '-clang-doc-binary',
-        dest='clangdoc',
-        metavar="PATH",
-        default='clang-doc',
-        help='path to clang-doc binary')
-    parser.add_argument(
-        '-llvm-bcanalyzer-binary',
-        dest='bcanalyzer',
-        metavar="PATH",
-        default='llvm-bcanalyzer',
-        help='path to llvm-bcanalyzer binary')
-    args = parser.parse_args()
-
-    flags = ' '.join(args.flags)
-
-    clang_doc_path = os.path.dirname(__file__)
-    tests_path = os.path.join(clang_doc_path, '..', 'test', 'clang-doc')
-    test_cases_path = os.path.join(tests_path, 'test_cases')
-
-    clear_test_prefix_files(args.prefix, tests_path)
-
-    for test_case_path in glob.glob(os.path.join(test_cases_path, '*')):
-        if test_case_path.endswith(
-                'compile_flags.txt') or test_case_path.endswith(
-                    'compile_commands.json'):
-            continue
-
-        # Name of this test case
-        case_name = os.path.basename(test_case_path).split('.')[0]
-
-        test_file = copy_to_test_file(test_case_path, test_cases_path)
-        out_dir = os.path.join(test_cases_path, case_name)
-
-        if run_clang_doc(args, out_dir, test_file):
-            return 1
-
-        # Retrieve output and format as FileCheck tests
-        all_output = ''
-        num_outputs = 0
-        for root, dirs, files in os.walk(out_dir):
-            for out_file in files:
-                # Make the file check the first 3 letters (there's a very small chance
-                # that this will collide, but the fix is to simply change the decl name)
-                usr = os.path.basename(out_file).split('.')
-                # If the usr is less than 2, this isn't one of the test files.
-                if len(usr) < 2:
-                    continue
-                all_output += get_output(root, out_file, out_dir, args.flags,
-                                         num_outputs, args.bcanalyzer)
-                num_outputs += 1
-
-        # Add test case code to test
-        all_output = get_test_case_code(test_case_path,
-                                        flags) + '\n' + all_output
-
-        # Write to test case file in /test.
-        test_out_path = os.path.join(
-            tests_path, args.prefix + '-' + os.path.basename(test_case_path))
-        with open(test_out_path, 'w+') as o:
-            o.write(all_output)
-
-        # Clean up
-        shutil.rmtree(out_dir)
-        os.remove(test_file)
-
-
-if __name__ == '__main__':
-    main()

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

@@ -1,17 +0,0 @@
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
-
-add_clang_executable(clang-doc
-  ClangDocMain.cpp
-  )
-
-target_link_libraries(clang-doc
-  PRIVATE
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangFrontend
-  clangDoc
-  clangTooling
-  clangToolingCore
-  )
-  

clang-tools-extra/clang-doc/tool/ClangDocMain.cpp

@@ -1,253 +0,0 @@
-//===-- ClangDocMain.cpp - ClangDoc -----------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This tool for generating C and C++ documenation from source code
-// and comments. Generally, it runs a LibTooling FrontendAction on source files,
-// mapping each declaration in those files to its USR and serializing relevant
-// information into LLVM bitcode. It then runs a pass over the collected
-// declaration information, reducing by USR. There is an option to dump this
-// intermediate result to bitcode. Finally, it hands the reduced information
-// off to a generator, which does the final parsing from the intermediate
-// representation to the desired output format.
-//
-//===----------------------------------------------------------------------===//
-
-#include "BitcodeReader.h"
-#include "BitcodeWriter.h"
-#include "ClangDoc.h"
-#include "Generators.h"
-#include "Representation.h"
-#include "clang/AST/AST.h"
-#include "clang/AST/Decl.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchersInternal.h"
-#include "clang/Driver/Options.h"
-#include "clang/Frontend/FrontendActions.h"
-#include "clang/Tooling/CommonOptionsParser.h"
-#include "clang/Tooling/Execution.h"
-#include "clang/Tooling/StandaloneExecution.h"
-#include "clang/Tooling/Tooling.h"
-#include "llvm/ADT/APFloat.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/Process.h"
-#include "llvm/Support/Signals.h"
-#include "llvm/Support/raw_ostream.h"
-#include <string>
-
-using namespace clang::ast_matchers;
-using namespace clang::tooling;
-using namespace clang;
-
-static llvm::cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
-static llvm::cl::OptionCategory ClangDocCategory("clang-doc options");
-
-static llvm::cl::opt<std::string>
-    OutDirectory("output",
-                 llvm::cl::desc("Directory for outputting generated files."),
-                 llvm::cl::init("docs"), llvm::cl::cat(ClangDocCategory));
-
-static llvm::cl::opt<bool>
-    DumpMapperResult("dump-mapper",
-                     llvm::cl::desc("Dump mapper results to bitcode file."),
-                     llvm::cl::init(false), llvm::cl::cat(ClangDocCategory));
-
-static llvm::cl::opt<bool> DumpIntermediateResult(
-    "dump-intermediate",
-    llvm::cl::desc("Dump intermediate results to bitcode file."),
-    llvm::cl::init(false), llvm::cl::cat(ClangDocCategory));
-
-static llvm::cl::opt<bool>
-    PublicOnly("public", llvm::cl::desc("Document only public declarations."),
-               llvm::cl::init(false), llvm::cl::cat(ClangDocCategory));
-
-enum OutputFormatTy {
-  yaml,
-};
-
-static llvm::cl::opt<OutputFormatTy> FormatEnum(
-    "format", llvm::cl::desc("Format for outputted docs."),
-    llvm::cl::values(clEnumVal(yaml, "Documentation in YAML format.")),
-    llvm::cl::init(yaml), llvm::cl::cat(ClangDocCategory));
-
-static llvm::cl::opt<bool> DoxygenOnly(
-    "doxygen",
-    llvm::cl::desc("Use only doxygen-style comments to generate docs."),
-    llvm::cl::init(false), llvm::cl::cat(ClangDocCategory));
-
-bool CreateDirectory(const Twine &DirName, bool ClearDirectory = false) {
-  std::error_code OK;
-  llvm::SmallString<128> DocsRootPath;
-  if (ClearDirectory) {
-    std::error_code RemoveStatus = llvm::sys::fs::remove_directories(DirName);
-    if (RemoveStatus != OK) {
-      llvm::errs() << "Unable to remove existing documentation directory for "
-                   << DirName << ".\n";
-      return true;
-    }
-  }
-  std::error_code DirectoryStatus = llvm::sys::fs::create_directories(DirName);
-  if (DirectoryStatus != OK) {
-    llvm::errs() << "Unable to create documentation directories.\n";
-    return true;
-  }
-  return false;
-}
-
-bool DumpResultToFile(const Twine &DirName, const Twine &FileName,
-                      StringRef Buffer, bool ClearDirectory = false) {
-  std::error_code OK;
-  llvm::SmallString<128> IRRootPath;
-  llvm::sys::path::native(OutDirectory, IRRootPath);
-  llvm::sys::path::append(IRRootPath, DirName);
-  if (CreateDirectory(IRRootPath, ClearDirectory))
-    return true;
-  llvm::sys::path::append(IRRootPath, FileName);
-  std::error_code OutErrorInfo;
-  llvm::raw_fd_ostream OS(IRRootPath, OutErrorInfo, llvm::sys::fs::F_None);
-  if (OutErrorInfo != OK) {
-    llvm::errs() << "Error opening documentation file.\n";
-    return true;
-  }
-  OS << Buffer;
-  OS.close();
-  return false;
-}
-
-llvm::Expected<llvm::SmallString<128>>
-getPath(StringRef Root, StringRef Ext, StringRef Name,
-        llvm::SmallVectorImpl<doc::Reference> &Namespaces) {
-  std::error_code OK;
-  llvm::SmallString<128> Path;
-  llvm::sys::path::native(Root, Path);
-  for (auto R = Namespaces.rbegin(), E = Namespaces.rend(); R != E; ++R)
-    llvm::sys::path::append(Path, R->Name);
-
-  if (CreateDirectory(Path))
-    return llvm::make_error<llvm::StringError>("Unable to create directory.\n",
-                                               llvm::inconvertibleErrorCode());
-
-  llvm::sys::path::append(Path, Name + Ext);
-  return Path;
-}
-
-std::string getFormatString(OutputFormatTy Ty) {
-  switch (Ty) {
-  case yaml:
-    return "yaml";
-  }
-  llvm_unreachable("Unknown OutputFormatTy");
-}
-
-int main(int argc, const char **argv) {
-  llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
-  std::error_code OK;
-
-  // Fail early if an invalid format was provided.
-  std::string Format = getFormatString(FormatEnum);
-  auto G = doc::findGeneratorByName(Format);
-  if (!G) {
-    llvm::errs() << toString(G.takeError()) << "\n";
-    return 1;
-  }
-
-  auto Exec = clang::tooling::createExecutorFromCommandLineArgs(
-      argc, argv, ClangDocCategory);
-
-  if (!Exec) {
-    llvm::errs() << toString(Exec.takeError()) << "\n";
-    return 1;
-  }
-
-  ArgumentsAdjuster ArgAdjuster;
-  if (!DoxygenOnly)
-    ArgAdjuster = combineAdjusters(
-        getInsertArgumentAdjuster("-fparse-all-comments",
-                                  tooling::ArgumentInsertPosition::END),
-        ArgAdjuster);
-
-  // Mapping phase
-  llvm::outs() << "Mapping decls...\n";
-  clang::doc::ClangDocContext CDCtx = {Exec->get()->getExecutionContext(),
-                                       PublicOnly};
-  auto Err =
-      Exec->get()->execute(doc::newMapperActionFactory(CDCtx), ArgAdjuster);
-  if (Err) {
-    llvm::errs() << toString(std::move(Err)) << "\n";
-    return 1;
-  }
-
-  if (DumpMapperResult) {
-    bool Err = false;
-    Exec->get()->getToolResults()->forEachResult(
-        [&](StringRef Key, StringRef Value) {
-          Err = DumpResultToFile("bc", Key + ".bc", Value);
-        });
-    if (Err)
-      llvm::errs() << "Error dumping map results.\n";
-    return Err;
-  }
-
-  // Collect values into output by key.
-  llvm::outs() << "Collecting infos...\n";
-  llvm::StringMap<std::vector<std::unique_ptr<doc::Info>>> MapOutput;
-
-  // In ToolResults, the Key is the hashed USR and the value is the
-  // bitcode-encoded representation of the Info object.
-  Exec->get()->getToolResults()->forEachResult([&](StringRef Key,
-                                                   StringRef Value) {
-    llvm::BitstreamCursor Stream(Value);
-    doc::ClangDocBitcodeReader Reader(Stream);
-    auto Infos = Reader.readBitcode();
-    for (auto &I : Infos) {
-      auto R =
-          MapOutput.try_emplace(Key, std::vector<std::unique_ptr<doc::Info>>());
-      R.first->second.emplace_back(std::move(I));
-    }
-  });
-
-  // Reducing and generation phases
-  llvm::outs() << "Reducing " << MapOutput.size() << " infos...\n";
-  llvm::StringMap<std::unique_ptr<doc::Info>> ReduceOutput;
-  for (auto &Group : MapOutput) {
-    auto Reduced = doc::mergeInfos(Group.getValue());
-    if (!Reduced)
-      llvm::errs() << llvm::toString(Reduced.takeError());
-
-    if (DumpIntermediateResult) {
-      SmallString<4096> Buffer;
-      llvm::BitstreamWriter Stream(Buffer);
-      doc::ClangDocBitcodeWriter Writer(Stream);
-      Writer.dispatchInfoForWrite(Reduced.get().get());
-      if (DumpResultToFile("bc", Group.getKey() + ".bc", Buffer))
-        llvm::errs() << "Error dumping to bitcode.\n";
-      continue;
-    }
-
-    // Create the relevant ostream and emit the documentation for this decl.
-    doc::Info *I = Reduced.get().get();
-    auto InfoPath = getPath(OutDirectory, "." + Format, I->Name, I->Namespace);
-    if (!InfoPath) {
-      llvm::errs() << toString(InfoPath.takeError()) << "\n";
-      continue;
-    }
-    std::error_code FileErr;
-    llvm::raw_fd_ostream InfoOS(InfoPath.get(), FileErr, llvm::sys::fs::F_None);
-    if (FileErr != OK) {
-      llvm::errs() << "Error opening index file: " << FileErr.message() << "\n";
-      continue;
-    }
-
-    if (G->get()->generateDocForInfo(I, InfoOS))
-      llvm::errs() << "Unable to generate docs for info.\n";
-  }
-
-  return 0;
-}

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

@@ -61,14 +61,6 @@ AST_MATCHER_P(CXXMethodDecl, ofOutermostEnclosingClass,
   return InnerMatcher.matches(*Parent, Finder, Builder);
 }
 
-std::string CleanPath(StringRef PathRef) {
-  llvm::SmallString<128> Path(PathRef);
-  llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
-  // FIXME: figure out why this is necessary.
-  llvm::sys::path::native(Path);
-  return Path.str();
-}
-
 // Make the Path absolute using the CurrentDir if the Path is not an absolute
 // path. An empty Path will result in an empty string.
 std::string MakeAbsolutePath(StringRef CurrentDir, StringRef Path) {
@@ -80,7 +72,9 @@ std::string MakeAbsolutePath(StringRef CurrentDir, StringRef Path) {
           llvm::sys::fs::make_absolute(InitialDirectory, AbsolutePath))
     llvm::errs() << "Warning: could not make absolute file: '" << EC.message()
                  << '\n';
-  return CleanPath(std::move(AbsolutePath));
+  llvm::sys::path::remove_dots(AbsolutePath, /*remove_dot_dot=*/true);
+  llvm::sys::path::native(AbsolutePath);
+  return AbsolutePath.str();
 }
 
 // Make the Path absolute using the current working directory of the given
@@ -101,15 +95,13 @@ std::string MakeAbsolutePath(const SourceManager &SM, StringRef Path) {
       llvm::sys::path::parent_path(AbsolutePath.str()));
   if (Dir) {
     StringRef DirName = SM.getFileManager().getCanonicalName(Dir);
-    // FIXME: getCanonicalName might fail to get real path on VFS.
-    if (llvm::sys::path::is_absolute(DirName)) {
-      SmallString<128> AbsoluteFilename;
-      llvm::sys::path::append(AbsoluteFilename, DirName,
-                              llvm::sys::path::filename(AbsolutePath.str()));
-      return CleanPath(AbsoluteFilename);
-    }
+    SmallVector<char, 128> AbsoluteFilename;
+    llvm::sys::path::append(AbsoluteFilename, DirName,
+                            llvm::sys::path::filename(AbsolutePath.str()));
+    return llvm::StringRef(AbsoluteFilename.data(), AbsoluteFilename.size())
+        .str();
   }
-  return CleanPath(AbsolutePath);
+  return AbsolutePath.str();
 }
 
 // Matches AST nodes that are expanded within the given AbsoluteFilePath.
@@ -139,8 +131,7 @@ public:
                           clang::CharSourceRange FilenameRange,
                           const clang::FileEntry * /*File*/,
                           StringRef SearchPath, StringRef /*RelativePath*/,
-                          const clang::Module * /*Imported*/,
-                          SrcMgr::CharacteristicKind /*FileType*/) override {
+                          const clang::Module * /*Imported*/) override {
     if (const auto *FileEntry = SM.getFileEntryForID(SM.getFileID(HashLoc)))
       MoveTool->addIncludes(FileName, IsAngled, SearchPath,
                             FileEntry->getName(), FilenameRange, SM);
@@ -289,10 +280,7 @@ SourceLocation
 getLocForEndOfDecl(const clang::Decl *D,
                    const LangOptions &LangOpts = clang::LangOptions()) {
   const auto &SM = D->getASTContext().getSourceManager();
-  // If the expansion range is a character range, this is the location of
-  // the first character past the end. Otherwise it's the location of the
-  // first character in the final token in the range.
-  auto EndExpansionLoc = SM.getExpansionRange(D->getLocEnd()).getEnd();
+  auto EndExpansionLoc = SM.getExpansionLoc(D->getLocEnd());
   std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(EndExpansionLoc);
   // Try to load the file buffer.
   bool InvalidTemp = false;
@@ -535,7 +523,6 @@ void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
   auto AllDeclsInHeader = namedDecl(
       unless(ForwardClassDecls), unless(namespaceDecl()),
       unless(usingDirectiveDecl()), // using namespace decl.
-      notInMacro(),
       InOldHeader,
       hasParent(decl(anyOf(namespaceDecl(), translationUnitDecl()))),
       hasDeclContext(decl(anyOf(namespaceDecl(), translationUnitDecl()))));
@@ -688,8 +675,8 @@ void ClangMoveTool::run(const ast_matchers::MatchFinder::MatchResult &Result) {
                  Result.Nodes.getNodeAs<clang::NamedDecl>("helper_decls")) {
     MovedDecls.push_back(ND);
     HelperDeclarations.push_back(ND);
-    LLVM_DEBUG(llvm::dbgs() << "Add helper : " << ND->getNameAsString() << " ("
-                            << ND << ")\n");
+    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);
@@ -707,28 +694,22 @@ void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
                                 const SourceManager &SM) {
   SmallVector<char, 128> HeaderWithSearchPath;
   llvm::sys::path::append(HeaderWithSearchPath, SearchPath, IncludeHeader);
-  std::string AbsoluteIncludeHeader =
+  std::string AbsoluteOldHeader = makeAbsolutePath(Context->Spec.OldHeader);
+  if (AbsoluteOldHeader ==
       MakeAbsolutePath(SM, llvm::StringRef(HeaderWithSearchPath.data(),
-                                           HeaderWithSearchPath.size()));
+                                           HeaderWithSearchPath.size()))) {
+    OldHeaderIncludeRange = IncludeFilenameRange;
+    return;
+  }
+
   std::string IncludeLine =
       IsAngled ? ("#include <" + IncludeHeader + ">\n").str()
                : ("#include \"" + IncludeHeader + "\"\n").str();
 
-  std::string AbsoluteOldHeader = makeAbsolutePath(Context->Spec.OldHeader);
   std::string AbsoluteCurrentFile = MakeAbsolutePath(SM, FileName);
   if (AbsoluteOldHeader == AbsoluteCurrentFile) {
-    // Find old.h includes "old.h".
-    if (AbsoluteOldHeader == AbsoluteIncludeHeader) {
-      OldHeaderIncludeRangeInHeader = IncludeFilenameRange;
-      return;
-    }
     HeaderIncludes.push_back(IncludeLine);
   } else if (makeAbsolutePath(Context->Spec.OldCC) == AbsoluteCurrentFile) {
-    // Find old.cc includes "old.h".
-    if (AbsoluteOldHeader == AbsoluteIncludeHeader) {
-      OldHeaderIncludeRangeInCC = IncludeFilenameRange;
-      return;
-    }
     CCIncludes.push_back(IncludeLine);
   }
 }
@@ -749,12 +730,12 @@ 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) {
-      LLVM_DEBUG(llvm::dbgs() << "Check helper is used: "
-                              << D->getNameAsString() << " (" << D << ")\n");
+      DEBUG(llvm::dbgs() << "Check helper is used: "
+                         << D->getNameAsString() << " (" << D << ")\n");
       if (!UsedDecls.count(HelperDeclRGBuilder::getOutmostClassOrFunDecl(
               D->getCanonicalDecl()))) {
-        LLVM_DEBUG(llvm::dbgs() << "Helper removed in old.cc: "
-                                << D->getNameAsString() << " (" << D << ")\n");
+        DEBUG(llvm::dbgs() << "Helper removed in old.cc: "
+                           << D->getNameAsString() << " (" << D << ")\n");
         RemovedDecls.push_back(D);
       }
     }
@@ -834,8 +815,8 @@ void ClangMoveTool::moveDeclsToNewFiles() {
             D->getCanonicalDecl())))
       continue;
 
-    LLVM_DEBUG(llvm::dbgs() << "Helper used in new.cc: " << D->getNameAsString()
-                            << " " << D << "\n");
+    DEBUG(llvm::dbgs() << "Helper used in new.cc: " << D->getNameAsString()
+                       << " " << D << "\n");
     ActualNewCCDecls.push_back(D);
   }
 
@@ -876,18 +857,13 @@ void ClangMoveTool::moveAll(SourceManager &SM, StringRef OldFile,
   if (!NewFile.empty()) {
     auto AllCode = clang::tooling::Replacements(
         clang::tooling::Replacement(NewFile, 0, 0, Code));
-    auto ReplaceOldInclude = [&](clang::CharSourceRange OldHeaderIncludeRange) {
-      AllCode = AllCode.merge(clang::tooling::Replacements(
-          clang::tooling::Replacement(SM, OldHeaderIncludeRange,
-                                      '"' + Context->Spec.NewHeader + '"')));
-    };
-    // Fix the case where old.h/old.cc includes "old.h", we replace the
-    // `#include "old.h"` with `#include "new.h"`.
-    if (Context->Spec.NewCC == NewFile && OldHeaderIncludeRangeInCC.isValid())
-      ReplaceOldInclude(OldHeaderIncludeRangeInCC);
-    else if (Context->Spec.NewHeader == NewFile &&
-             OldHeaderIncludeRangeInHeader.isValid())
-      ReplaceOldInclude(OldHeaderIncludeRangeInHeader);
+    // If we are moving from old.cc, an extra step is required: excluding
+    // the #include of "old.h", instead, we replace it with #include of "new.h".
+    if (Context->Spec.NewCC == NewFile && OldHeaderIncludeRange.isValid()) {
+      AllCode = AllCode.merge(
+          clang::tooling::Replacements(clang::tooling::Replacement(
+              SM, OldHeaderIncludeRange, '"' + Context->Spec.NewHeader + '"')));
+    }
     Context->FileToReplacements[NewFile] = std::move(AllCode);
   }
 }
@@ -918,9 +894,10 @@ void ClangMoveTool::onEndOfTranslationUnit() {
 
   if (RemovedDecls.empty())
     return;
-  // Ignore symbols that are not supported when checking if there is unremoved
-  // symbol in old header. This makes sure that we always move old files to new
-  // files when all symbols produced from dump_decls are moved.
+  // Ignore symbols that are not supported (e.g. typedef and enum) when
+  // checking if there is unremoved symbol in old header. This makes sure that
+  // we always move old files to new files when all symbols produced from
+  // dump_decls are moved.
   auto IsSupportedKind = [](const clang::NamedDecl *Decl) {
     switch (Decl->getKind()) {
     case Decl::Kind::Function:
@@ -945,7 +922,7 @@ void ClangMoveTool::onEndOfTranslationUnit() {
     moveAll(SM, Context->Spec.OldCC, Context->Spec.NewCC);
     return;
   }
-  LLVM_DEBUG(RGBuilder.getGraph()->dump());
+  DEBUG(RGBuilder.getGraph()->dump());
   moveDeclsToNewFiles();
   removeDeclsInOldFiles();
 }

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

@@ -176,11 +176,7 @@ private:
   /// The source range for the written file name in #include (i.e. "old.h" for
   /// #include "old.h") in old.cc,  including the enclosing quotes or angle
   /// brackets.
-  clang::CharSourceRange OldHeaderIncludeRangeInCC;
-  /// The source range for the written file name in #include (i.e. "old.h" for
-  /// #include "old.h") in old.h,  including the enclosing quotes or angle
-  /// brackets.
-  clang::CharSourceRange OldHeaderIncludeRangeInHeader;
+  clang::CharSourceRange OldHeaderIncludeRange;
   /// Mapping from FilePath to FileID, which can be used in post processes like
   /// cleanup around replacements.
   llvm::StringMap<FileID> FilePathToFileID;

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

@@ -116,9 +116,9 @@ void HelperDeclRGBuilder::run(
   if (const auto *FuncRef = Result.Nodes.getNodeAs<DeclRefExpr>("func_ref")) {
     const auto *DC = Result.Nodes.getNodeAs<Decl>("dc");
     assert(DC);
-    LLVM_DEBUG(llvm::dbgs() << "Find helper function usage: "
-                            << FuncRef->getDecl()->getNameAsString() << " ("
-                            << FuncRef->getDecl() << ")\n");
+    DEBUG(llvm::dbgs() << "Find helper function usage: "
+                       << FuncRef->getDecl()->getNameAsString() << " ("
+                       << FuncRef->getDecl() << ")\n");
     RG->addEdge(
         getOutmostClassOrFunDecl(DC->getCanonicalDecl()),
         getOutmostClassOrFunDecl(FuncRef->getDecl()->getCanonicalDecl()));
@@ -126,9 +126,9 @@ void HelperDeclRGBuilder::run(
                  Result.Nodes.getNodeAs<CXXRecordDecl>("used_class")) {
     const auto *DC = Result.Nodes.getNodeAs<Decl>("dc");
     assert(DC);
-    LLVM_DEBUG(llvm::dbgs()
-               << "Find helper class usage: " << UsedClass->getNameAsString()
-               << " (" << UsedClass << ")\n");
+    DEBUG(llvm::dbgs() << "Find helper class usage: "
+                       << UsedClass->getNameAsString() << " (" << UsedClass
+                       << ")\n");
     RG->addEdge(getOutmostClassOrFunDecl(DC->getCanonicalDecl()), UsedClass);
   }
 }

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

@@ -30,8 +30,8 @@ namespace {
 
 std::error_code CreateNewFile(const llvm::Twine &path) {
   int fd = 0;
-  if (std::error_code ec = llvm::sys::fs::openFileForWrite(
-          path, fd, llvm::sys::fs::CD_CreateAlways, llvm::sys::fs::F_Text))
+  if (std::error_code ec =
+          llvm::sys::fs::openFileForWrite(path, fd, llvm::sys::fs::F_Text))
     return ec;
 
   return llvm::sys::Process::SafelyCloseFileDescriptor(fd);

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

@@ -50,35 +50,25 @@ StringRef QueryParser::lexWord() {
 // This is the StringSwitch-alike used by lexOrCompleteWord below. See that
 // function for details.
 template <typename T> struct QueryParser::LexOrCompleteWord {
-  StringRef Word;
   StringSwitch<T> Switch;
 
   QueryParser *P;
+  StringRef Word;
   // Set to the completion point offset in Word, or StringRef::npos if
   // completion point not in Word.
   size_t WordCompletionPos;
 
-  // Lexes a word and stores it in Word. Returns a LexOrCompleteWord<T> object
-  // that can be used like a llvm::StringSwitch<T>, but adds cases as possible
-  // completions if the lexed word contains the completion point.
-  LexOrCompleteWord(QueryParser *P, StringRef &OutWord)
-      : Word(P->lexWord()), Switch(Word), P(P),
-        WordCompletionPos(StringRef::npos) {
-    OutWord = Word;
-    if (P->CompletionPos && P->CompletionPos <= Word.data() + Word.size()) {
-      if (P->CompletionPos < Word.data())
-        WordCompletionPos = 0;
-      else
-        WordCompletionPos = P->CompletionPos - Word.data();
-    }
-  }
+  LexOrCompleteWord(QueryParser *P, StringRef Word, size_t WCP)
+      : Switch(Word), P(P), Word(Word), WordCompletionPos(WCP) {}
 
-  LexOrCompleteWord &Case(llvm::StringLiteral CaseStr, const T &Value,
+  template <unsigned N>
+  LexOrCompleteWord &Case(const char (&S)[N], const T &Value,
                           bool IsCompletion = true) {
+    StringRef CaseStr(S, N - 1);
 
     if (WordCompletionPos == StringRef::npos)
-      Switch.Case(CaseStr, Value);
-    else if (CaseStr.size() != 0 && IsCompletion && WordCompletionPos <= CaseStr.size() &&
+      Switch.Case(S, Value);
+    else if (N != 1 && IsCompletion && WordCompletionPos <= CaseStr.size() &&
              CaseStr.substr(0, WordCompletionPos) ==
                  Word.substr(0, WordCompletionPos))
       P->Completions.push_back(LineEditor::Completion(
@@ -86,12 +76,29 @@ template <typename T> struct QueryParser::LexOrCompleteWord {
     return *this;
   }
 
-  T Default(T Value) { return Switch.Default(Value); }
+  T Default(const T &Value) const { return Switch.Default(Value); }
 };
 
+// Lexes a word and stores it in Word. Returns a LexOrCompleteWord<T> object
+// that can be used like a llvm::StringSwitch<T>, but adds cases as possible
+// completions if the lexed word contains the completion point.
+template <typename T>
+QueryParser::LexOrCompleteWord<T>
+QueryParser::lexOrCompleteWord(StringRef &Word) {
+  Word = lexWord();
+  size_t WordCompletionPos = StringRef::npos;
+  if (CompletionPos && CompletionPos <= Word.data() + Word.size()) {
+    if (CompletionPos < Word.data())
+      WordCompletionPos = 0;
+    else
+      WordCompletionPos = CompletionPos - Word.data();
+  }
+  return LexOrCompleteWord<T>(this, Word, WordCompletionPos);
+}
+
 QueryRef QueryParser::parseSetBool(bool QuerySession::*Var) {
   StringRef ValStr;
-  unsigned Value = LexOrCompleteWord<unsigned>(this, ValStr)
+  unsigned Value = lexOrCompleteWord<unsigned>(ValStr)
                        .Case("false", 0)
                        .Case("true", 1)
                        .Default(~0u);
@@ -103,7 +110,7 @@ QueryRef QueryParser::parseSetBool(bool QuerySession::*Var) {
 
 QueryRef QueryParser::parseSetOutputKind() {
   StringRef ValStr;
-  unsigned OutKind = LexOrCompleteWord<unsigned>(this, ValStr)
+  unsigned OutKind = lexOrCompleteWord<unsigned>(ValStr)
                          .Case("diag", OK_Diag)
                          .Case("print", OK_Print)
                          .Case("dump", OK_Dump)
@@ -159,7 +166,7 @@ QueryRef QueryParser::completeMatcherExpression() {
 
 QueryRef QueryParser::doParse() {
   StringRef CommandStr;
-  ParsedQueryKind QKind = LexOrCompleteWord<ParsedQueryKind>(this, CommandStr)
+  ParsedQueryKind QKind = lexOrCompleteWord<ParsedQueryKind>(CommandStr)
                               .Case("", PQK_NoOp)
                               .Case("help", PQK_Help)
                               .Case("m", PQK_Match, /*IsCompletion=*/false)
@@ -214,8 +221,7 @@ QueryRef QueryParser::doParse() {
 
   case PQK_Set: {
     StringRef VarStr;
-    ParsedQueryVariable Var = LexOrCompleteWord<ParsedQueryVariable>(this,
-                                                                     VarStr)
+    ParsedQueryVariable Var = lexOrCompleteWord<ParsedQueryVariable>(VarStr)
                                   .Case("output", PQV_Output)
                                   .Case("bind-root", PQV_BindRoot)
                                   .Default(PQV_Invalid);

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

@@ -42,6 +42,7 @@ private:
   StringRef lexWord();
 
   template <typename T> struct LexOrCompleteWord;
+  template <typename T> LexOrCompleteWord<T> lexOrCompleteWord(StringRef &Str);
 
   QueryRef parseSetBool(bool QuerySession::*Var);
   QueryRef parseSetOutputKind();

clang-tools-extra/clang-tidy-vs/ClangTidy/Resources/ClangTidyChecks.yaml

@@ -114,6 +114,10 @@ Checks:
     Label:       Find implementation-specific integral types
     Description: 
     Name:        google-runtime-int
+  - Category:    Google Style Guide
+    Label:       Find const string references
+    Description: 
+    Name:        google-runtime-member-string-references
   - Category:    Google Style Guide
     Label:       Find zero-length memsets
     Description: 

clang-tools-extra/clang-tidy-vs/ClangTidy/license.txt

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

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

@@ -7,7 +7,6 @@ add_clang_library(clangTidy
   ClangTidyModule.cpp
   ClangTidyDiagnosticConsumer.cpp
   ClangTidyOptions.cpp
-  ClangTidyProfiling.cpp
 
   DEPENDS
   ClangSACheckers
@@ -28,7 +27,6 @@ add_clang_library(clangTidy
   )
 
 add_subdirectory(android)
-add_subdirectory(abseil)
 add_subdirectory(boost)
 add_subdirectory(bugprone)
 add_subdirectory(cert)
@@ -43,8 +41,6 @@ add_subdirectory(mpi)
 add_subdirectory(objc)
 add_subdirectory(performance)
 add_subdirectory(plugin)
-add_subdirectory(portability)
 add_subdirectory(readability)
 add_subdirectory(tool)
 add_subdirectory(utils)
-add_subdirectory(zircon)

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

@@ -18,7 +18,6 @@
 #include "ClangTidy.h"
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyModuleRegistry.h"
-#include "ClangTidyProfiling.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
@@ -90,9 +89,8 @@ private:
 
 class ErrorReporter {
 public:
-  ErrorReporter(ClangTidyContext &Context, bool ApplyFixes,
-                llvm::IntrusiveRefCntPtr<vfs::FileSystem> BaseFS)
-      : Files(FileSystemOptions(), BaseFS), DiagOpts(new DiagnosticOptions()),
+  ErrorReporter(ClangTidyContext &Context, bool ApplyFixes)
+      : Files(FileSystemOptions()), DiagOpts(new DiagnosticOptions()),
         DiagPrinter(new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts)),
         Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts,
               DiagPrinter),
@@ -268,17 +266,12 @@ private:
 class ClangTidyASTConsumer : public MultiplexConsumer {
 public:
   ClangTidyASTConsumer(std::vector<std::unique_ptr<ASTConsumer>> Consumers,
-                       std::unique_ptr<ClangTidyProfiling> Profiling,
                        std::unique_ptr<ast_matchers::MatchFinder> Finder,
                        std::vector<std::unique_ptr<ClangTidyCheck>> Checks)
-      : MultiplexConsumer(std::move(Consumers)),
-        Profiling(std::move(Profiling)), Finder(std::move(Finder)),
+      : MultiplexConsumer(std::move(Consumers)), Finder(std::move(Finder)),
         Checks(std::move(Checks)) {}
 
 private:
-  // Destructor order matters! Profiling must be destructed last.
-  // Or at least after Finder.
-  std::unique_ptr<ClangTidyProfiling> Profiling;
   std::unique_ptr<ast_matchers::MatchFinder> Finder;
   std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
 };
@@ -309,12 +302,11 @@ static void setStaticAnalyzerCheckerOpts(const ClangTidyOptions &Opts,
 
 typedef std::vector<std::pair<std::string, bool>> CheckersList;
 
-static CheckersList getCheckersControlList(ClangTidyContext &Context,
-                                           bool IncludeExperimental) {
+static CheckersList getCheckersControlList(ClangTidyContext &Context) {
   CheckersList List;
 
   const auto &RegisteredCheckers =
-      AnalyzerOptions::getRegisteredCheckers(IncludeExperimental);
+      AnalyzerOptions::getRegisteredCheckers(/*IncludeExperimental=*/false);
   bool AnalyzerChecksEnabled = false;
   for (StringRef CheckName : RegisteredCheckers) {
     std::string ClangTidyCheckName((AnalyzerCheckNamePrefix + CheckName).str());
@@ -360,13 +352,8 @@ ClangTidyASTConsumerFactory::CreateASTConsumer(
   CheckFactories->createChecks(&Context, Checks);
 
   ast_matchers::MatchFinder::MatchFinderOptions FinderOptions;
-
-  std::unique_ptr<ClangTidyProfiling> Profiling;
-  if (Context.getEnableProfiling()) {
-    Profiling = llvm::make_unique<ClangTidyProfiling>(
-        Context.getProfileStorageParams());
-    FinderOptions.CheckProfiling.emplace(Profiling->Records);
-  }
+  if (auto *P = Context.getCheckProfileData())
+    FinderOptions.CheckProfiling.emplace(P->Records);
 
   std::unique_ptr<ast_matchers::MatchFinder> Finder(
       new ast_matchers::MatchFinder(std::move(FinderOptions)));
@@ -381,8 +368,12 @@ ClangTidyASTConsumerFactory::CreateASTConsumer(
     Consumers.push_back(Finder->newASTConsumer());
 
   AnalyzerOptionsRef AnalyzerOptions = Compiler.getAnalyzerOpts();
-  AnalyzerOptions->CheckersControlList =
-      getCheckersControlList(Context, Context.canEnableAnalyzerAlphaCheckers());
+  // FIXME: Remove this option once clang's cfg-temporary-dtors option defaults
+  // to true.
+  AnalyzerOptions->Config["cfg-temporary-dtors"] =
+      Context.getOptions().AnalyzeTemporaryDtors ? "true" : "false";
+
+  AnalyzerOptions->CheckersControlList = getCheckersControlList(Context);
   if (!AnalyzerOptions->CheckersControlList.empty()) {
     setStaticAnalyzerCheckerOpts(Context.getOptions(), AnalyzerOptions);
     AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
@@ -396,8 +387,7 @@ ClangTidyASTConsumerFactory::CreateASTConsumer(
     Consumers.push_back(std::move(AnalysisConsumer));
   }
   return llvm::make_unique<ClangTidyASTConsumer>(
-      std::move(Consumers), std::move(Profiling), std::move(Finder),
-      std::move(Checks));
+      std::move(Consumers), std::move(Finder), std::move(Checks));
 }
 
 std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
@@ -407,8 +397,7 @@ std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
       CheckNames.push_back(CheckFactory.first);
   }
 
-  for (const auto &AnalyzerCheck : getCheckersControlList(
-           Context, Context.canEnableAnalyzerAlphaCheckers()))
+  for (const auto &AnalyzerCheck : getCheckersControlList(Context))
     CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);
 
   std::sort(CheckNames.begin(), CheckNames.end());
@@ -467,35 +456,26 @@ void OptionsView::store(ClangTidyOptions::OptionMap &Options,
   store(Options, LocalName, llvm::itostr(Value));
 }
 
-std::vector<std::string>
-getCheckNames(const ClangTidyOptions &Options,
-              bool AllowEnablingAnalyzerAlphaCheckers) {
+std::vector<std::string> getCheckNames(const ClangTidyOptions &Options) {
   clang::tidy::ClangTidyContext Context(
       llvm::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
-                                                Options),
-      AllowEnablingAnalyzerAlphaCheckers);
+                                                Options));
   ClangTidyASTConsumerFactory Factory(Context);
   return Factory.getCheckNames();
 }
 
-ClangTidyOptions::OptionMap
-getCheckOptions(const ClangTidyOptions &Options,
-                bool AllowEnablingAnalyzerAlphaCheckers) {
+ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options) {
   clang::tidy::ClangTidyContext Context(
       llvm::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
-                                                Options),
-      AllowEnablingAnalyzerAlphaCheckers);
+                                                Options));
   ClangTidyASTConsumerFactory Factory(Context);
   return Factory.getCheckOptions();
 }
 
 void runClangTidy(clang::tidy::ClangTidyContext &Context,
                   const CompilationDatabase &Compilations,
-                  ArrayRef<std::string> InputFiles,
-                  llvm::IntrusiveRefCntPtr<vfs::FileSystem> BaseFS,
-                  bool EnableCheckProfile, llvm::StringRef StoreCheckProfile) {
-  ClangTool Tool(Compilations, InputFiles,
-                 std::make_shared<PCHContainerOperations>(), BaseFS);
+                  ArrayRef<std::string> InputFiles, ProfileData *Profile) {
+  ClangTool Tool(Compilations, InputFiles);
 
   // Add extra arguments passed by the clang-tidy command-line.
   ArgumentsAdjuster PerFileExtraArgumentsInserter =
@@ -533,8 +513,8 @@ void runClangTidy(clang::tidy::ClangTidyContext &Context,
 
   Tool.appendArgumentsAdjuster(PerFileExtraArgumentsInserter);
   Tool.appendArgumentsAdjuster(PluginArgumentsRemover);
-  Context.setEnableProfiling(EnableCheckProfile);
-  Context.setProfileStoragePrefix(StoreCheckProfile);
+  if (Profile)
+    Context.setCheckProfileData(Profile);
 
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
 
@@ -545,18 +525,6 @@ void runClangTidy(clang::tidy::ClangTidyContext &Context,
     ActionFactory(ClangTidyContext &Context) : ConsumerFactory(Context) {}
     FrontendAction *create() override { return new Action(&ConsumerFactory); }
 
-    bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation,
-                       FileManager *Files,
-                       std::shared_ptr<PCHContainerOperations> PCHContainerOps,
-                       DiagnosticConsumer *DiagConsumer) override {
-      // Explicitly set ProgramAction to RunAnalysis to make the preprocessor
-      // define __clang_analyzer__ macro. The frontend analyzer action will not
-      // be called here.
-      Invocation->getFrontendOpts().ProgramAction = frontend::RunAnalysis;
-      return FrontendActionFactory::runInvocation(
-          Invocation, Files, PCHContainerOps, DiagConsumer);
-    }
-
   private:
     class Action : public ASTFrontendAction {
     public:
@@ -578,9 +546,8 @@ void runClangTidy(clang::tidy::ClangTidyContext &Context,
 }
 
 void handleErrors(ClangTidyContext &Context, bool Fix,
-                  unsigned &WarningsAsErrorsCount,
-                  llvm::IntrusiveRefCntPtr<vfs::FileSystem> BaseFS) {
-  ErrorReporter Reporter(Context, Fix, BaseFS);
+                  unsigned &WarningsAsErrorsCount) {
+  ErrorReporter Reporter(Context, Fix);
   vfs::FileSystem &FileSystem =
       *Reporter.getSourceManager().getFileManager().getVirtualFileSystem();
   auto InitialWorkingDir = FileSystem.getCurrentWorkingDirectory();

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

@@ -210,8 +210,7 @@ private:
 
 /// \brief Fills the list of check names that are enabled when the provided
 /// filters are applied.
-std::vector<std::string> getCheckNames(const ClangTidyOptions &Options,
-                                       bool AllowEnablingAnalyzerAlphaCheckers);
+std::vector<std::string> getCheckNames(const ClangTidyOptions &Options);
 
 /// \brief Returns the effective check-specific options.
 ///
@@ -219,23 +218,16 @@ std::vector<std::string> getCheckNames(const ClangTidyOptions &Options,
 /// effective options from all created checks. The returned set of options
 /// includes default check-specific options for all keys not overridden by \p
 /// Options.
-ClangTidyOptions::OptionMap
-getCheckOptions(const ClangTidyOptions &Options,
-                bool AllowEnablingAnalyzerAlphaCheckers);
+ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options);
 
 /// \brief Run a set of clang-tidy checks on a set of files.
 ///
-/// \param EnableCheckProfile If provided, it enables check profile collection
-/// in MatchFinder, and will contain the result of the profile.
-/// \param StoreCheckProfile If provided, and EnableCheckProfile is true,
-/// the profile will not be output to stderr, but will instead be stored
-/// as a JSON file in the specified directory.
+/// \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,
-                  llvm::IntrusiveRefCntPtr<vfs::FileSystem> BaseFS,
-                  bool EnableCheckProfile = false,
-                  llvm::StringRef StoreCheckProfile = StringRef());
+                  ProfileData *Profile = nullptr);
 
 // FIXME: This interface will need to be significantly extended to be useful.
 // FIXME: Implement confidence levels for displaying/fixing errors.
@@ -244,8 +236,7 @@ void runClangTidy(clang::tidy::ClangTidyContext &Context,
 /// 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,
-                  llvm::IntrusiveRefCntPtr<vfs::FileSystem> BaseFS);
+                  unsigned &WarningsAsErrorsCount);
 
 /// \brief Serializes replacements into YAML and writes them to the specified
 /// output stream.

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

@@ -177,11 +177,9 @@ private:
 };
 
 ClangTidyContext::ClangTidyContext(
-    std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
-    bool AllowEnablingAnalyzerAlphaCheckers)
+    std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider)
     : DiagEngine(nullptr), OptionsProvider(std::move(OptionsProvider)),
-      Profile(false),
-      AllowEnablingAnalyzerAlphaCheckers(AllowEnablingAnalyzerAlphaCheckers) {
+      Profile(nullptr) {
   // Before the first translation unit we can get errors related to command-line
   // parsing, use empty string for the file name in this case.
   setCurrentFile("");
@@ -235,19 +233,7 @@ ClangTidyOptions ClangTidyContext::getOptionsForFile(StringRef File) const {
       OptionsProvider->getOptions(File));
 }
 
-void ClangTidyContext::setEnableProfiling(bool P) { Profile = P; }
-
-void ClangTidyContext::setProfileStoragePrefix(StringRef Prefix) {
-  ProfilePrefix = Prefix;
-}
-
-llvm::Optional<ClangTidyProfiling::StorageParams>
-ClangTidyContext::getProfileStorageParams() const {
-  if (ProfilePrefix.empty())
-    return llvm::None;
-
-  return ClangTidyProfiling::StorageParams(ProfilePrefix, CurrentFile);
-}
+void ClangTidyContext::setCheckProfileData(ProfileData *P) { Profile = P; }
 
 bool ClangTidyContext::isCheckEnabled(StringRef CheckName) const {
   assert(CheckFilter != nullptr);
@@ -388,7 +374,7 @@ static bool LineIsMarkedWithNOLINTinMacro(SourceManager &SM, SourceLocation Loc,
       return true;
     if (!Loc.isMacroID())
       return false;
-    Loc = SM.getImmediateExpansionRange(Loc).getBegin();
+    Loc = SM.getImmediateExpansionRange(Loc).first;
   }
   return false;
 }

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

@@ -11,7 +11,6 @@
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
 
 #include "ClangTidyOptions.h"
-#include "ClangTidyProfiling.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Tooling/Core/Diagnostic.h"
@@ -88,6 +87,11 @@ struct ClangTidyStats {
   }
 };
 
+/// \brief Container for clang-tidy profiling data.
+struct ProfileData {
+  llvm::StringMap<llvm::TimeRecord> Records;
+};
+
 /// \brief Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
 /// provided by this context.
 ///
@@ -100,8 +104,7 @@ struct ClangTidyStats {
 class ClangTidyContext {
 public:
   /// \brief Initializes \c ClangTidyContext instance.
-  ClangTidyContext(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
-                   bool AllowEnablingAnalyzerAlphaCheckers = false);
+  ClangTidyContext(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider);
 
   ~ClangTidyContext();
 
@@ -166,14 +169,12 @@ public:
   /// \brief Clears collected errors.
   void clearErrors() { Errors.clear(); }
 
-  /// \brief Control profile collection in clang-tidy.
-  void setEnableProfiling(bool Profile);
-  bool getEnableProfiling() const { return Profile; }
-
-  /// \brief Control storage of profile date.
-  void setProfileStoragePrefix(StringRef ProfilePrefix);
-  llvm::Optional<ClangTidyProfiling::StorageParams>
-  getProfileStorageParams() const;
+  /// \brief Set the output struct for profile data.
+  ///
+  /// Setting a non-null pointer here will enable profile collection in
+  /// clang-tidy.
+  void setCheckProfileData(ProfileData *Profile);
+  ProfileData *getCheckProfileData() const { return Profile; }
 
   /// \brief Should be called when starting to process new translation unit.
   void setCurrentBuildDirectory(StringRef BuildDirectory) {
@@ -185,12 +186,6 @@ public:
     return CurrentBuildDirectory;
   }
 
-  /// \brief If the experimental alpha checkers from the static analyzer can be
-  /// enabled.
-  bool canEnableAnalyzerAlphaCheckers() const {
-    return AllowEnablingAnalyzerAlphaCheckers;
-  }
-
 private:
   // Calls setDiagnosticsEngine() and storeError().
   friend class ClangTidyDiagnosticConsumer;
@@ -221,10 +216,7 @@ private:
 
   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 
-  bool Profile;
-  std::string ProfilePrefix;
-
-  bool AllowEnablingAnalyzerAlphaCheckers;
+  ProfileData *Profile;
 };
 
 /// \brief A diagnostic consumer that turns each \c Diagnostic into a

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

@@ -83,11 +83,10 @@ template <> struct MappingTraits<ClangTidyOptions> {
   static void mapping(IO &IO, ClangTidyOptions &Options) {
     MappingNormalization<NOptionMap, ClangTidyOptions::OptionMap> NOpts(
         IO, Options.CheckOptions);
-    bool Ignored = false;
     IO.mapOptional("Checks", Options.Checks);
     IO.mapOptional("WarningsAsErrors", Options.WarningsAsErrors);
     IO.mapOptional("HeaderFilterRegex", Options.HeaderFilterRegex);
-    IO.mapOptional("AnalyzeTemporaryDtors", Ignored); // legacy compatibility
+    IO.mapOptional("AnalyzeTemporaryDtors", Options.AnalyzeTemporaryDtors);
     IO.mapOptional("FormatStyle", Options.FormatStyle);
     IO.mapOptional("User", Options.User);
     IO.mapOptional("CheckOptions", NOpts->Options);
@@ -108,6 +107,7 @@ ClangTidyOptions ClangTidyOptions::getDefaults() {
   Options.WarningsAsErrors = "";
   Options.HeaderFilterRegex = "";
   Options.SystemHeaders = false;
+  Options.AnalyzeTemporaryDtors = false;
   Options.FormatStyle = "none";
   Options.User = llvm::None;
   for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
@@ -147,6 +147,7 @@ ClangTidyOptions::mergeWith(const ClangTidyOptions &Other) const {
   mergeCommaSeparatedLists(Result.WarningsAsErrors, Other.WarningsAsErrors);
   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);
@@ -203,12 +204,9 @@ ConfigOptionsProvider::getRawOptions(llvm::StringRef FileName) {
 FileOptionsProvider::FileOptionsProvider(
     const ClangTidyGlobalOptions &GlobalOptions,
     const ClangTidyOptions &DefaultOptions,
-    const ClangTidyOptions &OverrideOptions,
-    llvm::IntrusiveRefCntPtr<vfs::FileSystem> VFS)
+    const ClangTidyOptions &OverrideOptions)
     : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
-      OverrideOptions(OverrideOptions), FS(std::move(VFS)) {
-  if (!FS)
-    FS = vfs::getRealFileSystem();
+      OverrideOptions(OverrideOptions) {
   ConfigHandlers.emplace_back(".clang-tidy", parseConfiguration);
 }
 
@@ -225,22 +223,15 @@ FileOptionsProvider::FileOptionsProvider(
 // similar.
 std::vector<OptionsSource>
 FileOptionsProvider::getRawOptions(StringRef FileName) {
-  LLVM_DEBUG(llvm::dbgs() << "Getting options for file " << FileName
-                          << "...\n");
-  assert(FS && "FS must be set.");
-
-  llvm::SmallString<128> AbsoluteFilePath(FileName);
-
-  if (FS->makeAbsolute(AbsoluteFilePath))
-    return {};
+  DEBUG(llvm::dbgs() << "Getting options for file " << FileName << "...\n");
 
   std::vector<OptionsSource> RawOptions =
-      DefaultOptionsProvider::getRawOptions(AbsoluteFilePath.str());
+      DefaultOptionsProvider::getRawOptions(FileName);
   OptionsSource CommandLineOptions(OverrideOptions,
                                    OptionsSourceTypeCheckCommandLineOption);
   // Look for a suitable configuration file in all parent directories of the
   // file. Start with the immediate parent directory and move up.
-  StringRef Path = llvm::sys::path::parent_path(AbsoluteFilePath.str());
+  StringRef Path = llvm::sys::path::parent_path(FileName);
   for (StringRef CurrentPath = Path; !CurrentPath.empty();
        CurrentPath = llvm::sys::path::parent_path(CurrentPath)) {
     llvm::Optional<OptionsSource> Result;
@@ -255,8 +246,8 @@ FileOptionsProvider::getRawOptions(StringRef FileName) {
     if (Result) {
       // Store cached value for all intermediate directories.
       while (Path != CurrentPath) {
-        LLVM_DEBUG(llvm::dbgs()
-                   << "Caching configuration for path " << Path << ".\n");
+        DEBUG(llvm::dbgs() << "Caching configuration for path " << Path
+                           << ".\n");
         CachedOptions[Path] = *Result;
         Path = llvm::sys::path::parent_path(Path);
       }
@@ -283,7 +274,7 @@ FileOptionsProvider::tryReadConfigFile(StringRef Directory) {
   for (const ConfigFileHandler &ConfigHandler : ConfigHandlers) {
     SmallString<128> ConfigFile(Directory);
     llvm::sys::path::append(ConfigFile, ConfigHandler.first);
-    LLVM_DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
+    DEBUG(llvm::dbgs() << "Trying " << ConfigFile << "...\n");
 
     bool IsFile = false;
     // Ignore errors from is_regular_file: we only need to know if we can read

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

@@ -13,9 +13,7 @@
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/Support/ErrorOr.h"
-#include "clang/Basic/VirtualFileSystem.h"
 #include <functional>
 #include <map>
 #include <string>
@@ -74,6 +72,9 @@ struct ClangTidyOptions {
   /// \brief Output warnings from system headers matching \c HeaderFilterRegex.
   llvm::Optional<bool> SystemHeaders;
 
+  /// \brief Turns on temporary destructor-based analysis.
+  llvm::Optional<bool> AnalyzeTemporaryDtors;
+
   /// \brief Format code around applied fixes with clang-format using this
   /// style.
   ///
@@ -220,8 +221,7 @@ public:
   /// whatever options are read from the configuration file.
   FileOptionsProvider(const ClangTidyGlobalOptions &GlobalOptions,
                       const ClangTidyOptions &DefaultOptions,
-                      const ClangTidyOptions &OverrideOptions,
-                      llvm::IntrusiveRefCntPtr<vfs::FileSystem> FS = nullptr);
+                      const ClangTidyOptions &OverrideOptions);
 
   /// \brief Initializes the \c FileOptionsProvider instance with a custom set
   /// of configuration file handlers.
@@ -255,7 +255,6 @@ protected:
   llvm::StringMap<OptionsSource> CachedOptions;
   ClangTidyOptions OverrideOptions;
   ConfigFileHandlers ConfigHandlers;
-  llvm::IntrusiveRefCntPtr<vfs::FileSystem> FS;
 };
 
 /// \brief Parses LineFilter from JSON and stores it to the \p Options.

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

@@ -1,93 +0,0 @@
-//===--- ClangTidyProfiling.cpp - clang-tidy --------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ClangTidyProfiling.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/YAMLTraits.h"
-#include "llvm/Support/raw_ostream.h"
-#include <system_error>
-#include <utility>
-
-#define DEBUG_TYPE "clang-tidy-profiling"
-
-namespace clang {
-namespace tidy {
-
-ClangTidyProfiling::StorageParams::StorageParams(llvm::StringRef ProfilePrefix,
-                                                 llvm::StringRef SourceFile)
-    : Timestamp(std::chrono::system_clock::now()), SourceFilename(SourceFile) {
-  llvm::SmallString<32> TimestampStr;
-  llvm::raw_svector_ostream OS(TimestampStr);
-  llvm::format_provider<decltype(Timestamp)>::format(Timestamp, OS,
-                                                     "%Y%m%d%H%M%S%N");
-
-  llvm::SmallString<256> FinalPrefix(ProfilePrefix);
-  llvm::sys::path::append(FinalPrefix, TimestampStr);
-
-  // So the full output name is: /ProfilePrefix/timestamp-inputfilename.json
-  StoreFilename = llvm::Twine(FinalPrefix + "-" +
-                              llvm::sys::path::filename(SourceFile) + ".json")
-                      .str();
-}
-
-void ClangTidyProfiling::printUserFriendlyTable(llvm::raw_ostream &OS) {
-  TG->print(OS);
-  OS.flush();
-}
-
-void ClangTidyProfiling::printAsJSON(llvm::raw_ostream &OS) {
-  OS << "{\n";
-  OS << "\"file\": \"" << Storage->SourceFilename << "\",\n";
-  OS << "\"timestamp\": \"" << Storage->Timestamp << "\",\n";
-  OS << "\"profile\": {\n";
-  TG->printJSONValues(OS, "");
-  OS << "\n}\n";
-  OS << "}\n";
-  OS.flush();
-}
-
-void ClangTidyProfiling::storeProfileData() {
-  assert(Storage.hasValue() && "We should have a filename.");
-
-  llvm::SmallString<256> OutputDirectory(Storage->StoreFilename);
-  llvm::sys::path::remove_filename(OutputDirectory);
-  if (std::error_code EC = llvm::sys::fs::create_directories(OutputDirectory)) {
-    llvm::errs() << "Unable to create output directory '" << OutputDirectory
-                 << "': " << EC.message() << "\n";
-    return;
-  }
-
-  std::error_code EC;
-  llvm::raw_fd_ostream OS(Storage->StoreFilename, EC, llvm::sys::fs::F_None);
-  if (EC) {
-    llvm::errs() << "Error opening output file '" << Storage->StoreFilename
-                 << "': " << EC.message() << "\n";
-    return;
-  }
-
-  printAsJSON(OS);
-}
-
-ClangTidyProfiling::ClangTidyProfiling(llvm::Optional<StorageParams> Storage)
-    : Storage(std::move(Storage)) {}
-
-ClangTidyProfiling::~ClangTidyProfiling() {
-  TG.emplace("clang-tidy", "clang-tidy checks profiling", Records);
-
-  if (!Storage.hasValue())
-    printUserFriendlyTable(llvm::errs());
-  else
-    storeProfileData();
-}
-
-} // namespace tidy
-} // namespace clang

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

@@ -1,60 +0,0 @@
-//===--- ClangTidyProfiling.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_CLANGTIDYPROFILING_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYPROFILING_H
-
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/Support/Chrono.h"
-#include "llvm/Support/Timer.h"
-#include "llvm/Support/raw_ostream.h"
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace clang {
-namespace tidy {
-
-class ClangTidyProfiling {
-public:
-  struct StorageParams {
-    llvm::sys::TimePoint<> Timestamp;
-    std::string SourceFilename;
-    std::string StoreFilename;
-
-    StorageParams() = default;
-
-    StorageParams(llvm::StringRef ProfilePrefix, llvm::StringRef SourceFile);
-  };
-
-private:
-  llvm::Optional<llvm::TimerGroup> TG;
-
-  llvm::Optional<StorageParams> Storage;
-
-  void printUserFriendlyTable(llvm::raw_ostream &OS);
-  void printAsJSON(llvm::raw_ostream &OS);
-
-  void storeProfileData();
-
-public:
-  llvm::StringMap<llvm::TimeRecord> Records;
-
-  ClangTidyProfiling() = default;
-
-  ClangTidyProfiling(llvm::Optional<StorageParams> Storage);
-
-  ~ClangTidyProfiling();
-};
-
-} // end namespace tidy
-} // end namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYPROFILING_H

clang-tools-extra/clang-tidy/abseil/AbseilTidyModule.cpp

@@ -1,38 +0,0 @@
-//===------- AbseilTidyModule.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 "StringFindStartswithCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace abseil {
-
-class AbseilModule : public ClangTidyModule {
-public:
-  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    CheckFactories.registerCheck<StringFindStartswithCheck>(
-        "abseil-string-find-startswith");
-  }
-};
-
-// Register the AbseilModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<AbseilModule> X("abseil-module",
-                                                    "Add Abseil checks.");
-
-} // namespace abseil
-
-// This anchor is used to force the linker to link in the generated object file
-// and thus register the AbseilModule.
-volatile int AbseilModuleAnchorSource = 0;
-
-} // namespace tidy
-} // namespace clang

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

@@ -1,14 +0,0 @@
-set(LLVM_LINK_COMPONENTS support)
-
-add_clang_library(clangTidyAbseilModule
-  AbseilTidyModule.cpp
-  StringFindStartswithCheck.cpp
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangLex
-  clangTidy
-  clangTidyUtils
-  )

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

@@ -1,136 +0,0 @@
-//===--- StringFindStartswithCheck.cc - clang-tidy---------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "StringFindStartswithCheck.h"
-
-#include "../utils/OptionsUtils.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Frontend/CompilerInstance.h"
-
-#include <cassert>
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace abseil {
-
-StringFindStartswithCheck::StringFindStartswithCheck(StringRef Name,
-                                                     ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      StringLikeClasses(utils::options::parseStringList(
-          Options.get("StringLikeClasses", "::std::basic_string"))),
-      IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
-          Options.getLocalOrGlobal("IncludeStyle", "llvm"))),
-      AbseilStringsMatchHeader(
-          Options.get("AbseilStringsMatchHeader", "absl/strings/match.h")) {}
-
-void StringFindStartswithCheck::registerMatchers(MatchFinder *Finder) {
-  auto ZeroLiteral = integerLiteral(equals(0));
-  auto StringClassMatcher = cxxRecordDecl(hasAnyName(SmallVector<StringRef, 4>(
-      StringLikeClasses.begin(), StringLikeClasses.end())));
-  auto StringType = hasUnqualifiedDesugaredType(
-      recordType(hasDeclaration(StringClassMatcher)));
-
-  auto StringFind = cxxMemberCallExpr(
-      // .find()-call on a string...
-      callee(cxxMethodDecl(hasName("find"))),
-      on(hasType(StringType)),
-      // ... with some search expression ...
-      hasArgument(0, expr().bind("needle")),
-      // ... and either "0" as second argument or the default argument (also 0).
-      anyOf(hasArgument(1, ZeroLiteral), hasArgument(1, cxxDefaultArgExpr())));
-
-  Finder->addMatcher(
-      // Match [=!]= with a zero on one side and a string.find on the other.
-      binaryOperator(
-          anyOf(hasOperatorName("=="), hasOperatorName("!=")),
-          hasEitherOperand(ignoringParenImpCasts(ZeroLiteral)),
-          hasEitherOperand(ignoringParenImpCasts(StringFind.bind("findexpr"))))
-          .bind("expr"),
-      this);
-}
-
-void StringFindStartswithCheck::check(const MatchFinder::MatchResult &Result) {
-  const ASTContext &Context = *Result.Context;
-  const SourceManager &Source = Context.getSourceManager();
-
-  // Extract matching (sub)expressions
-  const auto *ComparisonExpr = Result.Nodes.getNodeAs<BinaryOperator>("expr");
-  assert(ComparisonExpr != nullptr);
-  const auto *Needle = Result.Nodes.getNodeAs<Expr>("needle");
-  assert(Needle != nullptr);
-  const Expr *Haystack = Result.Nodes.getNodeAs<CXXMemberCallExpr>("findexpr")
-                             ->getImplicitObjectArgument();
-  assert(Haystack != nullptr);
-
-  if (ComparisonExpr->getLocStart().isMacroID())
-    return;
-
-  // Get the source code blocks (as characters) for both the string object
-  // and the search expression
-  const StringRef NeedleExprCode = Lexer::getSourceText(
-      CharSourceRange::getTokenRange(Needle->getSourceRange()), Source,
-      Context.getLangOpts());
-  const StringRef HaystackExprCode = Lexer::getSourceText(
-      CharSourceRange::getTokenRange(Haystack->getSourceRange()), Source,
-      Context.getLangOpts());
-
-  // Create the StartsWith string, negating if comparison was "!=".
-  bool Neg = ComparisonExpr->getOpcodeStr() == "!=";
-  StringRef StartswithStr;
-  if (Neg) {
-    StartswithStr = "!absl::StartsWith";
-  } else {
-    StartswithStr = "absl::StartsWith";
-  }
-
-  // Create the warning message and a FixIt hint replacing the original expr.
-  auto Diagnostic =
-      diag(ComparisonExpr->getLocStart(),
-           (StringRef("use ") + StartswithStr + " instead of find() " +
-            ComparisonExpr->getOpcodeStr() + " 0")
-               .str());
-
-  Diagnostic << FixItHint::CreateReplacement(
-      ComparisonExpr->getSourceRange(),
-      (StartswithStr + "(" + HaystackExprCode + ", " + NeedleExprCode + ")")
-          .str());
-
-  // Create a preprocessor #include FixIt hint (CreateIncludeInsertion checks
-  // whether this already exists).
-  auto IncludeHint = IncludeInserter->CreateIncludeInsertion(
-      Source.getFileID(ComparisonExpr->getLocStart()), AbseilStringsMatchHeader,
-      false);
-  if (IncludeHint) {
-    Diagnostic << *IncludeHint;
-  }
-}
-
-void StringFindStartswithCheck::registerPPCallbacks(
-    CompilerInstance &Compiler) {
-  IncludeInserter = llvm::make_unique<clang::tidy::utils::IncludeInserter>(
-      Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle);
-  Compiler.getPreprocessor().addPPCallbacks(
-      IncludeInserter->CreatePPCallbacks());
-}
-
-void StringFindStartswithCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "StringLikeClasses",
-                utils::options::serializeStringList(StringLikeClasses));
-  Options.store(Opts, "IncludeStyle",
-                utils::IncludeSorter::toString(IncludeStyle));
-  Options.store(Opts, "AbseilStringsMatchHeader", AbseilStringsMatchHeader);
-}
-
-} // namespace abseil
-} // namespace tidy
-} // namespace clang

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.h

@@ -1,48 +0,0 @@
-//===--- StringFindStartswithCheck.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_ABSEIL_STRINGFINDSTARTSWITHCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTARTSWITHCHECK_H
-
-#include "../ClangTidy.h"
-#include "../utils/IncludeInserter.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace clang {
-namespace tidy {
-namespace abseil {
-
-// Find string.find(...) == 0 comparisons and suggest replacing with StartsWith.
-// FIXME(niko): Add similar check for EndsWith
-// FIXME(niko): Add equivalent modernize checks for C++20's std::starts_With
-class StringFindStartswithCheck : public ClangTidyCheck {
-public:
-  using ClangTidyCheck::ClangTidyCheck;
-  StringFindStartswithCheck(StringRef Name, ClangTidyContext *Context);
-  void registerPPCallbacks(CompilerInstance &Compiler) override;
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-
-private:
-  std::unique_ptr<clang::tidy::utils::IncludeInserter> IncludeInserter;
-  const std::vector<std::string> StringLikeClasses;
-  const utils::IncludeSorter::IncludeStyle IncludeStyle;
-  const std::string AbseilStringsMatchHeader;
-};
-
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTARTSWITHCHECK_H

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

@@ -9,13 +9,11 @@
 #
 #===------------------------------------------------------------------------===#
 
-from __future__ import print_function
-
-import argparse
 import os
 import re
 import sys
 
+
 # Adapts the module's CMakelist file. Returns 'True' if it could add a new entry
 # and 'False' if the entry already existed.
 def adapt_cmake(module_path, check_name_camel):
@@ -31,7 +29,7 @@ def adapt_cmake(module_path, check_name_camel):
       return False
 
   print('Updating %s...' % filename)
-  with open(filename, 'w') as f:
+  with open(filename, 'wb') as f:
     cpp_found = False
     file_added = False
     for line in lines:
@@ -51,7 +49,7 @@ def write_header(module_path, module, check_name, check_name_camel):
   check_name_dashes = module + '-' + check_name
   filename = os.path.join(module_path, check_name_camel) + '.h'
   print('Creating %s...' % filename)
-  with open(filename, 'w') as f:
+  with open(filename, 'wb') as f:
     header_guard = ('LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_' + module.upper() + '_'
                     + check_name_camel.upper() + '_H')
     f.write('//===--- ')
@@ -104,7 +102,7 @@ public:
 def write_implementation(module_path, module, check_name_camel):
   filename = os.path.join(module_path, check_name_camel) + '.cpp'
   print('Creating %s...' % filename)
-  with open(filename, 'w') as f:
+  with open(filename, 'wb') as f:
     f.write('//===--- ')
     f.write(os.path.basename(filename))
     f.write(' - clang-tidy')
@@ -153,15 +151,14 @@ void %(check_name)s::check(const MatchFinder::MatchResult &Result) {
 
 # Modifies the module to include the new check.
 def adapt_module(module_path, module, check_name, check_name_camel):
-  modulecpp = list(filter(
-      lambda p: p.lower() == module.lower() + 'tidymodule.cpp',
-      os.listdir(module_path)))[0]
+  modulecpp = filter(lambda p: p.lower() == module.lower() + 'tidymodule.cpp',
+                     os.listdir(module_path))[0]
   filename = os.path.join(module_path, modulecpp)
   with open(filename, 'r') as f:
     lines = f.readlines()
 
   print('Updating %s...' % filename)
-  with open(filename, 'w') as f:
+  with open(filename, 'wb') as f:
     header_added = False
     header_found = False
     check_added = False
@@ -201,7 +198,7 @@ def add_release_notes(module_path, module, check_name):
     lines = f.readlines()
 
   print('Updating %s...' % filename)
-  with open(filename, 'w') as f:
+  with open(filename, 'wb') as f:
     note_added = False
     header_found = False
 
@@ -213,8 +210,8 @@ def add_release_notes(module_path, module, check_name):
         elif header_found:
           if not line.startswith('----'):
             f.write("""
-- New :doc:`%s
-  <clang-tidy/checks/%s>` check.
+- New `%s
+  <http://clang.llvm.org/extra/clang-tidy/checks/%s.html>`_ check
 
   FIXME: add release notes.
 """ % (check_name_dashes, check_name_dashes))
@@ -224,12 +221,12 @@ def add_release_notes(module_path, module, check_name):
 
 
 # Adds a test for the check.
-def write_test(module_path, module, check_name, test_extension):
+def write_test(module_path, module, check_name):
   check_name_dashes = module + '-' + check_name
   filename = os.path.normpath(os.path.join(module_path, '../../test/clang-tidy',
-                                           check_name_dashes + '.' + test_extension))
+                                           check_name_dashes + '.cpp'))
   print('Creating %s...' % filename)
-  with open(filename, 'w') as f:
+  with open(filename, 'wb') as f:
     f.write("""// RUN: %%check_clang_tidy %%s %(check_name_dashes)s %%t
 
 // FIXME: Add something that triggers the check here.
@@ -253,8 +250,8 @@ def update_checks_list(clang_tidy_path):
   filename = os.path.normpath(os.path.join(docs_dir, 'list.rst'))
   with open(filename, 'r') as f:
     lines = f.readlines()
-  doc_files = list(filter(lambda s: s.endswith('.rst') and s != 'list.rst',
-                     os.listdir(docs_dir)))
+  doc_files = filter(lambda s: s.endswith('.rst') and s != 'list.rst',
+                     os.listdir(docs_dir))
   doc_files.sort()
 
   def format_link(doc_file):
@@ -277,7 +274,7 @@ def update_checks_list(clang_tidy_path):
   checks = map(format_link, doc_files)
 
   print('Updating %s...' % filename)
-  with open(filename, 'w') as f:
+  with open(filename, 'wb') as f:
     for line in lines:
       f.write(line)
       if line.startswith('.. toctree::'):
@@ -291,7 +288,7 @@ def write_docs(module_path, module, check_name):
   filename = os.path.normpath(os.path.join(
       module_path, '../../docs/clang-tidy/checks/', check_name_dashes + '.rst'))
   print('Creating %s...' % filename)
-  with open(filename, 'w') as f:
+  with open(filename, 'wb') as f:
     f.write(""".. title:: clang-tidy - %(check_name_dashes)s
 
 %(check_name_dashes)s
@@ -303,48 +300,26 @@ FIXME: Describe what patterns does the check detect and why. Give examples.
 
 
 def main():
-  language_to_extension = {
-      'c': 'c',
-      'c++': 'cpp',
-      'objc': 'm',
-      'objc++': 'mm',
-  }
-  parser = argparse.ArgumentParser()
-  parser.add_argument(
-      '--update-docs',
-      action='store_true',
-      help='just update the list of documentation files, then exit')
-  parser.add_argument(
-      '--language',
-      help='language to use for new check (defaults to c++)',
-      choices=language_to_extension.keys(),
-      default='c++',
-      metavar='LANG')
-  parser.add_argument(
-      'module',
-      nargs='?',
-      help='module directory under which to place the new tidy check (e.g., misc)')
-  parser.add_argument(
-      'check',
-      nargs='?',
-      help='name of new tidy check to add (e.g. foo-do-the-stuff)')
-  args = parser.parse_args()
-
-  if args.update_docs:
+  if len(sys.argv) == 2 and sys.argv[1] == '--update-docs':
     update_checks_list(os.path.dirname(sys.argv[0]))
     return
 
-  if not args.module or not args.check:
-    print('Module and check must be specified.')
-    parser.print_usage()
+  if len(sys.argv) != 3:
+    print """\
+Usage: add_new_check.py <module> <check>, e.g.
+  add_new_check.py misc awesome-functions
+
+Alternatively, run 'add_new_check.py --update-docs' to just update the list of
+documentation files."""
+
     return
 
-  module = args.module
-  check_name = args.check
+  module = sys.argv[1]
+  check_name = sys.argv[2]
 
   if check_name.startswith(module):
-    print('Check name "%s" must not start with the module "%s". Exiting.' % (
-        check_name, module))
+    print 'Check name "%s" must not start with the module "%s". Exiting.' % (
+        check_name, module)
     return
   check_name_camel = ''.join(map(lambda elem: elem.capitalize(),
                                  check_name.split('-'))) + 'Check'
@@ -357,8 +332,7 @@ def main():
   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)
-  test_extension = language_to_extension.get(args.language)
-  write_test(module_path, module, check_name, test_extension)
+  write_test(module_path, module, check_name)
   write_docs(module_path, module, check_name)
   update_checks_list(clang_tidy_path)
   print('Done. Now it\'s your turn!')

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

@@ -13,16 +13,15 @@
 #include "CloexecAccept4Check.h"
 #include "CloexecAcceptCheck.h"
 #include "CloexecCreatCheck.h"
-#include "CloexecDupCheck.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"
-#include "ComparisonInTempFailureRetryCheck.h"
 
 using namespace clang::ast_matchers;
 
@@ -51,8 +50,6 @@ public:
         "android-cloexec-memfd-create");
     CheckFactories.registerCheck<CloexecOpenCheck>("android-cloexec-open");
     CheckFactories.registerCheck<CloexecSocketCheck>("android-cloexec-socket");
-    CheckFactories.registerCheck<ComparisonInTempFailureRetryCheck>(
-        "android-comparison-in-temp-failure-retry");
   }
 };
 

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

@@ -15,7 +15,6 @@ add_clang_library(clangTidyAndroidModule
   CloexecMemfdCreateCheck.cpp
   CloexecOpenCheck.cpp
   CloexecSocketCheck.cpp
-  ComparisonInTempFailureRetryCheck.cpp
 
   LINK_LIBS
   clangAST

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

@@ -32,7 +32,7 @@ void CloexecAccept4Check::registerMatchers(MatchFinder *Finder) {
 }
 
 void CloexecAccept4Check::check(const MatchFinder::MatchResult &Result) {
-  insertMacroFlag(Result, /*MacroFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/3);
+  insertMacroFlag(Result, /*MarcoFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/3);
 }
 
 } // namespace android

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

@@ -25,7 +25,7 @@ void CloexecEpollCreate1Check::registerMatchers(MatchFinder *Finder) {
 }
 
 void CloexecEpollCreate1Check::check(const MatchFinder::MatchResult &Result) {
-  insertMacroFlag(Result, /*MacroFlag=*/"EPOLL_CLOEXEC", /*ArgPos=*/0);
+  insertMacroFlag(Result, /*MarcoFlag=*/"EPOLL_CLOEXEC", /*ArgPos=*/0);
 }
 
 } // namespace android

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

@@ -25,7 +25,7 @@ void CloexecInotifyInit1Check::registerMatchers(MatchFinder *Finder) {
 }
 
 void CloexecInotifyInit1Check::check(const MatchFinder::MatchResult &Result) {
-  insertMacroFlag(Result, /*MacroFlag=*/"IN_CLOEXEC", /*ArgPos=*/0);
+  insertMacroFlag(Result, /*MarcoFlag=*/"IN_CLOEXEC", /*ArgPos=*/0);
 }
 
 } // namespace android

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

@@ -36,7 +36,7 @@ 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, /*MacroFlag=*/"O_CLOEXEC", ArgPos);
+  insertMacroFlag(Result, /*MarcoFlag=*/"O_CLOEXEC", ArgPos);
 }
 
 } // namespace android

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

@@ -27,7 +27,7 @@ void CloexecSocketCheck::registerMatchers(MatchFinder *Finder) {
 }
 
 void CloexecSocketCheck::check(const MatchFinder::MatchResult &Result) {
-  insertMacroFlag(Result, /*MacroFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/1);
+  insertMacroFlag(Result, /*MarcoFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/1);
 }
 
 } // namespace android

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

@@ -1,84 +0,0 @@
-//===--- ComparisonInTempFailureRetryCheck.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 "../utils/Matchers.h"
-#include "ComparisonInTempFailureRetryCheck.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 {
-AST_MATCHER(BinaryOperator, isRHSATempFailureRetryArg) {
-  if (!Node.getLocStart().isMacroID())
-    return false;
-
-  const SourceManager &SM = Finder->getASTContext().getSourceManager();
-  if (!SM.isMacroArgExpansion(Node.getRHS()->IgnoreParenCasts()->getLocStart()))
-    return false;
-
-  const LangOptions &Opts = Finder->getASTContext().getLangOpts();
-  SourceLocation LocStart = Node.getLocStart();
-  while (LocStart.isMacroID()) {
-    SourceLocation Invocation = SM.getImmediateMacroCallerLoc(LocStart);
-    Token Tok;
-    if (!Lexer::getRawToken(SM.getSpellingLoc(Invocation), Tok, SM, Opts,
-                            /*IgnoreWhiteSpace=*/true)) {
-      if (Tok.getKind() == tok::raw_identifier &&
-          Tok.getRawIdentifier() == "TEMP_FAILURE_RETRY")
-        return true;
-    }
-
-    LocStart = Invocation;
-  }
-  return false;
-}
-} // namespace
-
-void ComparisonInTempFailureRetryCheck::registerMatchers(MatchFinder *Finder) {
-  // Both glibc's and Bionic's TEMP_FAILURE_RETRY macros structurally look like:
-  //
-  // #define TEMP_FAILURE_RETRY(x) ({ \
-  //    typeof(x) y; \
-  //    do y = (x); \
-  //    while (y == -1 && errno == EINTR); \
-  //    y; \
-  // })
-  //
-  // (glibc uses `long int` instead of `typeof(x)` for the type of y).
-  //
-  // It's unclear how to walk up the AST from inside the expansion of `x`, and
-  // we need to not complain about things like TEMP_FAILURE_RETRY(foo(x == 1)),
-  // so we just match the assignment of `y = (x)` and inspect `x` from there.
-  Finder->addMatcher(
-      binaryOperator(
-          hasOperatorName("="),
-          hasRHS(ignoringParenCasts(
-              binaryOperator(matchers::isComparisonOperator()).bind("binop"))),
-          isRHSATempFailureRetryArg()),
-      this);
-}
-
-void ComparisonInTempFailureRetryCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  const auto &BinOp = *Result.Nodes.getNodeAs<BinaryOperator>("binop");
-  diag(BinOp.getOperatorLoc(), "top-level comparison in TEMP_FAILURE_RETRY");
-
-  // FIXME: FixIts would be nice, but potentially nontrivial when nested macros
-  // happen, e.g. `TEMP_FAILURE_RETRY(IS_ZERO(foo()))`
-}
-
-} // namespace android
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- ComparisonInTempFailureRetryCheck.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_COMPARISONINTEMPFAILURERETRYCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_COMPARISONINTEMPFAILURERETRYCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace android {
-
-/// Attempts to catch calls to TEMP_FAILURE_RETRY with a top-level comparison
-/// operation, like `TEMP_FAILURE_RETRY(read(...) != N)`. In these cases, the
-/// comparison should go outside of the TEMP_FAILURE_RETRY.
-///
-/// TEMP_FAILURE_RETRY is a macro provided by both glibc and Bionic.
-class ComparisonInTempFailureRetryCheck : public ClangTidyCheck {
-public:
-  ComparisonInTempFailureRetryCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(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_COMPARISONINTEMPFAILURERETRYCHECK_H

clang-tools-extra/clang-tidy/boost/UseToStringCheck.cpp

@@ -15,12 +15,10 @@ namespace clang {
 namespace tidy {
 namespace boost {
 
-namespace {
 AST_MATCHER(Type, isStrictlyInteger) {
   return Node.isIntegerType() && !Node.isAnyCharacterType() &&
          !Node.isBooleanType();
 }
-} // namespace
 
 void UseToStringCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)

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

@@ -10,44 +10,21 @@
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
-#include "../cppcoreguidelines/NarrowingConversionsCheck.h"
 #include "ArgumentCommentCheck.h"
 #include "AssertSideEffectCheck.h"
 #include "BoolPointerImplicitConversionCheck.h"
 #include "CopyConstructorInitCheck.h"
 #include "DanglingHandleCheck.h"
-#include "ExceptionEscapeCheck.h"
 #include "FoldInitTypeCheck.h"
 #include "ForwardDeclarationNamespaceCheck.h"
-#include "ForwardingReferenceOverloadCheck.h"
 #include "InaccurateEraseCheck.h"
-#include "IncorrectRoundingsCheck.h"
 #include "IntegerDivisionCheck.h"
-#include "LambdaFunctionNameCheck.h"
-#include "MacroParenthesesCheck.h"
-#include "MacroRepeatedSideEffectsCheck.h"
 #include "MisplacedOperatorInStrlenInAllocCheck.h"
-#include "MisplacedWideningCastCheck.h"
 #include "MoveForwardingReferenceCheck.h"
 #include "MultipleStatementMacroCheck.h"
-#include "ParentVirtualCallCheck.h"
-#include "SizeofContainerCheck.h"
-#include "SizeofExpressionCheck.h"
 #include "StringConstructorCheck.h"
-#include "StringIntegerAssignmentCheck.h"
-#include "StringLiteralWithEmbeddedNulCheck.h"
-#include "SuspiciousEnumUsageCheck.h"
 #include "SuspiciousMemsetUsageCheck.h"
-#include "SuspiciousMissingCommaCheck.h"
-#include "SuspiciousSemicolonCheck.h"
-#include "SuspiciousStringCompareCheck.h"
-#include "SwappedArgumentsCheck.h"
-#include "TerminatingContinueCheck.h"
-#include "ThrowKeywordMissingCheck.h"
 #include "UndefinedMemoryManipulationCheck.h"
-#include "UndelegatedConstructorCheck.h"
-#include "UnusedRaiiCheck.h"
-#include "UnusedReturnValueCheck.h"
 #include "UseAfterMoveCheck.h"
 #include "VirtualNearMissCheck.h"
 
@@ -68,72 +45,26 @@ public:
         "bugprone-copy-constructor-init");
     CheckFactories.registerCheck<DanglingHandleCheck>(
         "bugprone-dangling-handle");
-    CheckFactories.registerCheck<ExceptionEscapeCheck>(
-        "bugprone-exception-escape");
     CheckFactories.registerCheck<FoldInitTypeCheck>(
         "bugprone-fold-init-type");
     CheckFactories.registerCheck<ForwardDeclarationNamespaceCheck>(
         "bugprone-forward-declaration-namespace");
-    CheckFactories.registerCheck<ForwardingReferenceOverloadCheck>(
-        "bugprone-forwarding-reference-overload");
     CheckFactories.registerCheck<InaccurateEraseCheck>(
         "bugprone-inaccurate-erase");
-    CheckFactories.registerCheck<IncorrectRoundingsCheck>(
-        "bugprone-incorrect-roundings");
     CheckFactories.registerCheck<IntegerDivisionCheck>(
         "bugprone-integer-division");
-    CheckFactories.registerCheck<LambdaFunctionNameCheck>(
-        "bugprone-lambda-function-name");
-    CheckFactories.registerCheck<MacroParenthesesCheck>(
-        "bugprone-macro-parentheses");
-    CheckFactories.registerCheck<MacroRepeatedSideEffectsCheck>(
-        "bugprone-macro-repeated-side-effects");
     CheckFactories.registerCheck<MisplacedOperatorInStrlenInAllocCheck>(
         "bugprone-misplaced-operator-in-strlen-in-alloc");
-    CheckFactories.registerCheck<MisplacedWideningCastCheck>(
-        "bugprone-misplaced-widening-cast");
     CheckFactories.registerCheck<MoveForwardingReferenceCheck>(
         "bugprone-move-forwarding-reference");
     CheckFactories.registerCheck<MultipleStatementMacroCheck>(
         "bugprone-multiple-statement-macro");
-    CheckFactories.registerCheck<cppcoreguidelines::NarrowingConversionsCheck>(
-        "bugprone-narrowing-conversions");
-    CheckFactories.registerCheck<ParentVirtualCallCheck>(
-        "bugprone-parent-virtual-call");
-    CheckFactories.registerCheck<SizeofContainerCheck>(
-        "bugprone-sizeof-container");
-    CheckFactories.registerCheck<SizeofExpressionCheck>(
-        "bugprone-sizeof-expression");
     CheckFactories.registerCheck<StringConstructorCheck>(
         "bugprone-string-constructor");
-    CheckFactories.registerCheck<StringIntegerAssignmentCheck>(
-        "bugprone-string-integer-assignment");
-    CheckFactories.registerCheck<StringLiteralWithEmbeddedNulCheck>(
-        "bugprone-string-literal-with-embedded-nul");
-    CheckFactories.registerCheck<SuspiciousEnumUsageCheck>(
-        "bugprone-suspicious-enum-usage");
     CheckFactories.registerCheck<SuspiciousMemsetUsageCheck>(
         "bugprone-suspicious-memset-usage");
-    CheckFactories.registerCheck<SuspiciousMissingCommaCheck>(
-        "bugprone-suspicious-missing-comma");
-    CheckFactories.registerCheck<SuspiciousSemicolonCheck>(
-        "bugprone-suspicious-semicolon");
-    CheckFactories.registerCheck<SuspiciousStringCompareCheck>(
-        "bugprone-suspicious-string-compare");
-    CheckFactories.registerCheck<SwappedArgumentsCheck>(
-        "bugprone-swapped-arguments");
-    CheckFactories.registerCheck<TerminatingContinueCheck>(
-        "bugprone-terminating-continue");
-    CheckFactories.registerCheck<ThrowKeywordMissingCheck>(
-        "bugprone-throw-keyword-missing");
     CheckFactories.registerCheck<UndefinedMemoryManipulationCheck>(
         "bugprone-undefined-memory-manipulation");
-    CheckFactories.registerCheck<UndelegatedConstructorCheck>(
-        "bugprone-undelegated-constructor");
-    CheckFactories.registerCheck<UnusedRaiiCheck>(
-        "bugprone-unused-raii");
-    CheckFactories.registerCheck<UnusedReturnValueCheck>(
-        "bugprone-unused-return-value");
     CheckFactories.registerCheck<UseAfterMoveCheck>(
         "bugprone-use-after-move");
     CheckFactories.registerCheck<VirtualNearMissCheck>(

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

@@ -7,38 +7,16 @@ add_clang_library(clangTidyBugproneModule
   BugproneTidyModule.cpp
   CopyConstructorInitCheck.cpp
   DanglingHandleCheck.cpp
-  ExceptionEscapeCheck.cpp
   FoldInitTypeCheck.cpp
   ForwardDeclarationNamespaceCheck.cpp
-  ForwardingReferenceOverloadCheck.cpp
   InaccurateEraseCheck.cpp
-  IncorrectRoundingsCheck.cpp
   IntegerDivisionCheck.cpp
-  LambdaFunctionNameCheck.cpp
-  MacroParenthesesCheck.cpp
-  MacroRepeatedSideEffectsCheck.cpp
   MisplacedOperatorInStrlenInAllocCheck.cpp
-  MisplacedWideningCastCheck.cpp
   MoveForwardingReferenceCheck.cpp
   MultipleStatementMacroCheck.cpp
-  ParentVirtualCallCheck.cpp
-  SizeofContainerCheck.cpp
-  SizeofExpressionCheck.cpp
   StringConstructorCheck.cpp
-  StringIntegerAssignmentCheck.cpp
-  StringLiteralWithEmbeddedNulCheck.cpp
-  SuspiciousEnumUsageCheck.cpp
   SuspiciousMemsetUsageCheck.cpp
-  SuspiciousMissingCommaCheck.cpp
-  SuspiciousSemicolonCheck.cpp
-  SuspiciousStringCompareCheck.cpp
-  SwappedArgumentsCheck.cpp
-  TerminatingContinueCheck.cpp
-  ThrowKeywordMissingCheck.cpp
   UndefinedMemoryManipulationCheck.cpp
-  UndelegatedConstructorCheck.cpp
-  UnusedRaiiCheck.cpp
-  UnusedReturnValueCheck.cpp
   UseAfterMoveCheck.cpp
   VirtualNearMissCheck.cpp
 
@@ -49,7 +27,6 @@ add_clang_library(clangTidyBugproneModule
   clangBasic
   clangLex
   clangTidy
-  clangTidyCppCoreGuidelinesModule
   clangTidyUtils
   clangTooling
   )

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

@@ -25,12 +25,8 @@ namespace {
 ast_matchers::internal::BindableMatcher<Stmt>
 handleFrom(const ast_matchers::internal::Matcher<RecordDecl> &IsAHandle,
            const ast_matchers::internal::Matcher<Expr> &Arg) {
-  return expr(
-      anyOf(cxxConstructExpr(hasDeclaration(cxxMethodDecl(ofClass(IsAHandle))),
-                             hasArgument(0, Arg)),
-            cxxMemberCallExpr(hasType(cxxRecordDecl(IsAHandle)),
-                              callee(memberExpr(member(cxxConversionDecl()))),
-                              on(Arg))));
+  return cxxConstructExpr(hasDeclaration(cxxMethodDecl(ofClass(IsAHandle))),
+                          hasArgument(0, Arg));
 }
 
 ast_matchers::internal::Matcher<Stmt> handleFromTemporaryValue(

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

@@ -1,214 +0,0 @@
-//===--- ExceptionEscapeCheck.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 "ExceptionEscapeCheck.h"
-
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-#include "llvm/ADT/SmallSet.h"
-#include "llvm/ADT/StringSet.h"
-
-using namespace clang::ast_matchers;
-
-namespace {
-typedef llvm::SmallVector<const clang::Type *, 8> TypeVec;
-} // namespace
-
-namespace clang {
-
-static bool isBaseOf(const Type *DerivedType, const Type *BaseType) {
-  const auto *DerivedClass = DerivedType->getAsCXXRecordDecl();
-  const auto *BaseClass = BaseType->getAsCXXRecordDecl();
-  if (!DerivedClass || !BaseClass)
-    return false;
-
-  return !DerivedClass->forallBases(
-      [BaseClass](const CXXRecordDecl *Cur) { return Cur != BaseClass; });
-}
-
-static const TypeVec
-throwsException(const Stmt *St, const TypeVec &Caught,
-                llvm::SmallSet<const FunctionDecl *, 32> &CallStack);
-
-static const TypeVec
-throwsException(const FunctionDecl *Func,
-                llvm::SmallSet<const FunctionDecl *, 32> &CallStack) {
-  if (CallStack.count(Func))
-    return TypeVec();
-
-  if (const Stmt *Body = Func->getBody()) {
-    CallStack.insert(Func);
-    const TypeVec Result = throwsException(Body, TypeVec(), CallStack);
-    CallStack.erase(Func);
-    return Result;
-  }
-
-  TypeVec Result;
-  if (const auto *FPT = Func->getType()->getAs<FunctionProtoType>()) {
-    for (const QualType Ex : FPT->exceptions()) {
-      Result.push_back(Ex.getTypePtr());
-    }
-  }
-  return Result;
-}
-
-static const TypeVec
-throwsException(const Stmt *St, const TypeVec &Caught,
-                llvm::SmallSet<const FunctionDecl *, 32> &CallStack) {
-  TypeVec Results;
-
-  if (!St)
-    return Results;
-
-  if (const auto *Throw = dyn_cast<CXXThrowExpr>(St)) {
-    if (const auto *ThrownExpr = Throw->getSubExpr()) {
-      const auto *ThrownType =
-          ThrownExpr->getType()->getUnqualifiedDesugaredType();
-      if (ThrownType->isReferenceType()) {
-        ThrownType = ThrownType->castAs<ReferenceType>()
-                         ->getPointeeType()
-                         ->getUnqualifiedDesugaredType();
-      }
-      if (const auto *TD = ThrownType->getAsTagDecl()) {
-        if (TD->getDeclName().isIdentifier() && TD->getName() == "bad_alloc"
-            && TD->isInStdNamespace())
-          return Results;
-      }
-      Results.push_back(ThrownExpr->getType()->getUnqualifiedDesugaredType());
-    } else {
-      Results.append(Caught.begin(), Caught.end());
-    }
-  } else if (const auto *Try = dyn_cast<CXXTryStmt>(St)) {
-    TypeVec Uncaught = throwsException(Try->getTryBlock(), Caught, CallStack);
-    for (unsigned i = 0; i < Try->getNumHandlers(); ++i) {
-      const CXXCatchStmt *Catch = Try->getHandler(i);
-      if (!Catch->getExceptionDecl()) {
-        const TypeVec Rethrown =
-            throwsException(Catch->getHandlerBlock(), Uncaught, CallStack);
-        Results.append(Rethrown.begin(), Rethrown.end());
-        Uncaught.clear();
-      } else {
-        const auto *CaughtType =
-            Catch->getCaughtType()->getUnqualifiedDesugaredType();
-        if (CaughtType->isReferenceType()) {
-          CaughtType = CaughtType->castAs<ReferenceType>()
-                           ->getPointeeType()
-                           ->getUnqualifiedDesugaredType();
-        }
-        auto NewEnd =
-            llvm::remove_if(Uncaught, [&CaughtType](const Type *ThrownType) {
-              return ThrownType == CaughtType ||
-                     isBaseOf(ThrownType, CaughtType);
-            });
-        if (NewEnd != Uncaught.end()) {
-          Uncaught.erase(NewEnd, Uncaught.end());
-          const TypeVec Rethrown = throwsException(
-              Catch->getHandlerBlock(), TypeVec(1, CaughtType), CallStack);
-          Results.append(Rethrown.begin(), Rethrown.end());
-        }
-      }
-    }
-    Results.append(Uncaught.begin(), Uncaught.end());
-  } else if (const auto *Call = dyn_cast<CallExpr>(St)) {
-    if (const FunctionDecl *Func = Call->getDirectCallee()) {
-      TypeVec Excs = throwsException(Func, CallStack);
-      Results.append(Excs.begin(), Excs.end());
-    }
-  } else {
-    for (const Stmt *Child : St->children()) {
-      TypeVec Excs = throwsException(Child, Caught, CallStack);
-      Results.append(Excs.begin(), Excs.end());
-    }
-  }
-  return Results;
-}
-
-static const TypeVec throwsException(const FunctionDecl *Func) {
-  llvm::SmallSet<const FunctionDecl *, 32> CallStack;
-  return throwsException(Func, CallStack);
-}
-
-namespace ast_matchers {
-AST_MATCHER_P(FunctionDecl, throws, internal::Matcher<Type>, InnerMatcher) {
-  TypeVec ExceptionList = throwsException(&Node);
-  auto NewEnd = llvm::remove_if(
-      ExceptionList, [this, Finder, Builder](const Type *Exception) {
-        return !InnerMatcher.matches(*Exception, Finder, Builder);
-      });
-  ExceptionList.erase(NewEnd, ExceptionList.end());
-  return ExceptionList.size();
-}
-
-AST_MATCHER_P(Type, isIgnored, llvm::StringSet<>, IgnoredExceptions) {
-  if (const auto *TD = Node.getAsTagDecl()) {
-    if (TD->getDeclName().isIdentifier())
-      return IgnoredExceptions.count(TD->getName()) > 0;
-  }
-  return false;
-}
-
-AST_MATCHER_P(FunctionDecl, isEnabled, llvm::StringSet<>,
-              FunctionsThatShouldNotThrow) {
-  return FunctionsThatShouldNotThrow.count(Node.getNameAsString()) > 0;
-}
-} // namespace ast_matchers
-
-namespace tidy {
-namespace bugprone {
-
-ExceptionEscapeCheck::ExceptionEscapeCheck(StringRef Name,
-                                           ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), RawFunctionsThatShouldNotThrow(Options.get(
-                                         "FunctionsThatShouldNotThrow", "")),
-      RawIgnoredExceptions(Options.get("IgnoredExceptions", "")) {
-  llvm::SmallVector<StringRef, 8> FunctionsThatShouldNotThrowVec,
-      IgnoredExceptionsVec;
-  StringRef(RawFunctionsThatShouldNotThrow)
-      .split(FunctionsThatShouldNotThrowVec, ",", -1, false);
-  FunctionsThatShouldNotThrow.insert(FunctionsThatShouldNotThrowVec.begin(),
-                                     FunctionsThatShouldNotThrowVec.end());
-  StringRef(RawIgnoredExceptions).split(IgnoredExceptionsVec, ",", -1, false);
-  IgnoredExceptions.insert(IgnoredExceptionsVec.begin(),
-                           IgnoredExceptionsVec.end());
-}
-
-void ExceptionEscapeCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "FunctionsThatShouldNotThrow",
-                RawFunctionsThatShouldNotThrow);
-  Options.store(Opts, "IgnoredExceptions", RawIgnoredExceptions);
-}
-
-void ExceptionEscapeCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      functionDecl(allOf(anyOf(isNoThrow(), cxxDestructorDecl(),
-                               cxxConstructorDecl(isMoveConstructor()),
-                               cxxMethodDecl(isMoveAssignmentOperator()),
-                               hasName("main"), hasName("swap"),
-                               isEnabled(FunctionsThatShouldNotThrow)),
-                         throws(unless(isIgnored(IgnoredExceptions)))))
-          .bind("thrower"),
-      this);
-}
-
-void ExceptionEscapeCheck::check(const MatchFinder::MatchResult &Result) {
-  const FunctionDecl *MatchedDecl =
-      Result.Nodes.getNodeAs<FunctionDecl>("thrower");
-  if (!MatchedDecl)
-    return;
-
-  // FIXME: We should provide more information about the exact location where
-  // the exception is thrown, maybe the full path the exception escapes
-  diag(MatchedDecl->getLocation(), "an exception may be thrown in function %0 "
-       "which should not throw exceptions") << MatchedDecl;
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

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

@@ -1,47 +0,0 @@
-//===--- ExceptionEscapeCheck.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_EXCEPTION_ESCAPE_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_EXCEPTION_ESCAPE_H
-
-#include "../ClangTidy.h"
-
-#include "llvm/ADT/StringSet.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds functions which should not throw exceptions: Destructors, move
-/// constructors, move assignment operators, the main() function,
-/// swap() functions, functions marked with throw() or noexcept and functions
-/// given as option to the checker.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-exception-escape.html
-class ExceptionEscapeCheck : public ClangTidyCheck {
-public:
-  ExceptionEscapeCheck(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:
-  std::string RawFunctionsThatShouldNotThrow;
-  std::string RawIgnoredExceptions;
-
-  llvm::StringSet<> FunctionsThatShouldNotThrow;
-  llvm::StringSet<> IgnoredExceptions;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_EXCEPTION_ESCAPE_H

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

@@ -1,71 +0,0 @@
-//===--- IncorrectRoundingsCheck.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 "IncorrectRoundingsCheck.h"
-#include "clang/AST/DeclBase.h"
-#include "clang/AST/Type.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-namespace {
-AST_MATCHER(FloatingLiteral, floatHalf) {
-  const auto &literal = Node.getValue();
-  if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
-    return literal.convertToFloat() == 0.5f;
-  if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
-    return literal.convertToDouble() == 0.5;
-  return false;
-}
-} // namespace
-
-void IncorrectRoundingsCheck::registerMatchers(MatchFinder *MatchFinder) {
-  // Match a floating literal with value 0.5.
-  auto FloatHalf = floatLiteral(floatHalf());
-
-  // Match a floating point expression.
-  auto FloatType = expr(hasType(realFloatingPointType()));
-
-  // Match a floating literal of 0.5 or a floating literal of 0.5 implicitly.
-  // cast to floating type.
-  auto FloatOrCastHalf =
-      anyOf(FloatHalf,
-            implicitCastExpr(FloatType, has(ignoringParenImpCasts(FloatHalf))));
-
-  // Match if either the LHS or RHS is a floating literal of 0.5 or a floating
-  // literal of 0.5 and the other is of type double or vice versa.
-  auto OneSideHalf = anyOf(allOf(hasLHS(FloatOrCastHalf), hasRHS(FloatType)),
-                           allOf(hasRHS(FloatOrCastHalf), hasLHS(FloatType)));
-
-  // Find expressions of cast to int of the sum of a floating point expression
-  // and 0.5.
-  MatchFinder->addMatcher(
-      implicitCastExpr(
-          hasImplicitDestinationType(isInteger()),
-          ignoringParenCasts(binaryOperator(hasOperatorName("+"), OneSideHalf)))
-          .bind("CastExpr"),
-      this);
-}
-
-void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *CastExpr = Result.Nodes.getNodeAs<ImplicitCastExpr>("CastExpr");
-  diag(CastExpr->getLocStart(),
-       "casting (double + 0.5) to integer leads to incorrect rounding; "
-       "consider using lround (#include <cmath>) instead");
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

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

@@ -1,39 +0,0 @@
-//===--- IncorrectRoundingsCheck.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_INCORRECTROUNDINGSCHECK_H_
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INCORRECTROUNDINGSCHECK_H_
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// \brief Checks the usage of patterns known to produce incorrect rounding.
-/// Programmers often use
-///   (int)(double_expression + 0.5)
-/// to round the double expression to an integer. The problem with this
-///  1. It is unnecessarily slow.
-///  2. It is incorrect. The number 0.499999975 (smallest representable float
-///     number below 0.5) rounds to 1.0. Even worse behavior for negative
-///     numbers where both -0.5f and -1.4f both round to 0.0.
-class IncorrectRoundingsCheck : public ClangTidyCheck {
-public:
-  IncorrectRoundingsCheck(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_INCORRECTROUNDINGSCHECK_H_

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

@@ -1,31 +0,0 @@
-//===--- MacroRepeatedSideEffectsCheck.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_MACROREPEATEDSIDEEFFECTSCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MACROREPEATEDSIDEEFFECTSCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Checks for repeated argument with side effects in macros.
-class MacroRepeatedSideEffectsCheck : public ClangTidyCheck {
-public:
-  MacroRepeatedSideEffectsCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerPPCallbacks(CompilerInstance &Compiler) override;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MACROREPEATEDSIDEEFFECTSCHECK_H

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

@@ -38,7 +38,7 @@ const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) {
   return nextStmt(Result, Parent);
 }
 
-using ExpansionRanges = std::vector<SourceRange>;
+using ExpansionRanges = std::vector<std::pair<SourceLocation, SourceLocation>>;
 
 /// \bried Get all the macro expansion ranges related to `Loc`.
 ///
@@ -47,9 +47,8 @@ ExpansionRanges getExpansionRanges(SourceLocation Loc,
                                    const MatchFinder::MatchResult &Result) {
   ExpansionRanges Locs;
   while (Loc.isMacroID()) {
-    Locs.push_back(
-        Result.SourceManager->getImmediateExpansionRange(Loc).getAsRange());
-    Loc = Locs.back().getBegin();
+    Locs.push_back(Result.SourceManager->getImmediateExpansionRange(Loc));
+    Loc = Locs.back().first;
   }
   return Locs;
 }
@@ -97,9 +96,9 @@ void MultipleStatementMacroCheck::check(
       InnerRanges.back() != NextRanges.back())
     return;
 
-  diag(InnerRanges.back().getBegin(), "multiple statement macro used without "
-                                      "braces; some statements will be "
-                                      "unconditionally executed");
+  diag(InnerRanges.back().first, "multiple statement macro used without "
+                                 "braces; some statements will be "
+                                 "unconditionally executed");
 }
 
 } // namespace bugprone

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

@@ -1,156 +0,0 @@
-//===--- ParentVirtualCallCheck.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 "ParentVirtualCallCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Tooling/FixIt.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallVector.h"
-#include <algorithm>
-#include <cctype>
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-using BasesVector = llvm::SmallVector<const CXXRecordDecl *, 5>;
-
-static bool isParentOf(const CXXRecordDecl &Parent,
-                       const CXXRecordDecl &ThisClass) {
-  if (Parent.getCanonicalDecl() == ThisClass.getCanonicalDecl())
-    return true;
-  const CXXRecordDecl *ParentCanonicalDecl = Parent.getCanonicalDecl();
-  return ThisClass.bases_end() !=
-         llvm::find_if(ThisClass.bases(), [=](const CXXBaseSpecifier &Base) {
-           auto *BaseDecl = Base.getType()->getAsCXXRecordDecl();
-           assert(BaseDecl);
-           return ParentCanonicalDecl == BaseDecl->getCanonicalDecl();
-         });
-}
-
-static BasesVector getParentsByGrandParent(const CXXRecordDecl &GrandParent,
-                                           const CXXRecordDecl &ThisClass,
-                                           const CXXMethodDecl &MemberDecl) {
-  BasesVector Result;
-  for (const auto &Base : ThisClass.bases()) {
-    const auto *BaseDecl = Base.getType()->getAsCXXRecordDecl();
-    const CXXMethodDecl *ActualMemberDecl =
-        MemberDecl.getCorrespondingMethodInClass(BaseDecl);
-    if (!ActualMemberDecl)
-      continue;
-    // TypePtr is the nearest base class to ThisClass between ThisClass and
-    // GrandParent, where MemberDecl is overridden. TypePtr is the class the
-    // check proposes to fix to.
-    const Type *TypePtr =
-        ActualMemberDecl->getThisType(ActualMemberDecl->getASTContext())
-            .getTypePtr();
-    const CXXRecordDecl *RecordDeclType = TypePtr->getPointeeCXXRecordDecl();
-    assert(RecordDeclType && "TypePtr is not a pointer to CXXRecordDecl!");
-    if (RecordDeclType->getCanonicalDecl()->isDerivedFrom(&GrandParent))
-      Result.emplace_back(RecordDeclType);
-  }
-
-  return Result;
-}
-
-static std::string getNameAsString(const NamedDecl *Decl) {
-  std::string QualName;
-  llvm::raw_string_ostream OS(QualName);
-  PrintingPolicy PP(Decl->getASTContext().getPrintingPolicy());
-  PP.SuppressUnwrittenScope = true;
-  Decl->printQualifiedName(OS, PP);
-  return OS.str();
-}
-
-// Returns E as written in the source code. Used to handle 'using' and
-// 'typedef'ed names of grand-parent classes.
-static std::string getExprAsString(const clang::Expr &E,
-                                   clang::ASTContext &AC) {
-  std::string Text = tooling::fixit::getText(E, AC).str();
-  Text.erase(
-      llvm::remove_if(
-          Text,
-          [](char C) { return std::isspace(static_cast<unsigned char>(C)); }),
-      Text.end());
-  return Text;
-}
-
-void ParentVirtualCallCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      cxxMemberCallExpr(
-          callee(memberExpr(hasDescendant(implicitCastExpr(
-                                hasImplicitDestinationType(pointsTo(
-                                    type(anything()).bind("castToType"))),
-                                hasSourceExpression(cxxThisExpr(hasType(
-                                    type(anything()).bind("thisType")))))))
-                     .bind("member")),
-          callee(cxxMethodDecl(isVirtual()))),
-      this);
-}
-
-void ParentVirtualCallCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Member = Result.Nodes.getNodeAs<MemberExpr>("member");
-  assert(Member);
-
-  if (!Member->getQualifier())
-    return;
-
-  const auto *MemberDecl = cast<CXXMethodDecl>(Member->getMemberDecl());
-
-  const auto *ThisTypePtr = Result.Nodes.getNodeAs<PointerType>("thisType");
-  assert(ThisTypePtr);
-
-  const auto *ThisType = ThisTypePtr->getPointeeCXXRecordDecl();
-  assert(ThisType);
-
-  const auto *CastToTypePtr = Result.Nodes.getNodeAs<Type>("castToType");
-  assert(CastToTypePtr);
-
-  const auto *CastToType = CastToTypePtr->getAsCXXRecordDecl();
-  assert(CastToType);
-
-  if (isParentOf(*CastToType, *ThisType))
-    return;
-
-  const BasesVector Parents =
-      getParentsByGrandParent(*CastToType, *ThisType, *MemberDecl);
-
-  if (Parents.empty())
-    return;
-
-  std::string ParentsStr;
-  ParentsStr.reserve(30 * Parents.size());
-  for (const CXXRecordDecl *Parent : Parents) {
-    if (!ParentsStr.empty())
-      ParentsStr.append(" or ");
-    ParentsStr.append("'").append(getNameAsString(Parent)).append("'");
-  }
-
-  assert(Member->getQualifierLoc().getSourceRange().getBegin().isValid());
-  auto Diag = diag(Member->getQualifierLoc().getSourceRange().getBegin(),
-                   "qualified name '%0' refers to a member overridden "
-                   "in subclass%1; did you mean %2?")
-              << getExprAsString(*Member, *Result.Context)
-              << (Parents.size() > 1 ? "es" : "") << ParentsStr;
-
-  // Propose a fix if there's only one parent class...
-  if (Parents.size() == 1 &&
-      // ...unless parent class is templated
-      !isa<ClassTemplateSpecializationDecl>(Parents.front()))
-    Diag << FixItHint::CreateReplacement(
-        Member->getQualifierLoc().getSourceRange(),
-        getNameAsString(Parents.front()) + "::");
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

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

@@ -1,35 +0,0 @@
-//===--- ParentVirtualCallCheck.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_PARENTVIRTUALCALLCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_PARENTVIRTUALCALLCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds calls to grand..-parent virtual methods instead of parent's.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-parent-virtual-call.html
-class ParentVirtualCallCheck : public ClangTidyCheck {
-public:
-  ParentVirtualCallCheck(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_PARENTVIRTUALCALLCHECK_H

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

@@ -1,36 +0,0 @@
-//===--- SizeofContainerCheck.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_SIZEOFCONTAINERCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIZEOFCONTAINERCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Find usages of sizeof on expressions of STL container types. Most likely the
-/// user wanted to use `.size()` instead.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-sizeof-container.html
-class SizeofContainerCheck : public ClangTidyCheck {
-public:
-  SizeofContainerCheck(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_SIZEOFCONTAINERCHECK_H

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

@@ -1,41 +0,0 @@
-//===--- SizeofExpressionCheck.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_SIZEOFEXPRESSIONCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIZEOFEXPRESSIONCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Find suspicious usages of sizeof expression.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-sizeof-expression.html
-class SizeofExpressionCheck : public ClangTidyCheck {
-public:
-  SizeofExpressionCheck(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 WarnOnSizeOfConstant;
-  const bool WarnOnSizeOfIntegerExpression;
-  const bool WarnOnSizeOfThis;
-  const bool WarnOnSizeOfCompareToConstant;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIZEOFEXPRESSIONCHECK_H

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

@@ -18,11 +18,9 @@ namespace clang {
 namespace tidy {
 namespace bugprone {
 
-namespace {
 AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) {
   return Node.getValue().getZExtValue() > N;
 }
-} // namespace
 
 StringConstructorCheck::StringConstructorCheck(StringRef Name,
                                                ClangTidyContext *Context)

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

@@ -1,35 +0,0 @@
-//===--- StringLiteralWithEmbeddedNulCheck.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_STRINGLITERALWITHEMBEDDEDNULCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGLITERALWITHEMBEDDEDNULCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Find suspicious string literals with embedded NUL characters.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-string-literal-with-embedded-nul.html
-class StringLiteralWithEmbeddedNulCheck : public ClangTidyCheck {
-public:
-  StringLiteralWithEmbeddedNulCheck(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_STRINGLITERALWITHEMBEDDEDNULCHECK_H

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

@@ -1,39 +0,0 @@
-//===--- SuspiciousEnumUsageCheck.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_SUSPICIOUSENUMUSAGECHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSENUMUSAGECHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// The checker detects various cases when an enum is probably misused (as a
-/// bitmask).
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-enum-usage.html
-class SuspiciousEnumUsageCheck : public ClangTidyCheck {
-public:
-  SuspiciousEnumUsageCheck(StringRef Name, ClangTidyContext *Context);
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-
-private:
-  void checkSuspiciousBitmaskUsage(const Expr*, const EnumDecl*);
-  const bool StrictMode;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSENUMUSAGECHECK_H

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

@@ -1,36 +0,0 @@
-//===--- SuspiciousSemicolonCheck.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_SUSPICIOUSSEMICOLONCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSEMICOLONCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// This check finds semicolon that modifies the meaning of the program
-/// unintendedly.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-semicolon.html
-class SuspiciousSemicolonCheck : public ClangTidyCheck {
-public:
-  SuspiciousSemicolonCheck(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_SUSPICIOUSSEMICOLONCHECK_H

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

@@ -1,40 +0,0 @@
-//===--- SuspiciousStringCompareCheck.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_SUSPICIOUSSTRINGCOMPARECHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSTRINGCOMPARECHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Find suspicious calls to string compare functions.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-suspicious-string-compare.html
-class SuspiciousStringCompareCheck : public ClangTidyCheck {
-public:
-  SuspiciousStringCompareCheck(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 WarnOnImplicitComparison;
-  const bool WarnOnLogicalNotComparison;
-  const std::string StringCompareLikeFunctions;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSTRINGCOMPARECHECK_H

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

@@ -1,49 +0,0 @@
-//===--- TerminatingContinueCheck.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 "TerminatingContinueCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Lex/Lexer.h"
-#include "clang/Tooling/FixIt.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-void TerminatingContinueCheck::registerMatchers(MatchFinder *Finder) {
-  const auto doWithFalse =
-      doStmt(hasCondition(ignoringImpCasts(
-                 anyOf(cxxBoolLiteral(equals(false)), integerLiteral(equals(0)),
-                       cxxNullPtrLiteralExpr(), gnuNullExpr()))),
-             equalsBoundNode("closestLoop"));
-
-  Finder->addMatcher(
-      continueStmt(hasAncestor(stmt(anyOf(forStmt(), whileStmt(),
-                                          cxxForRangeStmt(), doStmt()))
-                                   .bind("closestLoop")),
-                   hasAncestor(doWithFalse))
-          .bind("continue"),
-      this);
-}
-
-void TerminatingContinueCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *ContStmt = Result.Nodes.getNodeAs<ContinueStmt>("continue");
-
-  auto Diag =
-      diag(ContStmt->getLocStart(),
-           "'continue' in loop with false condition is equivalent to 'break'")
-      << tooling::fixit::createReplacement(*ContStmt, "break");
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- TerminatingContinueCheck.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_TERMINATINGCONTINUECHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_TERMINATINGCONTINUECHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Checks if a 'continue' statement terminates the loop (i.e. the loop has
-///	a condition which always evaluates to false).
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-terminating-continue.html
-class TerminatingContinueCheck : public ClangTidyCheck {
-public:
-  TerminatingContinueCheck(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_TERMINATINGCONTINUECHECK_H

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

@@ -1,52 +0,0 @@
-//===--- ThrowKeywordMissingCheck.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 "ThrowKeywordMissingCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-void ThrowKeywordMissingCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  auto CtorInitializerList =
-      cxxConstructorDecl(hasAnyConstructorInitializer(anything()));
-
-  Finder->addMatcher(
-      expr(anyOf(cxxFunctionalCastExpr(), cxxBindTemporaryExpr(),
-                 cxxTemporaryObjectExpr()),
-           hasType(cxxRecordDecl(
-               isSameOrDerivedFrom(matchesName("[Ee]xception|EXCEPTION")))),
-           unless(anyOf(hasAncestor(stmt(
-                            anyOf(cxxThrowExpr(), callExpr(), returnStmt()))),
-                        hasAncestor(varDecl()),
-                        allOf(hasAncestor(CtorInitializerList),
-                              unless(hasAncestor(cxxCatchStmt()))))))
-          .bind("temporary-exception-not-thrown"),
-      this); 
-}
-
-void ThrowKeywordMissingCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *TemporaryExpr =
-      Result.Nodes.getNodeAs<Expr>("temporary-exception-not-thrown");
-
-  diag(TemporaryExpr->getLocStart(), "suspicious exception object created but "
-                                     "not thrown; did you mean 'throw %0'?")
-      << TemporaryExpr->getType().getBaseTypeIdentifier()->getName();
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- ThrowKeywordMissingCheck.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_THROWKEYWORDMISSINGCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_THROWKEYWORDMISSINGCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Emits a warning about temporary objects whose type is (or is derived from) a
-/// class that has 'EXCEPTION', 'Exception' or 'exception' in its name.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-throw-keyword-missing.html
-class ThrowKeywordMissingCheck : public ClangTidyCheck {
-public:
-  ThrowKeywordMissingCheck(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_THROWKEYWORDMISSINGCHECK_H

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

@@ -1,84 +0,0 @@
-//===--- UndelegatedConstructorCheck.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 "UndelegatedConstructorCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-namespace {
-AST_MATCHER_P(Stmt, ignoringTemporaryExpr,
-              ast_matchers::internal::Matcher<Stmt>, InnerMatcher) {
-  const Stmt *E = &Node;
-  for (;;) {
-    // Temporaries with non-trivial dtors.
-    if (const auto *EWC = dyn_cast<ExprWithCleanups>(E))
-      E = EWC->getSubExpr();
-    // Temporaries with zero or more than two ctor arguments.
-    else if (const auto *BTE = dyn_cast<CXXBindTemporaryExpr>(E))
-      E = BTE->getSubExpr();
-    // Temporaries with exactly one ctor argument.
-    else if (const auto *FCE = dyn_cast<CXXFunctionalCastExpr>(E))
-      E = FCE->getSubExpr();
-    else
-      break;
-  }
-
-  return InnerMatcher.matches(*E, Finder, Builder);
-}
-
-// Finds a node if it's a base of an already bound node.
-AST_MATCHER_P(CXXRecordDecl, baseOfBoundNode, std::string, ID) {
-  return Builder->removeBindings(
-      [&](const ast_matchers::internal::BoundNodesMap &Nodes) {
-        const auto *Derived = Nodes.getNodeAs<CXXRecordDecl>(ID);
-        return Derived != &Node && !Derived->isDerivedFrom(&Node);
-      });
-}
-} // namespace
-
-void UndelegatedConstructorCheck::registerMatchers(MatchFinder *Finder) {
-  // We look for calls to constructors of the same type in constructors. To do
-  // this we have to look through a variety of nodes that occur in the path,
-  // depending on the type's destructor and the number of arguments on the
-  // constructor call, this is handled by ignoringTemporaryExpr. Ignore template
-  // instantiations to reduce the number of duplicated warnings.
-  //
-  // Only register the matchers for C++11; the functionality currently does not
-  // provide any benefit to other languages, despite being benign.
-  if (!getLangOpts().CPlusPlus11)
-    return;
-
-  Finder->addMatcher(
-      compoundStmt(
-          hasParent(
-              cxxConstructorDecl(ofClass(cxxRecordDecl().bind("parent")))),
-          forEach(ignoringTemporaryExpr(
-              cxxConstructExpr(hasDeclaration(cxxConstructorDecl(ofClass(
-                                   cxxRecordDecl(baseOfBoundNode("parent"))))))
-                  .bind("construct"))),
-          unless(isInTemplateInstantiation())),
-      this);
-}
-
-void UndelegatedConstructorCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("construct");
-  diag(E->getLocStart(), "did you intend to call a delegated constructor? "
-                         "A temporary object is created here instead");
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- UndelegatedConstructorCheck.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_MISC_UNDELEGATEDCONSTRUCTOR_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNDELEGATEDCONSTRUCTOR_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds creation of temporary objects in constructors that look like a
-/// function call to another constructor of the same class.
-///
-/// The user most likely meant to use a delegating constructor or base class
-/// initializer.
-class UndelegatedConstructorCheck : public ClangTidyCheck {
-public:
-  UndelegatedConstructorCheck(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_MISC_UNDELEGATEDCONSTRUCTOR_H

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

@@ -1,94 +0,0 @@
-//===--- UnusedRaiiCheck.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 "UnusedRaiiCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-namespace {
-AST_MATCHER(CXXRecordDecl, hasNonTrivialDestructor) {
-  // TODO: If the dtor is there but empty we don't want to warn either.
-  return Node.hasDefinition() && Node.hasNonTrivialDestructor();
-}
-} // namespace
-
-void UnusedRaiiCheck::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;
-
-  // Look for temporaries that are constructed in-place and immediately
-  // destroyed. Look for temporaries created by a functional cast but not for
-  // those returned from a call.
-  auto BindTemp =
-      cxxBindTemporaryExpr(unless(has(ignoringParenImpCasts(callExpr()))))
-          .bind("temp");
-  Finder->addMatcher(
-      exprWithCleanups(unless(isInTemplateInstantiation()),
-                       hasParent(compoundStmt().bind("compound")),
-                       hasType(cxxRecordDecl(hasNonTrivialDestructor())),
-                       anyOf(has(ignoringParenImpCasts(BindTemp)),
-                             has(ignoringParenImpCasts(cxxFunctionalCastExpr(
-                                 has(ignoringParenImpCasts(BindTemp)))))))
-          .bind("expr"),
-      this);
-}
-
-void UnusedRaiiCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
-
-  // We ignore code expanded from macros to reduce the number of false
-  // positives.
-  if (E->getLocStart().isMacroID())
-    return;
-
-  // Don't emit a warning for the last statement in the surrounding compund
-  // statement.
-  const auto *CS = Result.Nodes.getNodeAs<CompoundStmt>("compound");
-  if (E == CS->body_back())
-    return;
-
-  // Emit a warning.
-  auto D = diag(E->getLocStart(), "object destroyed immediately after "
-                                  "creation; did you mean to name the object?");
-  const char *Replacement = " give_me_a_name";
-
-  // If this is a default ctor we have to remove the parens or we'll introduce a
-  // most vexing parse.
-  const auto *BTE = Result.Nodes.getNodeAs<CXXBindTemporaryExpr>("temp");
-  if (const auto *TOE = dyn_cast<CXXTemporaryObjectExpr>(BTE->getSubExpr()))
-    if (TOE->getNumArgs() == 0) {
-      D << FixItHint::CreateReplacement(
-          CharSourceRange::getTokenRange(TOE->getParenOrBraceRange()),
-          Replacement);
-      return;
-    }
-
-  // Otherwise just suggest adding a name. To find the place to insert the name
-  // find the first TypeLoc in the children of E, which always points to the
-  // written type.
-  auto Matches =
-      match(expr(hasDescendant(typeLoc().bind("t"))), *E, *Result.Context);
-  const auto *TL = selectFirst<TypeLoc>("t", Matches);
-  D << FixItHint::CreateInsertion(
-      Lexer::getLocForEndOfToken(TL->getLocEnd(), 0, *Result.SourceManager,
-                                 getLangOpts()),
-      Replacement);
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

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

@@ -1,35 +0,0 @@
-//===--- UnusedRaiiCheck.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_UNUSEDRAIICHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRAIICHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Finds temporaries that look like RAII objects.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-unused-raii.html
-class UnusedRaiiCheck : public ClangTidyCheck {
-public:
-  UnusedRaiiCheck(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_UNUSEDRAIICHECK_H

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

@@ -1,100 +0,0 @@
-//===--- UnusedReturnValueCheck.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 "UnusedReturnValueCheck.h"
-#include "../utils/OptionsUtils.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-using namespace clang::ast_matchers::internal;
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-namespace {
-
-// Matches functions that are instantiated from a class template member function
-// matching InnerMatcher. Functions not instantiated from a class template
-// member function are matched directly with InnerMatcher.
-AST_MATCHER_P(FunctionDecl, isInstantiatedFrom, Matcher<FunctionDecl>,
-              InnerMatcher) {
-  FunctionDecl *InstantiatedFrom = Node.getInstantiatedFromMemberFunction();
-  return InnerMatcher.matches(InstantiatedFrom ? *InstantiatedFrom : Node,
-                              Finder, Builder);
-}
-
-} // namespace
-
-UnusedReturnValueCheck::UnusedReturnValueCheck(llvm::StringRef Name,
-                                               ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      CheckedFunctions(Options.get("CheckedFunctions",
-                                   "::std::async;"
-                                   "::std::launder;"
-                                   "::std::remove;"
-                                   "::std::remove_if;"
-                                   "::std::unique;"
-                                   "::std::unique_ptr::release;"
-                                   "::std::basic_string::empty;"
-                                   "::std::vector::empty")) {}
-
-void UnusedReturnValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "CheckedFunctions", CheckedFunctions);
-}
-
-void UnusedReturnValueCheck::registerMatchers(MatchFinder *Finder) {
-  auto FunVec = utils::options::parseStringList(CheckedFunctions);
-  auto MatchedCallExpr = expr(ignoringImplicit(ignoringParenImpCasts(
-      callExpr(callee(functionDecl(
-                   // Don't match void overloads of checked functions.
-                   unless(returns(voidType())),
-                   isInstantiatedFrom(hasAnyName(
-                       std::vector<StringRef>(FunVec.begin(), FunVec.end()))))))
-          .bind("match"))));
-
-  auto UnusedInCompoundStmt =
-      compoundStmt(forEach(MatchedCallExpr),
-                   // The checker can't currently differentiate between the
-                   // return statement and other statements inside GNU statement
-                   // expressions, so disable the checker inside them to avoid
-                   // false positives.
-                   unless(hasParent(stmtExpr())));
-  auto UnusedInIfStmt =
-      ifStmt(eachOf(hasThen(MatchedCallExpr), hasElse(MatchedCallExpr)));
-  auto UnusedInWhileStmt = whileStmt(hasBody(MatchedCallExpr));
-  auto UnusedInDoStmt = doStmt(hasBody(MatchedCallExpr));
-  auto UnusedInForStmt =
-      forStmt(eachOf(hasLoopInit(MatchedCallExpr),
-                     hasIncrement(MatchedCallExpr), hasBody(MatchedCallExpr)));
-  auto UnusedInRangeForStmt = cxxForRangeStmt(hasBody(MatchedCallExpr));
-  auto UnusedInCaseStmt = switchCase(forEach(MatchedCallExpr));
-
-  Finder->addMatcher(
-      stmt(anyOf(UnusedInCompoundStmt, UnusedInIfStmt, UnusedInWhileStmt,
-                 UnusedInDoStmt, UnusedInForStmt, UnusedInRangeForStmt,
-                 UnusedInCaseStmt)),
-      this);
-}
-
-void UnusedReturnValueCheck::check(const MatchFinder::MatchResult &Result) {
-  if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("match")) {
-    diag(Matched->getLocStart(),
-         "the value returned by this function should be used")
-        << Matched->getSourceRange();
-    diag(Matched->getLocStart(),
-         "cast the expression to void to silence this warning",
-         DiagnosticIDs::Note);
-  }
-}
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang

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

@@ -1,39 +0,0 @@
-//===--- UnusedReturnValueCheck.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_UNUSEDRETURNVALUECHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRETURNVALUECHECK_H
-
-#include "../ClangTidy.h"
-#include <string>
-
-namespace clang {
-namespace tidy {
-namespace bugprone {
-
-/// Detects function calls where the return value is unused.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-unused-return-value.html
-class UnusedReturnValueCheck : public ClangTidyCheck {
-public:
-  UnusedReturnValueCheck(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:
-  std::string CheckedFunctions;
-};
-
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRETURNVALUECHECK_H

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

@@ -19,13 +19,11 @@ namespace clang {
 namespace tidy {
 namespace bugprone {
 
-namespace {
 AST_MATCHER(CXXMethodDecl, isStatic) { return Node.isStatic(); }
 
 AST_MATCHER(CXXMethodDecl, isOverloadedOperator) {
   return Node.isOverloadedOperator();
 }
-} // namespace
 
 /// Finds out if the given method overrides some method.
 static bool isOverrideMethod(const CXXMethodDecl *MD) {

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

@@ -21,7 +21,6 @@
 #include "FloatLoopCounter.h"
 #include "LimitedRandomnessCheck.h"
 #include "PostfixOperatorCheck.h"
-#include "ProperlySeededRandomGeneratorCheck.h"
 #include "SetLongJmpCheck.h"
 #include "StaticObjectExceptionCheck.h"
 #include "StrToNumCheck.h"
@@ -59,8 +58,6 @@ public:
         "cert-err61-cpp");
     // MSC
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc50-cpp");
-    CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(
-        "cert-msc51-cpp");
 
     // C checkers
     // DCL
@@ -75,8 +72,6 @@ public:
     CheckFactories.registerCheck<StrToNumCheck>("cert-err34-c");
     // MSC
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc30-c");
-    CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(
-        "cert-msc32-c");
   }
 };
 

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

@@ -7,7 +7,6 @@ add_clang_library(clangTidyCERTModule
   FloatLoopCounter.cpp
   LimitedRandomnessCheck.cpp
   PostfixOperatorCheck.cpp
-  ProperlySeededRandomGeneratorCheck.cpp
   SetLongJmpCheck.cpp
   StaticObjectExceptionCheck.cpp
   StrToNumCheck.cpp

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

@@ -1,124 +0,0 @@
-//===--- ProperlySeededRandomGeneratorCheck.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 "ProperlySeededRandomGeneratorCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "llvm/ADT/STLExtras.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-ProperlySeededRandomGeneratorCheck::ProperlySeededRandomGeneratorCheck(
-    StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      RawDisallowedSeedTypes(
-          Options.get("DisallowedSeedTypes", "time_t,std::time_t")) {
-  StringRef(RawDisallowedSeedTypes).split(DisallowedSeedTypes, ',');
-}
-
-void ProperlySeededRandomGeneratorCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "DisallowedSeedTypes", RawDisallowedSeedTypes);
-}
-
-void ProperlySeededRandomGeneratorCheck::registerMatchers(MatchFinder *Finder) {
-  auto RandomGeneratorEngineDecl = cxxRecordDecl(hasAnyName(
-      "::std::linear_congruential_engine", "::std::mersenne_twister_engine",
-      "::std::subtract_with_carry_engine", "::std::discard_block_engine",
-      "::std::independent_bits_engine", "::std::shuffle_order_engine"));
-  auto RandomGeneratorEngineTypeMatcher = hasType(hasUnqualifiedDesugaredType(
-      recordType(hasDeclaration(RandomGeneratorEngineDecl))));
-
-  // std::mt19937 engine;
-  // engine.seed();
-  //        ^
-  // engine.seed(1);
-  //        ^
-  // const int x = 1;
-  // engine.seed(x);
-  //        ^
-  Finder->addMatcher(
-      cxxMemberCallExpr(
-          has(memberExpr(has(declRefExpr(RandomGeneratorEngineTypeMatcher)),
-                         member(hasName("seed")),
-                         unless(hasDescendant(cxxThisExpr())))))
-          .bind("seed"),
-      this);
-
-  // std::mt19937 engine;
-  //              ^
-  // std::mt19937 engine(1);
-  //              ^
-  // const int x = 1;
-  // std::mt19937 engine(x);
-  //              ^
-  Finder->addMatcher(
-      cxxConstructExpr(RandomGeneratorEngineTypeMatcher).bind("ctor"), this);
-
-  // srand();
-  // ^
-  // const int x = 1;
-  // srand(x);
-  // ^
-  Finder->addMatcher(
-      callExpr(callee(functionDecl(hasAnyName("::srand", "::std::srand"))))
-          .bind("srand"),
-      this);
-}
-
-void ProperlySeededRandomGeneratorCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructExpr>("ctor");
-  if (Ctor)
-    checkSeed(Result, Ctor);
-
-  const auto *Func = Result.Nodes.getNodeAs<CXXMemberCallExpr>("seed");
-  if (Func)
-    checkSeed(Result, Func);
-
-  const auto *Srand = Result.Nodes.getNodeAs<CallExpr>("srand");
-  if (Srand)
-    checkSeed(Result, Srand);
-}
-
-template <class T>
-void ProperlySeededRandomGeneratorCheck::checkSeed(
-    const MatchFinder::MatchResult &Result, const T *Func) {
-  if (Func->getNumArgs() == 0 || Func->getArg(0)->isDefaultArgument()) {
-    diag(Func->getExprLoc(),
-         "random number generator seeded with a default argument will generate "
-         "a predictable sequence of values");
-    return;
-  }
-
-  llvm::APSInt Value;
-  if (Func->getArg(0)->EvaluateAsInt(Value, *Result.Context)) {
-    diag(Func->getExprLoc(),
-         "random number generator seeded with a constant value will generate a "
-         "predictable sequence of values");
-    return;
-  }
-
-  const std::string SeedType(
-      Func->getArg(0)->IgnoreCasts()->getType().getAsString());
-  if (llvm::find(DisallowedSeedTypes, SeedType) != DisallowedSeedTypes.end()) {
-    diag(Func->getExprLoc(),
-         "random number generator seeded with a disallowed source of seed "
-         "value will generate a predictable sequence of values");
-    return;
-  }
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

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

@@ -1,47 +0,0 @@
-//===--- ProperlySeededRandomGeneratorCheck.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_PROPERLY_SEEDED_RANDOM_GENERATOR_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_PROPERLY_SEEDED_RANDOM_GENERATOR_H
-
-#include "../ClangTidy.h"
-#include <string>
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// Random number generator must be seeded properly.
-///
-/// A random number generator initialized with default value or a
-/// constant expression is a security vulnerability.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-properly-seeded-random-generator.html
-class ProperlySeededRandomGeneratorCheck : public ClangTidyCheck {
-public:
-  ProperlySeededRandomGeneratorCheck(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:
-  template <class T>
-  void checkSeed(const ast_matchers::MatchFinder::MatchResult &Result,
-                 const T *Func);
-
-  std::string RawDisallowedSeedTypes;
-  SmallVector<StringRef, 5> DisallowedSeedTypes;
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_PROPERLY_SEEDED_RANDOM_GENERATOR_H

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

@@ -1,57 +0,0 @@
-//===--- AvoidGotoCheck.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 "AvoidGotoCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-namespace {
-AST_MATCHER(GotoStmt, isForwardJumping) {
-  return Node.getLocStart() < Node.getLabel()->getLocStart();
-}
-} // namespace
-
-void AvoidGotoCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  // TODO: This check does not recognize `IndirectGotoStmt` which is a
-  // GNU extension. These must be matched separately and an AST matcher
-  // is currently missing for them.
-
-  // Check if the 'goto' is used for control flow other than jumping
-  // out of a nested loop.
-  auto Loop = stmt(anyOf(forStmt(), cxxForRangeStmt(), whileStmt(), doStmt()));
-  auto NestedLoop =
-      stmt(anyOf(forStmt(hasAncestor(Loop)), cxxForRangeStmt(hasAncestor(Loop)),
-                 whileStmt(hasAncestor(Loop)), doStmt(hasAncestor(Loop))));
-
-  Finder->addMatcher(gotoStmt(anyOf(unless(hasAncestor(NestedLoop)),
-                                    unless(isForwardJumping())))
-                         .bind("goto"),
-                     this);
-}
-
-void AvoidGotoCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Goto = Result.Nodes.getNodeAs<GotoStmt>("goto");
-
-  diag(Goto->getGotoLoc(), "avoid using 'goto' for flow control")
-      << Goto->getSourceRange();
-  diag(Goto->getLabel()->getLocStart(), "label defined here",
-       DiagnosticIDs::Note);
-}
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- AvoidGotoCheck.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_AVOIDGOTOCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDGOTOCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// The usage of ``goto`` for control flow is error prone and should be replaced
-/// with looping constructs. Only forward jumps in nested loops are accepted.
-//
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-avoid-goto.html
-class AvoidGotoCheck : public ClangTidyCheck {
-public:
-  AvoidGotoCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDGOTOCHECK_H

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

@@ -1,10 +1,8 @@
 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyCppCoreGuidelinesModule
-  AvoidGotoCheck.cpp
   CppCoreGuidelinesTidyModule.cpp
   InterfacesGlobalInitCheck.cpp
-  NarrowingConversionsCheck.cpp
   NoMallocCheck.cpp
   OwningMemoryCheck.cpp
   ProBoundsArrayToPointerDecayCheck.cpp

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

@@ -11,9 +11,7 @@
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../misc/UnconventionalAssignOperatorCheck.h"
-#include "AvoidGotoCheck.h"
 #include "InterfacesGlobalInitCheck.h"
-#include "NarrowingConversionsCheck.h"
 #include "NoMallocCheck.h"
 #include "OwningMemoryCheck.h"
 #include "ProBoundsArrayToPointerDecayCheck.h"
@@ -37,12 +35,8 @@ namespace cppcoreguidelines {
 class CppCoreGuidelinesModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    CheckFactories.registerCheck<AvoidGotoCheck>(
-        "cppcoreguidelines-avoid-goto");
     CheckFactories.registerCheck<InterfacesGlobalInitCheck>(
         "cppcoreguidelines-interfaces-global-init");
-    CheckFactories.registerCheck<NarrowingConversionsCheck>(
-        "cppcoreguidelines-narrowing-conversions");
     CheckFactories.registerCheck<NoMallocCheck>("cppcoreguidelines-no-malloc");
     CheckFactories.registerCheck<OwningMemoryCheck>(
         "cppcoreguidelines-owning-memory");

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

@@ -1,70 +0,0 @@
-//===--- NarrowingConversionsCheck.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 "NarrowingConversionsCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-// FIXME: Check double -> float truncation. Pay attention to casts:
-void NarrowingConversionsCheck::registerMatchers(MatchFinder *Finder) {
-  // ceil() and floor() are guaranteed to return integers, even though the type
-  // is not integral.
-  const auto IsCeilFloorCall = callExpr(callee(functionDecl(
-      hasAnyName("::ceil", "::std::ceil", "::floor", "::std::floor"))));
-
-  const auto IsFloatExpr =
-      expr(hasType(realFloatingPointType()), unless(IsCeilFloorCall));
-
-  // casts:
-  //   i = 0.5;
-  //   void f(int); f(0.5);
-  Finder->addMatcher(implicitCastExpr(hasImplicitDestinationType(isInteger()),
-                                      hasSourceExpression(IsFloatExpr),
-                                      unless(hasParent(castExpr())),
-                                      unless(isInTemplateInstantiation()))
-                         .bind("cast"),
-                     this);
-
-  // Binary operators:
-  //   i += 0.5;
-  Finder->addMatcher(
-      binaryOperator(isAssignmentOperator(),
-                     // The `=` case generates an implicit cast which is covered
-                     // by the previous matcher.
-                     unless(hasOperatorName("=")),
-                     hasLHS(hasType(isInteger())), hasRHS(IsFloatExpr),
-                     unless(isInTemplateInstantiation()))
-          .bind("op"),
-      this);
-}
-
-void NarrowingConversionsCheck::check(const MatchFinder::MatchResult &Result) {
-  if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("op")) {
-    if (Op->getLocStart().isMacroID())
-      return;
-    diag(Op->getOperatorLoc(), "narrowing conversion from %0 to %1")
-        << Op->getRHS()->getType() << Op->getLHS()->getType();
-    return;
-  }
-  const auto *Cast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast");
-  if (Cast->getLocStart().isMacroID())
-    return;
-  diag(Cast->getExprLoc(), "narrowing conversion from %0 to %1")
-      << Cast->getSubExpr()->getType() << Cast->getType();
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,37 +0,0 @@
-//===--- NarrowingConversionsCheck.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_NARROWING_CONVERSIONS_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NARROWING_CONVERSIONS_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// Checks for narrowing conversions, e.g:
-///   int i = 0;
-///   i += 0.1;
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-narrowing-conversions.html
-class NarrowingConversionsCheck : public ClangTidyCheck {
-public:
-  NarrowingConversionsCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NARROWING_CONVERSIONS_H

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

@@ -1,4 +1,4 @@
-//===--- NoMallocCheck.cpp - clang-tidy------------------------------------===//
+//===--- NoMallocCheck.cpp - clang-tidy------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //

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

@@ -17,7 +17,6 @@ namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
-namespace {
 AST_MATCHER_P(CXXForRangeStmt, hasRangeBeginEndStmt,
               ast_matchers::internal::Matcher<DeclStmt>, InnerMatcher) {
   for (const DeclStmt *Stmt : {Node.getBeginStmt(), Node.getEndStmt()})
@@ -47,7 +46,6 @@ AST_MATCHER_P(Expr, hasParentIgnoringImpCasts,
 
   return InnerMatcher.matches(*E, Finder, Builder);
 }
-} // namespace
 
 void ProBoundsArrayToPointerDecayCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)