Added Stacker Reid Spencer's contributions.

llvm-svn: 10498

clang-tools-extra/.arcconfig

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

clang-tools-extra/.gitignore

@@ -1,32 +0,0 @@
-#==============================================================================#
-# This file specifies intentionally untracked files that git should ignore.
-# See: http://www.kernel.org/pub/software/scm/git/docs/gitignore.html
-#
-# This file is intentionally different from the output of `git svn show-ignore`,
-# as most of those are useless.
-#==============================================================================#
-
-#==============================================================================#
-# File extensions to be ignored anywhere in the tree.
-#==============================================================================#
-# Temp files created by most text editors.
-*~
-# Merge files created by git.
-*.orig
-# Byte compiled python modules.
-*.pyc
-# vim swap files
-.*.swp
-.sw?
-
-#==============================================================================#
-# Explicit files to ignore (only matches one).
-#==============================================================================#
-cscope.files
-cscope.out
-.clang_complete
-
-#==============================================================================#
-# Directories to ignore (do not add trailing '/'s, they skip symlinks).
-#==============================================================================#
-docs/_build

clang-tools-extra/CMakeLists.txt

@@ -1,25 +0,0 @@
-add_subdirectory(clang-apply-replacements)
-add_subdirectory(clang-rename)
-add_subdirectory(modularize)
-if(CLANG_ENABLE_STATIC_ANALYZER)
-add_subdirectory(clang-tidy)
-endif()
-
-add_subdirectory(clang-query)
-add_subdirectory(include-fixer)
-add_subdirectory(pp-trace)
-add_subdirectory(tool-template)
-
-# Add the common testsuite after all the tools.
-# TODO: Support tests with more granularity when features are off?
-if(CLANG_ENABLE_STATIC_ANALYZER AND CLANG_INCLUDE_TESTS)
-add_subdirectory(test)
-add_subdirectory(unittests)
-endif()
-
-option(CLANG_TOOLS_EXTRA_INCLUDE_DOCS "Generate build targets for the Clang Extra Tools docs."
-  ${LLVM_INCLUDE_DOCS})
-if( CLANG_TOOLS_EXTRA_INCLUDE_DOCS )
-  add_subdirectory(docs)
-endif()
-

clang-tools-extra/CODE_OWNERS.TXT

@@ -1,21 +0,0 @@
-This file is a list of the people responsible for ensuring that patches for a
-particular tool are reviewed, either by themself or by someone else. They are
-also the gatekeepers for their part of Clang, with the final word on what goes
-in or not.
-
-The list is sorted by surname and formatted to allow easy grepping and
-beautification by scripts.  The fields are: name (N), email (E), web-address
-(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
-(S).
-
-N: Peter Collingbourne
-E: peter@pcc.me.uk
-D: clang-query
-
-N: Manuel Klimek
-E: klimek@google.com
-D: clang-rename, all parts of clang-tools-extra not covered by someone else
-
-N: Alexander Kornienko
-E: alexfh@google.com
-D: clang-tidy

clang-tools-extra/LICENSE.TXT

@@ -1,62 +0,0 @@
-==============================================================================
-LLVM Release License
-==============================================================================
-University of Illinois/NCSA
-Open Source License
-
-Copyright (c) 2007-2016 University of Illinois at Urbana-Champaign.
-All rights reserved.
-
-Developed by:
-
-    LLVM Team
-
-    University of Illinois at Urbana-Champaign
-
-    http://llvm.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal with
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimers.
-
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimers in the
-      documentation and/or other materials provided with the distribution.
-
-    * Neither the names of the LLVM Team, University of Illinois at
-      Urbana-Champaign, nor the names of its contributors may be used to
-      endorse or promote products derived from this Software without specific
-      prior written permission.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-SOFTWARE.
-
-==============================================================================
-The LLVM software contains code written by third parties.  Such software will
-have its own individual LICENSE.TXT file in the directory in which it appears.
-This file will describe the copyrights, license, and restrictions which apply
-to that code.
-
-The disclaimer of warranty in the University of Illinois Open Source License
-applies to all code in the LLVM Distribution, and nothing in any of the
-other licenses gives permission to use the names of the LLVM Team or the
-University of Illinois to endorse or promote products derived from this
-Software.
-
-The following pieces of software have additional or alternate copyrights,
-licenses, and/or restrictions:
-
-Program             Directory
--------             ---------
-clang-tidy          clang-tidy/cert

clang-tools-extra/README.txt

@@ -1,22 +0,0 @@
-//===----------------------------------------------------------------------===//
-// Clang Tools repository
-//===----------------------------------------------------------------------===//
-
-Welcome to the repository of extra Clang Tools.  This repository holds tools
-that are developed as part of the LLVM compiler infrastructure project and the
-Clang frontend.  These tools are kept in a separate "extra" repository to
-allow lighter weight checkouts of the core Clang codebase.
-
-This repository is only intended to be checked out inside of a full LLVM+Clang
-tree, and in the 'tools/extra' subdirectory of the Clang checkout.
-
-All discussion regarding Clang, Clang-based tools, and code in this repository
-should be held using the standard Clang mailing lists:
-  http://lists.llvm.org/mailman/listinfo/cfe-dev
-
-Code review for this tree should take place on the standard Clang patch and
-commit lists:
-  http://lists.llvm.org/mailman/listinfo/cfe-commits
-
-If you find a bug in these tools, please file it in the LLVM bug tracker:
-  http://llvm.org/bugs/

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

@@ -1,19 +0,0 @@
-set(LLVM_LINK_COMPONENTS
-  Support
-  )
-
-add_clang_library(clangApplyReplacements
-  lib/Tooling/ApplyReplacements.cpp
-
-  LINK_LIBS
-  clangAST
-  clangBasic
-  clangRewrite
-  clangToolingCore
-  )
-
-include_directories(
-  ${CMAKE_CURRENT_SOURCE_DIR}
-  include
-  )
-add_subdirectory(tool)

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

@@ -1,140 +0,0 @@
-//===-- ApplyReplacements.h - Deduplicate and apply replacements -- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief This file provides the interface for deduplicating, detecting
-/// conflicts in, and applying collections of Replacements.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_APPLYREPLACEMENTS_H
-#define LLVM_CLANG_APPLYREPLACEMENTS_H
-
-#include "clang/Tooling/Refactoring.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/StringRef.h"
-#include <string>
-#include <system_error>
-#include <vector>
-
-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;
-
-/// \brief Collection of TranslationUnitReplacement files.
-typedef std::vector<std::string> TUReplacementFiles;
-
-/// \brief Map mapping file name to Replacements targeting that file.
-typedef llvm::DenseMap<const clang::FileEntry *,
-                       std::vector<clang::tooling::Replacement>>
-    FileToReplacementsMap;
-
-/// \brief Recursively descends through a directory structure rooted at \p
-/// Directory and attempts to deserialize *.yaml files as
-/// TranslationUnitReplacements. All docs that successfully deserialize are
-/// added to \p TUs.
-///
-/// Directories starting with '.' are ignored during traversal.
-///
-/// \param[in] Directory Directory to begin search for serialized
-/// TranslationUnitReplacements.
-/// \param[out] TUs Collection of all found and deserialized
-/// TranslationUnitReplacements.
-/// \param[out] TURFiles Collection of all TranslationUnitReplacement files
-/// found in \c Directory.
-/// \param[in] Diagnostics DiagnosticsEngine used for error output.
-///
-/// \returns An error_code indicating success or failure in navigating the
-/// directory structure.
-std::error_code
-collectReplacementsFromDirectory(const llvm::StringRef Directory,
-                                 TUReplacements &TUs,
-                                 TUReplacementFiles &TURFiles,
-                                 clang::DiagnosticsEngine &Diagnostics);
-
-/// \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 GroupedReplacements, value[i].getOffset() <=
-/// value[i+1].getOffset().
-///
-/// \param[in] TUs Collection of TranslationUnitReplacements 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 applied successfully.
-///          \li false If there were conflicts.
-bool mergeAndDeduplicate(const TUReplacements &TUs,
-                         FileToReplacementsMap &GroupedReplacements,
-                         clang::SourceManager &SM);
-
-/// \brief Apply all replacements in \c GroupedReplacements.
-///
-/// \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 \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.
-///
-/// \param[in] Files Replacement files to delete.
-/// \param[in] Diagnostics DiagnosticsEngine used for error output.
-///
-/// \returns \parblock
-///          \li true If all files have been deleted successfully.
-///          \li false If at least one or more failures occur when deleting
-/// files.
-bool deleteReplacementFiles(const TUReplacementFiles &Files,
-                            clang::DiagnosticsEngine &Diagnostics);
-
-} // end namespace replace
-} // end namespace clang
-
-#endif // LLVM_CLANG_APPLYREPLACEMENTS_H

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

@@ -1,260 +0,0 @@
-//===-- ApplyReplacements.cpp - Apply and deduplicate replacements --------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief This file provides the implementation for deduplicating, detecting
-/// conflicts in, and applying collections of Replacements.
-///
-/// FIXME: Use Diagnostics for output instead of llvm::errs().
-///
-//===----------------------------------------------------------------------===//
-#include "clang-apply-replacements/Tooling/ApplyReplacements.h"
-#include "clang/Basic/LangOptions.h"
-#include "clang/Basic/SourceManager.h"
-#include "clang/Format/Format.h"
-#include "clang/Lex/Lexer.h"
-#include "clang/Rewrite/Core/Rewriter.h"
-#include "clang/Tooling/ReplacementsYaml.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/Support/FileSystem.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Path.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace llvm;
-using namespace clang;
-
-
-static void eatDiagnostics(const SMDiagnostic &, void *) {}
-
-namespace clang {
-namespace replace {
-
-std::error_code
-collectReplacementsFromDirectory(const llvm::StringRef Directory,
-                                 TUReplacements &TUs,
-                                 TUReplacementFiles & TURFiles,
-                                 clang::DiagnosticsEngine &Diagnostics) {
-  using namespace llvm::sys::fs;
-  using namespace llvm::sys::path;
-
-  std::error_code ErrorCode;
-
-  for (recursive_directory_iterator I(Directory, ErrorCode), E;
-       I != E && !ErrorCode; I.increment(ErrorCode)) {
-    if (filename(I->path())[0] == '.') {
-      // Indicate not to descend into directories beginning with '.'
-      I.no_push();
-      continue;
-    }
-
-    if (extension(I->path()) != ".yaml")
-      continue;
-
-    TURFiles.push_back(I->path());
-
-    ErrorOr<std::unique_ptr<MemoryBuffer>> Out =
-        MemoryBuffer::getFile(I->path());
-    if (std::error_code BufferError = Out.getError()) {
-      errs() << "Error reading " << I->path() << ": " << BufferError.message()
-             << "\n";
-      continue;
-    }
-
-    yaml::Input YIn(Out.get()->getBuffer(), nullptr, &eatDiagnostics);
-    tooling::TranslationUnitReplacements TU;
-    YIn >> TU;
-    if (YIn.error()) {
-      // File doesn't appear to be a header change description. Ignore it.
-      continue;
-    }
-
-    // Only keep files that properly parse.
-    TUs.push_back(TU);
-  }
-
-  return ErrorCode;
-}
-
-/// \brief Dumps information for a sequence of conflicting Replacements.
-///
-/// \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);
-
-  // 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";
-    }
-  }
-}
-
-/// \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;
-
-  for (auto &FileAndReplacements : Replacements) {
-    const FileEntry *Entry = FileAndReplacements.first;
-    auto &Replacements = FileAndReplacements.second;
-    assert(Entry != nullptr && "No file entry!");
-
-    std::vector<tooling::Range> Conflicts;
-    tooling::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.
-      const FileEntry *Entry = SM.getFileManager().getFile(R.getFilePath());
-      if (!Entry && Warned.insert(R.getFilePath()).second) {
-        errs() << "Described file '" << R.getFilePath()
-               << "' doesn't exist. Ignoring...\n";
-        continue;
-      }
-      GroupedReplacements[Entry].push_back(R);
-    }
-  }
-
-  // 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 (!tooling::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 (Rewriter::const_buffer_iterator BufferI = Rewrites.buffer_begin(),
-                                       BufferE = Rewrites.buffer_end();
-       BufferI != BufferE; ++BufferI) {
-    const char *FileName =
-        Rewrites.getSourceMgr().getFileEntryForID(BufferI->first)->getName();
-
-    std::error_code EC;
-    llvm::raw_fd_ostream FileStream(FileName, EC, llvm::sys::fs::F_Text);
-    if (EC) {
-      errs() << "Warning: Could not write to " << EC.message() << "\n";
-      continue;
-    }
-    BufferI->second.write(FileStream);
-  }
-
-  return true;
-}
-
-bool deleteReplacementFiles(const TUReplacementFiles &Files,
-                            clang::DiagnosticsEngine &Diagnostics) {
-  bool Success = true;
-  for (const auto &Filename : Files) {
-    std::error_code Error = llvm::sys::fs::remove(Filename);
-    if (Error) {
-      Success = false;
-      // FIXME: Use Diagnostics for outputting errors.
-      errs() << "Error deleting file: " << Filename << "\n";
-      errs() << Error.message() << "\n";
-      errs() << "Please delete the file manually\n";
-    }
-  }
-  return Success;
-}
-
-} // end namespace replace
-} // end namespace clang

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

@@ -1,17 +0,0 @@
-set(LLVM_LINK_COMPONENTS
-  Support
-  )
-
-add_clang_executable(clang-apply-replacements
-  ClangApplyReplacementsMain.cpp
-  )
-target_link_libraries(clang-apply-replacements
-  clangApplyReplacements
-  clangBasic
-  clangFormat
-  clangRewrite
-  clangToolingCore
-  )
-
-install(TARGETS clang-apply-replacements
-  RUNTIME DESTINATION bin)

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

@@ -1,279 +0,0 @@
-//===-- ClangApplyReplacementsMain.cpp - Main file for the tool -----------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief This file provides the main function for the
-/// clang-apply-replacements tool.
-///
-//===----------------------------------------------------------------------===//
-
-#include "clang-apply-replacements/Tooling/ApplyReplacements.h"
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/DiagnosticOptions.h"
-#include "clang/Basic/SourceManager.h"
-#include "clang/Basic/Version.h"
-#include "clang/Format/Format.h"
-#include "clang/Rewrite/Core/Rewriter.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/StringSet.h"
-#include "llvm/Support/CommandLine.h"
-
-using namespace llvm;
-using namespace clang;
-using namespace clang::replace;
-
-static cl::opt<std::string> Directory(cl::Positional, cl::Required,
-                                      cl::desc("<Search Root Directory>"));
-
-static cl::OptionCategory ReplacementCategory("Replacement Options");
-static cl::OptionCategory FormattingCategory("Formatting Options");
-
-const cl::OptionCategory *VisibleCategories[] = {&ReplacementCategory,
-                                                 &FormattingCategory};
-
-static cl::opt<bool> RemoveTUReplacementFiles(
-    "remove-change-desc-files",
-    cl::desc("Remove the change description files regardless of successful\n"
-             "merging/replacing."),
-    cl::init(false), cl::cat(ReplacementCategory));
-
-
-static cl::opt<bool> DoFormat(
-    "format",
-    cl::desc("Enable formatting of code changed by applying replacements.\n"
-             "Use -style to choose formatting style.\n"),
-    cl::cat(FormattingCategory));
-
-// FIXME: Consider making the default behaviour for finding a style
-// configuration file to start the search anew for every file being changed to
-// handle situations where the style is different for different parts of a
-// project.
-
-static cl::opt<std::string> FormatStyleConfig(
-    "style-config",
-    cl::desc("Path to a directory containing a .clang-format file\n"
-             "describing a formatting style to use for formatting\n"
-             "code when -style=file.\n"),
-    cl::init(""), cl::cat(FormattingCategory));
-
-static cl::opt<std::string>
-FormatStyleOpt("style", cl::desc(format::StyleOptionHelpDescription),
-               cl::init("LLVM"), cl::cat(FormattingCategory));
-
-namespace {
-// Helper object to remove the TUReplacement files (triggered by
-// "remove-change-desc-files" command line option) when exiting current scope.
-class ScopedFileRemover {
-public:
-  ScopedFileRemover(const TUReplacementFiles &Files,
-                    clang::DiagnosticsEngine &Diagnostics)
-      : TURFiles(Files), Diag(Diagnostics) {}
-
-  ~ScopedFileRemover() {
-    deleteReplacementFiles(TURFiles, Diag);
-  }
-
-private:
-  const TUReplacementFiles &TURFiles;
-  clang::DiagnosticsEngine &Diag;
-};
-} // namespace
-
-static void printVersion() {
-  outs() << "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 (!tooling::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));
-
-  cl::SetVersionPrinter(&printVersion);
-  cl::ParseCommandLineOptions(argc, argv);
-
-  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions());
-  DiagnosticsEngine Diagnostics(
-      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
-      DiagOpts.get());
-
-  // Determine a formatting style from options.
-  format::FormatStyle FormatStyle;
-  if (DoFormat)
-    FormatStyle = format::getStyle(FormatStyleOpt, FormatStyleConfig, "LLVM");
-
-  TUReplacements TUs;
-  TUReplacementFiles TURFiles;
-
-  std::error_code ErrorCode =
-      collectReplacementsFromDirectory(Directory, TUs, TURFiles, Diagnostics);
-
-  if (ErrorCode) {
-    errs() << "Trouble iterating over directory '" << Directory
-           << "': " << ErrorCode.message() << "\n";
-    return 1;
-  }
-
-  // Remove the TUReplacementFiles (triggered by "remove-change-desc-files"
-  // command line option) when exiting main().
-  std::unique_ptr<ScopedFileRemover> Remover;
-  if (RemoveTUReplacementFiles)
-    Remover.reset(new ScopedFileRemover(TURFiles, Diagnostics));
-
-  FileManager Files((FileSystemOptions()));
-  SourceManager SM(Diagnostics, Files);
-
-  FileToReplacementsMap GroupedReplacements;
-  if (!mergeAndDeduplicate(TUs, GroupedReplacements, SM))
-    return 1;
-
-  Rewriter ReplacementsRewriter(SM, LangOptions());
-
-  for (const auto &FileAndReplacements : GroupedReplacements) {
-    // This shouldn't happen but if a file somehow has no replacements skip to
-    // next file.
-    if (FileAndReplacements.second.empty())
-      continue;
-
-    std::string NewFileData;
-    const char *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;
-    }
-
-    // Write new file to disk
-    std::error_code EC;
-    llvm::raw_fd_ostream FileStream(FileName, EC, llvm::sys::fs::F_None);
-    if (EC) {
-      llvm::errs() << "Could not open " << FileName << " for writing\n";
-      continue;
-    }
-
-    FileStream << NewFileData;
-  }
-
-  return 0;
-}

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

@@ -1,18 +0,0 @@
-set(LLVM_LINK_COMPONENTS
-  lineeditor
-  support
-  )
-
-add_clang_library(clangQuery
-  Query.cpp
-  QueryParser.cpp
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangDynamicASTMatchers
-  clangFrontend
-  )
-
-add_subdirectory(tool)

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

@@ -1,150 +0,0 @@
-//===---- Query.cpp - clang-query query -----------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Query.h"
-#include "QuerySession.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Frontend/ASTUnit.h"
-#include "clang/Frontend/TextDiagnostic.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace clang::ast_matchers;
-using namespace clang::ast_matchers::dynamic;
-
-namespace clang {
-namespace query {
-
-Query::~Query() {}
-
-bool InvalidQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
-  OS << ErrStr << "\n";
-  return false;
-}
-
-bool NoOpQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
-  return true;
-}
-
-bool HelpQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
-  OS << "Available commands:\n\n"
-        "  match MATCHER, m MATCHER          "
-        "Match the loaded ASTs against the given matcher.\n"
-        "  let NAME MATCHER, l NAME MATCHER  "
-        "Give a matcher expression a name, to be used later\n"
-        "                                    "
-        "as part of other expressions.\n"
-        "  set bind-root (true|false)        "
-        "Set whether to bind the root matcher to \"root\".\n"
-        "  set output (diag|print|dump)      "
-        "Set whether to print bindings as diagnostics,\n"
-        "                                    "
-        "AST pretty prints or AST dumps.\n"
-        "  quit                              "
-        "Terminates the query session.\n\n";
-  return true;
-}
-
-bool QuitQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
-  QS.Terminate = true;
-  return true;
-}
-
-namespace {
-
-struct CollectBoundNodes : MatchFinder::MatchCallback {
-  std::vector<BoundNodes> &Bindings;
-  CollectBoundNodes(std::vector<BoundNodes> &Bindings) : Bindings(Bindings) {}
-  void run(const MatchFinder::MatchResult &Result) override {
-    Bindings.push_back(Result.Nodes);
-  }
-};
-
-}  // namespace
-
-bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
-  unsigned MatchCount = 0;
-
-  for (auto &AST : QS.ASTs) {
-    MatchFinder Finder;
-    std::vector<BoundNodes> Matches;
-    DynTypedMatcher MaybeBoundMatcher = Matcher;
-    if (QS.BindRoot) {
-      llvm::Optional<DynTypedMatcher> M = Matcher.tryBind("root");
-      if (M)
-        MaybeBoundMatcher = *M;
-    }
-    CollectBoundNodes Collect(Matches);
-    if (!Finder.addDynamicMatcher(MaybeBoundMatcher, &Collect)) {
-      OS << "Not a valid top-level matcher.\n";
-      return false;
-    }
-    Finder.matchAST(AST->getASTContext());
-
-    for (std::vector<BoundNodes>::iterator MI = Matches.begin(),
-                                           ME = Matches.end();
-         MI != ME; ++MI) {
-      OS << "\nMatch #" << ++MatchCount << ":\n\n";
-
-      for (BoundNodes::IDToNodeMap::const_iterator BI = MI->getMap().begin(),
-                                                   BE = MI->getMap().end();
-           BI != BE; ++BI) {
-        switch (QS.OutKind) {
-        case OK_Diag: {
-          clang::SourceRange R = BI->second.getSourceRange();
-          if (R.isValid()) {
-            TextDiagnostic TD(OS, AST->getASTContext().getLangOpts(),
-                              &AST->getDiagnostics().getDiagnosticOptions());
-            TD.emitDiagnostic(
-                R.getBegin(), DiagnosticsEngine::Note,
-                "\"" + BI->first + "\" binds here",
-                CharSourceRange::getTokenRange(R),
-                None, &AST->getSourceManager());
-          }
-          break;
-        }
-        case OK_Print: {
-          OS << "Binding for \"" << BI->first << "\":\n";
-          BI->second.print(OS, AST->getASTContext().getPrintingPolicy());
-          OS << "\n";
-          break;
-        }
-        case OK_Dump: {
-          OS << "Binding for \"" << BI->first << "\":\n";
-          BI->second.dump(OS, AST->getSourceManager());
-          OS << "\n";
-          break;
-        }
-        }
-      }
-
-      if (MI->getMap().empty())
-        OS << "No bindings.\n";
-    }
-  }
-
-  OS << MatchCount << (MatchCount == 1 ? " match.\n" : " matches.\n");
-  return true;
-}
-
-bool LetQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
-  if (Value) {
-    QS.NamedValues[Name] = Value;
-  } else {
-    QS.NamedValues.erase(Name);
-  }
-  return true;
-}
-
-#ifndef _MSC_VER
-const QueryKind SetQueryKind<bool>::value;
-const QueryKind SetQueryKind<OutputKind>::value;
-#endif
-
-} // namespace query
-} // namespace clang

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

@@ -1,140 +0,0 @@
-//===--- Query.h - clang-query ----------------------------------*- 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_QUERY_QUERY_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_H
-
-#include "clang/ASTMatchers/Dynamic/VariantValue.h"
-#include "llvm/ADT/IntrusiveRefCntPtr.h"
-#include "llvm/ADT/Optional.h"
-#include <string>
-
-namespace clang {
-namespace query {
-
-enum OutputKind {
-  OK_Diag,
-  OK_Print,
-  OK_Dump
-};
-
-enum QueryKind {
-  QK_Invalid,
-  QK_NoOp,
-  QK_Help,
-  QK_Let,
-  QK_Match,
-  QK_SetBool,
-  QK_SetOutputKind,
-  QK_Quit
-};
-
-class QuerySession;
-
-struct Query : llvm::RefCountedBase<Query> {
-  Query(QueryKind Kind) : Kind(Kind) {}
-  virtual ~Query();
-
-  /// Perform the query on \p QS and print output to \p OS.
-  ///
-  /// \return false if an error occurs, otherwise return true.
-  virtual bool run(llvm::raw_ostream &OS, QuerySession &QS) const = 0;
-
-  const QueryKind Kind;
-};
-
-typedef llvm::IntrusiveRefCntPtr<Query> QueryRef;
-
-/// Any query which resulted in a parse error.  The error message is in ErrStr.
-struct InvalidQuery : Query {
-  InvalidQuery(const Twine &ErrStr) : Query(QK_Invalid), ErrStr(ErrStr.str()) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
-
-  std::string ErrStr;
-
-  static bool classof(const Query *Q) { return Q->Kind == QK_Invalid; }
-};
-
-/// No-op query (i.e. a blank line).
-struct NoOpQuery : Query {
-  NoOpQuery() : Query(QK_NoOp) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
-
-  static bool classof(const Query *Q) { return Q->Kind == QK_NoOp; }
-};
-
-/// Query for "help".
-struct HelpQuery : Query {
-  HelpQuery() : Query(QK_Help) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
-
-  static bool classof(const Query *Q) { return Q->Kind == QK_Help; }
-};
-
-/// Query for "quit".
-struct QuitQuery : Query {
-  QuitQuery() : Query(QK_Quit) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
-
-  static bool classof(const Query *Q) { return Q->Kind == QK_Quit; }
-};
-
-/// Query for "match MATCHER".
-struct MatchQuery : Query {
-  MatchQuery(const ast_matchers::dynamic::DynTypedMatcher &Matcher)
-      : Query(QK_Match), Matcher(Matcher) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
-
-  ast_matchers::dynamic::DynTypedMatcher Matcher;
-
-  static bool classof(const Query *Q) { return Q->Kind == QK_Match; }
-};
-
-struct LetQuery : Query {
-  LetQuery(StringRef Name, const ast_matchers::dynamic::VariantValue &Value)
-      : Query(QK_Let), Name(Name), Value(Value) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
-
-  std::string Name;
-  ast_matchers::dynamic::VariantValue Value;
-
-  static bool classof(const Query *Q) { return Q->Kind == QK_Let; }
-};
-
-template <typename T> struct SetQueryKind {};
-
-template <> struct SetQueryKind<bool> {
-  static const QueryKind value = QK_SetBool;
-};
-
-template <> struct SetQueryKind<OutputKind> {
-  static const QueryKind value = QK_SetOutputKind;
-};
-
-/// Query for "set VAR VALUE".
-template <typename T> struct SetQuery : Query {
-  SetQuery(T QuerySession::*Var, T Value)
-      : Query(SetQueryKind<T>::value), Var(Var), Value(Value) {}
-  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override {
-    QS.*Var = Value;
-    return true;
-  }
-
-  static bool classof(const Query *Q) {
-    return Q->Kind == SetQueryKind<T>::value;
-  }
-
-  T QuerySession::*Var;
-  T Value;
-};
-
-} // namespace query
-} // namespace clang
-
-#endif

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

@@ -1,286 +0,0 @@
-//===---- QueryParser.cpp - clang-query command parser --------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "QueryParser.h"
-#include "Query.h"
-#include "QuerySession.h"
-#include "clang/ASTMatchers/Dynamic/Parser.h"
-#include "clang/Basic/CharInfo.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringSwitch.h"
-#include <set>
-
-using namespace llvm;
-using namespace clang::ast_matchers::dynamic;
-
-namespace clang {
-namespace query {
-
-// Lex any amount of whitespace followed by a "word" (any sequence of
-// non-whitespace characters) from the start of region [Begin,End).  If no word
-// is found before End, return StringRef().  Begin is adjusted to exclude the
-// lexed region.
-StringRef QueryParser::lexWord() {
-  while (true) {
-    if (Begin == End)
-      return StringRef(Begin, 0);
-
-    if (!isWhitespace(*Begin))
-      break;
-
-    ++Begin;
-  }
-
-  const char *WordBegin = Begin;
-
-  while (true) {
-    ++Begin;
-
-    if (Begin == End || isWhitespace(*Begin))
-      return StringRef(WordBegin, Begin - WordBegin);
-  }
-}
-
-// This is the StringSwitch-alike used by lexOrCompleteWord below. See that
-// function for details.
-template <typename T> struct QueryParser::LexOrCompleteWord {
-  StringSwitch<T> Switch;
-
-  QueryParser *P;
-  StringRef Word;
-  // Set to the completion point offset in Word, or StringRef::npos if
-  // completion point not in Word.
-  size_t WordCompletionPos;
-
-  LexOrCompleteWord(QueryParser *P, StringRef Word, size_t WCP)
-      : Switch(Word), P(P), Word(Word), WordCompletionPos(WCP) {}
-
-  template <unsigned N>
-  LexOrCompleteWord &Case(const char (&S)[N], const T &Value,
-                          bool IsCompletion = true) {
-    StringRef CaseStr(S, N - 1);
-
-    if (WordCompletionPos == StringRef::npos)
-      Switch.Case(S, Value);
-    else if (N != 1 && IsCompletion && WordCompletionPos <= CaseStr.size() &&
-             CaseStr.substr(0, WordCompletionPos) ==
-                 Word.substr(0, WordCompletionPos))
-      P->Completions.push_back(LineEditor::Completion(
-          (CaseStr.substr(WordCompletionPos) + " ").str(), CaseStr));
-    return *this;
-  }
-
-  T Default(const T& Value) const {
-    return Switch.Default(Value);
-  }
-};
-
-// Lexes a word and stores it in Word. Returns a LexOrCompleteWord<T> object
-// that can be used like a llvm::StringSwitch<T>, but adds cases as possible
-// completions if the lexed word contains the completion point.
-template <typename T>
-QueryParser::LexOrCompleteWord<T>
-QueryParser::lexOrCompleteWord(StringRef &Word) {
-  Word = lexWord();
-  size_t WordCompletionPos = StringRef::npos;
-  if (CompletionPos && CompletionPos <= Word.data() + Word.size()) {
-    if (CompletionPos < Word.data())
-      WordCompletionPos = 0;
-    else
-      WordCompletionPos = CompletionPos - Word.data();
-  }
-  return LexOrCompleteWord<T>(this, Word, WordCompletionPos);
-}
-
-QueryRef QueryParser::parseSetBool(bool QuerySession::*Var) {
-  StringRef ValStr;
-  unsigned Value = lexOrCompleteWord<unsigned>(ValStr)
-                      .Case("false", 0)
-                      .Case("true", 1)
-                      .Default(~0u);
-  if (Value == ~0u) {
-    return new InvalidQuery("expected 'true' or 'false', got '" + ValStr + "'");
-  }
-  return new SetQuery<bool>(Var, Value);
-}
-
-QueryRef QueryParser::parseSetOutputKind() {
-  StringRef ValStr;
-  unsigned OutKind = lexOrCompleteWord<unsigned>(ValStr)
-                         .Case("diag", OK_Diag)
-                         .Case("print", OK_Print)
-                         .Case("dump", OK_Dump)
-                         .Default(~0u);
-  if (OutKind == ~0u) {
-    return new InvalidQuery("expected 'diag', 'print' or 'dump', got '" +
-                            ValStr + "'");
-  }
-  return new SetQuery<OutputKind>(&QuerySession::OutKind, OutputKind(OutKind));
-}
-
-QueryRef QueryParser::endQuery(QueryRef Q) {
-  const char *Extra = Begin;
-  if (!lexWord().empty())
-    return new InvalidQuery("unexpected extra input: '" +
-                            StringRef(Extra, End - Extra) + "'");
-  return Q;
-}
-
-namespace {
-
-enum ParsedQueryKind {
-  PQK_Invalid,
-  PQK_NoOp,
-  PQK_Help,
-  PQK_Let,
-  PQK_Match,
-  PQK_Set,
-  PQK_Unlet,
-  PQK_Quit
-};
-
-enum ParsedQueryVariable {
-  PQV_Invalid,
-  PQV_Output,
-  PQV_BindRoot
-};
-
-QueryRef makeInvalidQueryFromDiagnostics(const Diagnostics &Diag) {
-  std::string ErrStr;
-  llvm::raw_string_ostream OS(ErrStr);
-  Diag.printToStreamFull(OS);
-  return new InvalidQuery(OS.str());
-}
-
-}  // namespace
-
-QueryRef QueryParser::completeMatcherExpression() {
-  std::vector<MatcherCompletion> Comps = Parser::completeExpression(
-      StringRef(Begin, End - Begin), CompletionPos - Begin, nullptr,
-      &QS.NamedValues);
-  for (std::vector<MatcherCompletion>::iterator I = Comps.begin(),
-                                                E = Comps.end();
-       I != E; ++I) {
-    Completions.push_back(LineEditor::Completion(I->TypedText, I->MatcherDecl));
-  }
-  return QueryRef();
-}
-
-QueryRef QueryParser::doParse() {
-  StringRef CommandStr;
-  ParsedQueryKind QKind = lexOrCompleteWord<ParsedQueryKind>(CommandStr)
-                              .Case("", PQK_NoOp)
-                              .Case("help", PQK_Help)
-                              .Case("m", PQK_Match, /*IsCompletion=*/false)
-                              .Case("let", PQK_Let)
-                              .Case("match", PQK_Match)
-                              .Case("set", PQK_Set)
-                              .Case("unlet", PQK_Unlet)
-                              .Case("quit", PQK_Quit)
-                              .Default(PQK_Invalid);
-
-  switch (QKind) {
-  case PQK_NoOp:
-    return new NoOpQuery;
-
-  case PQK_Help:
-    return endQuery(new HelpQuery);
-
-  case PQK_Quit:
-    return endQuery(new QuitQuery);
-
-  case PQK_Let: {
-    StringRef Name = lexWord();
-
-    if (Name.empty())
-      return new InvalidQuery("expected variable name");
-
-    if (CompletionPos)
-      return completeMatcherExpression();
-
-    Diagnostics Diag;
-    ast_matchers::dynamic::VariantValue Value;
-    if (!Parser::parseExpression(StringRef(Begin, End - Begin), nullptr,
-                                 &QS.NamedValues, &Value, &Diag)) {
-      return makeInvalidQueryFromDiagnostics(Diag);
-    }
-
-    return new LetQuery(Name, Value);
-  }
-
-  case PQK_Match: {
-    if (CompletionPos)
-      return completeMatcherExpression();
-
-    Diagnostics Diag;
-    Optional<DynTypedMatcher> Matcher = Parser::parseMatcherExpression(
-        StringRef(Begin, End - Begin), nullptr, &QS.NamedValues, &Diag);
-    if (!Matcher) {
-      return makeInvalidQueryFromDiagnostics(Diag);
-    }
-    return new MatchQuery(*Matcher);
-  }
-
-  case PQK_Set: {
-    StringRef VarStr;
-    ParsedQueryVariable Var = lexOrCompleteWord<ParsedQueryVariable>(VarStr)
-                                  .Case("output", PQV_Output)
-                                  .Case("bind-root", PQV_BindRoot)
-                                  .Default(PQV_Invalid);
-    if (VarStr.empty())
-      return new InvalidQuery("expected variable name");
-    if (Var == PQV_Invalid)
-      return new InvalidQuery("unknown variable: '" + VarStr + "'");
-
-    QueryRef Q;
-    switch (Var) {
-    case PQV_Output:
-      Q = parseSetOutputKind();
-      break;
-    case PQV_BindRoot:
-      Q = parseSetBool(&QuerySession::BindRoot);
-      break;
-    case PQV_Invalid:
-      llvm_unreachable("Invalid query kind");
-    }
-
-    return endQuery(Q);
-  }
-
-  case PQK_Unlet: {
-    StringRef Name = lexWord();
-
-    if (Name.empty())
-      return new InvalidQuery("expected variable name");
-
-    return endQuery(new LetQuery(Name, VariantValue()));
-  }
-
-  case PQK_Invalid:
-    return new InvalidQuery("unknown command: " + CommandStr);
-  }
-
-  llvm_unreachable("Invalid query kind");
-}
-
-QueryRef QueryParser::parse(StringRef Line, const QuerySession &QS) {
-  return QueryParser(Line, QS).doParse();
-}
-
-std::vector<LineEditor::Completion>
-QueryParser::complete(StringRef Line, size_t Pos, const QuerySession &QS) {
-  QueryParser P(Line, QS);
-  P.CompletionPos = Line.data() + Pos;
-
-  P.doParse();
-  return P.Completions;
-}
-
-} // namespace query
-} // namespace clang

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

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

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

@@ -1,40 +0,0 @@
-//===--- QuerySession.h - clang-query ---------------------------*- 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_QUERY_QUERY_SESSION_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_SESSION_H
-
-#include "Query.h"
-#include "clang/ASTMatchers/Dynamic/VariantValue.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringMap.h"
-
-namespace clang {
-
-class ASTUnit;
-
-namespace query {
-
-/// Represents the state for a particular clang-query session.
-class QuerySession {
-public:
-  QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
-      : ASTs(ASTs), OutKind(OK_Diag), BindRoot(true), Terminate(false) {}
-
-  llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
-  OutputKind OutKind;
-  bool BindRoot;
-  bool Terminate;
-  llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
-};
-
-} // namespace query
-} // namespace clang
-
-#endif

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

@@ -1,14 +0,0 @@
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
-
-add_clang_executable(clang-query ClangQuery.cpp)
-target_link_libraries(clang-query
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangDynamicASTMatchers
-  clangFrontend
-  clangQuery
-  clangTooling
-  )
-
-install(TARGETS clang-query RUNTIME DESTINATION bin)

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

@@ -1,120 +0,0 @@
-//===---- ClangQuery.cpp - clang-query tool -------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This tool is for interactive exploration of the Clang AST using AST matchers.
-// It currently allows the user to enter a matcher at an interactive prompt and
-// view the resulting bindings as diagnostics, AST pretty prints or AST dumps.
-// Example session:
-//
-// $ cat foo.c
-// void foo(void) {}
-// $ clang-query foo.c --
-// clang-query> match functionDecl()
-//
-// Match #1:
-//
-// foo.c:1:1: note: "root" binds here
-// void foo(void) {}
-// ^~~~~~~~~~~~~~~~~
-// 1 match.
-//
-//===----------------------------------------------------------------------===//
-
-#include "Query.h"
-#include "QueryParser.h"
-#include "QuerySession.h"
-#include "clang/Frontend/ASTUnit.h"
-#include "clang/Tooling/CommonOptionsParser.h"
-#include "clang/Tooling/Tooling.h"
-#include "llvm/LineEditor/LineEditor.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/Signals.h"
-#include <fstream>
-#include <string>
-
-using namespace clang;
-using namespace clang::ast_matchers;
-using namespace clang::ast_matchers::dynamic;
-using namespace clang::query;
-using namespace clang::tooling;
-using namespace llvm;
-
-static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
-static cl::OptionCategory ClangQueryCategory("clang-query options");
-
-static cl::list<std::string> Commands("c", cl::desc("Specify command to run"),
-                                      cl::value_desc("command"),
-                                      cl::cat(ClangQueryCategory));
-
-static cl::list<std::string> CommandFiles("f",
-                                          cl::desc("Read commands from file"),
-                                          cl::value_desc("file"),
-                                          cl::cat(ClangQueryCategory));
-
-int main(int argc, const char **argv) {
-  llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
-
-  CommonOptionsParser OptionsParser(argc, argv, ClangQueryCategory);
-
-  if (!Commands.empty() && !CommandFiles.empty()) {
-    llvm::errs() << argv[0] << ": cannot specify both -c and -f\n";
-    return 1;
-  }
-
-  ClangTool Tool(OptionsParser.getCompilations(),
-                 OptionsParser.getSourcePathList());
-  std::vector<std::unique_ptr<ASTUnit>> ASTs;
-  if (Tool.buildASTs(ASTs) != 0)
-    return 1;
-
-  QuerySession QS(ASTs);
-
-  if (!Commands.empty()) {
-    for (cl::list<std::string>::iterator I = Commands.begin(),
-                                         E = Commands.end();
-         I != E; ++I) {
-      QueryRef Q = QueryParser::parse(I->c_str(), QS);
-      if (!Q->run(llvm::outs(), QS))
-        return 1;
-    }
-  } else if (!CommandFiles.empty()) {
-    for (cl::list<std::string>::iterator I = CommandFiles.begin(),
-                                         E = CommandFiles.end();
-         I != E; ++I) {
-      std::ifstream Input(I->c_str());
-      if (!Input.is_open()) {
-        llvm::errs() << argv[0] << ": cannot open " << *I << "\n";
-        return 1;
-      }
-      while (Input.good()) {
-        std::string Line;
-        std::getline(Input, Line);
-
-        QueryRef Q = QueryParser::parse(Line.c_str(), QS);
-        if (!Q->run(llvm::outs(), QS))
-          return 1;
-      }
-    }
-  } else {
-    LineEditor LE("clang-query");
-    LE.setListCompleter([&QS](StringRef Line, size_t Pos) {
-      return QueryParser::complete(Line, Pos, QS);
-    });
-    while (llvm::Optional<std::string> Line = LE.readLine()) {
-      QueryRef Q = QueryParser::parse(*Line, QS);
-      Q->run(llvm::outs(), QS);
-      llvm::outs().flush();
-      if (QS.Terminate)
-        break;
-    }
-  }
-
-  return 0;
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,220 +0,0 @@
-//===--- tools/extra/clang-rename/USRLocFinder.cpp - Clang rename tool ----===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief Mehtods for finding all instances of a USR. Our strategy is very
-/// simple; we just compare the USR at every relevant AST node with the one
-/// provided.
-///
-//===----------------------------------------------------------------------===//
-
-#include "USRLocFinder.h"
-#include "USRFinder.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/RecursiveASTVisitor.h"
-#include "clang/Basic/SourceLocation.h"
-#include "clang/Index/USRGeneration.h"
-#include "clang/Lex/Lexer.h"
-#include "llvm/ADT/SmallVector.h"
-
-using namespace llvm;
-
-namespace clang {
-namespace rename {
-
-namespace {
-// \brief This visitor recursively searches for all instances of a USR in a
-// translation unit and stores them for later usage.
-class USRLocFindingASTVisitor
-    : public clang::RecursiveASTVisitor<USRLocFindingASTVisitor> {
-public:
-  explicit USRLocFindingASTVisitor(StringRef USR, StringRef PrevName)
-      : USR(USR), PrevName(PrevName) {}
-
-  // Declaration visitors:
-
-  bool VisitNamedDecl(const NamedDecl *Decl) {
-    if (getUSRForDecl(Decl) == USR) {
-      LocationsFound.push_back(Decl->getLocation());
-    }
-    return true;
-  }
-
-  bool VisitVarDecl(clang::VarDecl *Decl) {
-    clang::QualType Type = Decl->getType();
-    const clang::RecordDecl *RecordDecl = Type->getPointeeCXXRecordDecl();
-    if (RecordDecl) {
-      if (getUSRForDecl(RecordDecl) == USR) {
-        // The declaration refers to a type that is to be renamed.
-        LocationsFound.push_back(Decl->getTypeSpecStartLoc());
-      }
-    }
-    return true;
-  }
-
-  bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *ConstructorDecl) {
-    const ASTContext &Context = ConstructorDecl->getASTContext();
-    for (auto &Initializer : ConstructorDecl->inits()) {
-      if (Initializer->getSourceOrder() == -1) {
-        // Ignore implicit initializers.
-        continue;
-      }
-
-      if (const clang::FieldDecl *FieldDecl = Initializer->getAnyMember()) {
-        if (getUSRForDecl(FieldDecl) == USR) {
-          // The initializer refers to a field that is to be renamed.
-          SourceLocation Location = Initializer->getSourceLocation();
-          StringRef TokenName = Lexer::getSourceText(
-              CharSourceRange::getTokenRange(Location),
-              Context.getSourceManager(), Context.getLangOpts());
-          if (TokenName == PrevName) {
-            // The token of the source location we find actually has the old
-            // name.
-            LocationsFound.push_back(Initializer->getSourceLocation());
-          }
-        }
-      }
-    }
-
-    if (getUSRForDecl(ConstructorDecl) == USR) {
-      // This takes care of the class name part of a non-inline ctor definition.
-      LocationsFound.push_back(ConstructorDecl->getLocStart());
-    }
-    return true;
-  }
-
-  bool VisitCXXDestructorDecl(clang::CXXDestructorDecl *DestructorDecl) {
-    if (getUSRForDecl(DestructorDecl->getParent()) == USR) {
-      // Handles "~Foo" from "Foo::~Foo".
-      SourceLocation Location = DestructorDecl->getLocation();
-      const ASTContext &Context = DestructorDecl->getASTContext();
-      StringRef LLVM_ATTRIBUTE_UNUSED TokenName = Lexer::getSourceText(
-          CharSourceRange::getTokenRange(Location), Context.getSourceManager(),
-          Context.getLangOpts());
-      // 1 is the length of the "~" string that is not to be touched by the
-      // rename.
-      assert(TokenName.startswith("~"));
-      LocationsFound.push_back(Location.getLocWithOffset(1));
-
-      if (DestructorDecl->isThisDeclarationADefinition()) {
-        // Handles "Foo" from "Foo::~Foo".
-        LocationsFound.push_back(DestructorDecl->getLocStart());
-      }
-    }
-
-    return true;
-  }
-
-  // Expression visitors:
-
-  bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
-    const auto *Decl = Expr->getFoundDecl();
-
-    checkNestedNameSpecifierLoc(Expr->getQualifierLoc());
-    if (getUSRForDecl(Decl) == USR) {
-      const SourceManager &Manager = Decl->getASTContext().getSourceManager();
-      SourceLocation Location = Manager.getSpellingLoc(Expr->getLocation());
-      LocationsFound.push_back(Location);
-    }
-
-    return true;
-  }
-
-  bool VisitMemberExpr(const MemberExpr *Expr) {
-    const auto *Decl = Expr->getFoundDecl().getDecl();
-    if (getUSRForDecl(Decl) == USR) {
-      const SourceManager &Manager = Decl->getASTContext().getSourceManager();
-      SourceLocation Location = Manager.getSpellingLoc(Expr->getMemberLoc());
-      LocationsFound.push_back(Location);
-    }
-    return true;
-  }
-
-  bool VisitCXXConstructExpr(const CXXConstructExpr *Expr) {
-    CXXConstructorDecl *Decl = Expr->getConstructor();
-
-    if (getUSRForDecl(Decl) == USR) {
-      // This takes care of 'new <name>' expressions.
-      LocationsFound.push_back(Expr->getLocation());
-    }
-
-    return true;
-  }
-
-  bool VisitCXXStaticCastExpr(clang::CXXStaticCastExpr *Expr) {
-    return handleCXXNamedCastExpr(Expr);
-  }
-
-  bool VisitCXXDynamicCastExpr(clang::CXXDynamicCastExpr *Expr) {
-    return handleCXXNamedCastExpr(Expr);
-  }
-
-  bool VisitCXXReinterpretCastExpr(clang::CXXReinterpretCastExpr *Expr) {
-    return handleCXXNamedCastExpr(Expr);
-  }
-
-  bool VisitCXXConstCastExpr(clang::CXXConstCastExpr *Expr) {
-    return handleCXXNamedCastExpr(Expr);
-  }
-
-  // Non-visitors:
-
-  // \brief Returns a list of unique locations. Duplicate or overlapping
-  // locations are erroneous and should be reported!
-  const std::vector<clang::SourceLocation> &getLocationsFound() const {
-    return LocationsFound;
-  }
-
-private:
-  // Namespace traversal:
-  void checkNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
-    while (NameLoc) {
-      const auto *Decl = NameLoc.getNestedNameSpecifier()->getAsNamespace();
-      if (Decl && getUSRForDecl(Decl) == USR)
-        LocationsFound.push_back(NameLoc.getLocalBeginLoc());
-      NameLoc = NameLoc.getPrefix();
-    }
-  }
-
-  bool handleCXXNamedCastExpr(clang::CXXNamedCastExpr *Expr) {
-    clang::QualType Type = Expr->getType();
-    // See if this a cast of a pointer.
-    const RecordDecl *Decl = Type->getPointeeCXXRecordDecl();
-    if (!Decl) {
-      // See if this is a cast of a reference.
-      Decl = Type->getAsCXXRecordDecl();
-    }
-
-    if (Decl && getUSRForDecl(Decl) == USR) {
-      SourceLocation Location =
-          Expr->getTypeInfoAsWritten()->getTypeLoc().getBeginLoc();
-      LocationsFound.push_back(Location);
-    }
-
-    return true;
-  }
-
-  // All the locations of the USR were found.
-  const std::string USR;
-  // Old name that is renamed.
-  const std::string PrevName;
-  std::vector<clang::SourceLocation> LocationsFound;
-};
-} // namespace
-
-std::vector<SourceLocation> getLocationsOfUSR(StringRef USR, StringRef PrevName,
-                                              Decl *Decl) {
-  USRLocFindingASTVisitor Visitor(USR, PrevName);
-
-  Visitor.TraverseDecl(Decl);
-  return Visitor.getLocationsFound();
-}
-
-} // namespace rename
-} // namespace clang

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

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

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

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

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

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

clang-tools-extra/clang-rename/tool/clang-rename.py

@@ -1,61 +0,0 @@
-'''
-Minimal clang-rename integration with Vim.
-
-Before installing make sure one of the following is satisfied:
-
-* clang-rename is in your PATH
-* `g:clang_rename_path` in ~/.vimrc points to valid clang-rename executable
-* `binary` in clang-rename.py points to valid to clang-rename executable
-
-To install, simply put this into your ~/.vimrc
-
-    map ,cr :pyf <path-to>/clang-rename.py<cr>
-
-IMPORTANT NOTE: Before running the tool, make sure you saved the file.
-
-All you have to do now is to place a cursor on a variable/function/class which
-you would like to rename and press ',cr'. You will be prompted for a new name if
-the cursor points to a valid symbol.
-'''
-
-import vim
-import subprocess
-import sys
-
-def main():
-    binary = 'clang-rename'
-    if vim.eval('exists("g:clang_rename_path")') == "1":
-        binary = vim.eval('g:clang_rename_path')
-
-    # Get arguments for clang-rename binary.
-    offset = int(vim.eval('line2byte(line("."))+col(".")')) - 2
-    if offset < 0:
-        print >> sys.stderr, '''Couldn\'t determine cursor position.
-                                Is your file empty?'''
-        return
-    filename = vim.current.buffer.name
-
-    new_name_request_message = 'type new name:'
-    new_name = vim.eval("input('{}\n')".format(new_name_request_message))
-
-    # Call clang-rename.
-    command = [binary,
-               filename,
-               '-i',
-               '-offset', str(offset),
-               '-new-name', str(new_name)]
-    # FIXME: make it possible to run the tool on unsaved file.
-    p = subprocess.Popen(command,
-                         stdout=subprocess.PIPE,
-                         stderr=subprocess.PIPE)
-    stdout, stderr = p.communicate()
-
-    if stderr:
-        print stderr
-
-    # Reload all buffers in Vim.
-    vim.command("bufdo edit")
-
-
-if __name__ == '__main__':
-    main()

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

@@ -1,39 +0,0 @@
-set(LLVM_LINK_COMPONENTS
-  Support
-  )
-
-add_clang_library(clangTidy
-  ClangTidy.cpp
-  ClangTidyModule.cpp
-  ClangTidyDiagnosticConsumer.cpp
-  ClangTidyOptions.cpp
-
-  DEPENDS
-  ClangSACheckers
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangFrontend
-  clangLex
-  clangRewrite
-  clangSema
-  clangStaticAnalyzerCore
-  clangStaticAnalyzerFrontend
-  clangTooling
-  clangToolingCore
-  )
-
-add_subdirectory(tool)
-add_subdirectory(plugin)
-add_subdirectory(boost)
-add_subdirectory(cert)
-add_subdirectory(llvm)
-add_subdirectory(cppcoreguidelines)
-add_subdirectory(google)
-add_subdirectory(misc)
-add_subdirectory(modernize)
-add_subdirectory(performance)
-add_subdirectory(readability)
-add_subdirectory(utils)

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

@@ -1,522 +0,0 @@
-//===--- tools/extra/clang-tidy/ClangTidy.cpp - Clang tidy tool -----------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-///  \file This file implements a clang-tidy tool.
-///
-///  This tool uses the Clang Tooling infrastructure, see
-///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
-///  for details on setting it up with LLVM source tree.
-///
-//===----------------------------------------------------------------------===//
-
-#include "ClangTidy.h"
-#include "ClangTidyDiagnosticConsumer.h"
-#include "ClangTidyModuleRegistry.h"
-#include "clang/AST/ASTConsumer.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/Decl.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Frontend/ASTConsumers.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/FrontendActions.h"
-#include "clang/Frontend/FrontendDiagnostic.h"
-#include "clang/Frontend/MultiplexConsumer.h"
-#include "clang/Frontend/TextDiagnosticPrinter.h"
-#include "clang/Lex/PPCallbacks.h"
-#include "clang/Lex/Preprocessor.h"
-#include "clang/Rewrite/Frontend/FixItRewriter.h"
-#include "clang/Rewrite/Frontend/FrontendActions.h"
-#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
-#include "clang/Tooling/Refactoring.h"
-#include "clang/Tooling/ReplacementsYaml.h"
-#include "clang/Tooling/Tooling.h"
-#include "llvm/Support/Process.h"
-#include "llvm/Support/Signals.h"
-#include <algorithm>
-#include <utility>
-
-using namespace clang::ast_matchers;
-using namespace clang::driver;
-using namespace clang::tooling;
-using namespace llvm;
-
-template class llvm::Registry<clang::tidy::ClangTidyModule>;
-
-namespace clang {
-namespace tidy {
-
-namespace {
-static const char *AnalyzerCheckNamePrefix = "clang-analyzer-";
-
-static const StringRef StaticAnalyzerChecks[] = {
-#define GET_CHECKERS
-#define CHECKER(FULLNAME, CLASS, DESCFILE, HELPTEXT, GROUPINDEX, HIDDEN)       \
-  FULLNAME,
-#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
-#undef CHECKER
-#undef GET_CHECKERS
-};
-
-class AnalyzerDiagnosticConsumer : public ento::PathDiagnosticConsumer {
-public:
-  AnalyzerDiagnosticConsumer(ClangTidyContext &Context) : Context(Context) {}
-
-  void FlushDiagnosticsImpl(std::vector<const ento::PathDiagnostic *> &Diags,
-                            FilesMade *filesMade) override {
-    for (const ento::PathDiagnostic *PD : Diags) {
-      SmallString<64> CheckName(AnalyzerCheckNamePrefix);
-      CheckName += PD->getCheckName();
-      Context.diag(CheckName, PD->getLocation().asLocation(),
-                   PD->getShortDescription())
-          << PD->path.back()->getRanges();
-
-      for (const auto &DiagPiece :
-           PD->path.flatten(/*ShouldFlattenMacros=*/true)) {
-        Context.diag(CheckName, DiagPiece->getLocation().asLocation(),
-                     DiagPiece->getString(), DiagnosticIDs::Note)
-            << DiagPiece->getRanges();
-      }
-    }
-  }
-
-  StringRef getName() const override { return "ClangTidyDiags"; }
-  bool supportsLogicalOpControlFlow() const override { return true; }
-  bool supportsCrossFileDiagnostics() const override { return true; }
-
-private:
-  ClangTidyContext &Context;
-};
-
-class ErrorReporter {
-public:
-  ErrorReporter(bool ApplyFixes)
-      : Files(FileSystemOptions()), DiagOpts(new DiagnosticOptions()),
-        DiagPrinter(new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts)),
-        Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts,
-              DiagPrinter),
-        SourceMgr(Diags, Files), Rewrite(SourceMgr, LangOpts),
-        ApplyFixes(ApplyFixes), TotalFixes(0), AppliedFixes(0),
-        WarningsAsErrors(0) {
-    DiagOpts->ShowColors = llvm::sys::Process::StandardOutHasColors();
-    DiagPrinter->BeginSourceFile(LangOpts);
-  }
-
-  SourceManager &getSourceManager() { return SourceMgr; }
-
-  void reportDiagnostic(const ClangTidyError &Error) {
-    const ClangTidyMessage &Message = Error.Message;
-    SourceLocation Loc = getLocation(Message.FilePath, Message.FileOffset);
-    // Contains a pair for each attempted fix: location and whether the fix was
-    // applied successfully.
-    SmallVector<std::pair<SourceLocation, bool>, 4> FixLocations;
-    {
-      auto Level = static_cast<DiagnosticsEngine::Level>(Error.DiagLevel);
-      std::string Name = Error.CheckName;
-      if (Error.IsWarningAsError) {
-        Name += ",-warnings-as-errors";
-        Level = DiagnosticsEngine::Error;
-        WarningsAsErrors++;
-      }
-      auto Diag = Diags.Report(Loc, Diags.getCustomDiagID(Level, "%0 [%1]"))
-                  << Message.Message << Name;
-      for (const tooling::Replacement &Fix : Error.Fix) {
-        // Retrieve the source range for applicable fixes. Macro definitions
-        // on the command line have locations in a virtual buffer and don't
-        // have valid file paths and are therefore not applicable.
-        SourceRange Range;
-        SourceLocation FixLoc;
-        if (Fix.isApplicable()) {
-          SmallString<128> FixAbsoluteFilePath = Fix.getFilePath();
-          Files.makeAbsolutePath(FixAbsoluteFilePath);
-          FixLoc = getLocation(FixAbsoluteFilePath, Fix.getOffset());
-          SourceLocation FixEndLoc = FixLoc.getLocWithOffset(Fix.getLength());
-          Range = SourceRange(FixLoc, FixEndLoc);
-          Diag << FixItHint::CreateReplacement(Range, Fix.getReplacementText());
-        }
-
-        ++TotalFixes;
-        if (ApplyFixes) {
-          bool Success = Fix.isApplicable() && Fix.apply(Rewrite);
-          if (Success)
-            ++AppliedFixes;
-          FixLocations.push_back(std::make_pair(FixLoc, Success));
-        }
-      }
-    }
-    for (auto Fix : FixLocations) {
-      Diags.Report(Fix.first, Fix.second ? diag::note_fixit_applied
-                                         : diag::note_fixit_failed);
-    }
-    for (const ClangTidyMessage &Note : Error.Notes)
-      reportNote(Note);
-  }
-
-  void Finish() {
-    // FIXME: Run clang-format on changes.
-    if (ApplyFixes && TotalFixes > 0) {
-      llvm::errs() << "clang-tidy applied " << AppliedFixes << " of "
-                   << TotalFixes << " suggested fixes.\n";
-      Rewrite.overwriteChangedFiles();
-    }
-  }
-
-  unsigned getWarningsAsErrorsCount() const { return WarningsAsErrors; }
-
-private:
-  SourceLocation getLocation(StringRef FilePath, unsigned Offset) {
-    if (FilePath.empty())
-      return SourceLocation();
-
-    const FileEntry *File = SourceMgr.getFileManager().getFile(FilePath);
-    FileID ID = SourceMgr.createFileID(File, SourceLocation(), SrcMgr::C_User);
-    return SourceMgr.getLocForStartOfFile(ID).getLocWithOffset(Offset);
-  }
-
-  void reportNote(const ClangTidyMessage &Message) {
-    SourceLocation Loc = getLocation(Message.FilePath, Message.FileOffset);
-    DiagnosticBuilder Diag =
-        Diags.Report(Loc, Diags.getCustomDiagID(DiagnosticsEngine::Note, "%0"))
-        << Message.Message;
-  }
-
-  FileManager Files;
-  LangOptions LangOpts; // FIXME: use langopts from each original file
-  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
-  DiagnosticConsumer *DiagPrinter;
-  DiagnosticsEngine Diags;
-  SourceManager SourceMgr;
-  Rewriter Rewrite;
-  bool ApplyFixes;
-  unsigned TotalFixes;
-  unsigned AppliedFixes;
-  unsigned WarningsAsErrors;
-};
-
-class ClangTidyASTConsumer : public MultiplexConsumer {
-public:
-  ClangTidyASTConsumer(std::vector<std::unique_ptr<ASTConsumer>> Consumers,
-                       std::unique_ptr<ast_matchers::MatchFinder> Finder,
-                       std::vector<std::unique_ptr<ClangTidyCheck>> Checks)
-      : MultiplexConsumer(std::move(Consumers)), Finder(std::move(Finder)),
-        Checks(std::move(Checks)) {}
-
-private:
-  std::unique_ptr<ast_matchers::MatchFinder> Finder;
-  std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
-};
-
-} // namespace
-
-ClangTidyASTConsumerFactory::ClangTidyASTConsumerFactory(
-    ClangTidyContext &Context)
-    : Context(Context), CheckFactories(new ClangTidyCheckFactories) {
-  for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
-                                         E = ClangTidyModuleRegistry::end();
-       I != E; ++I) {
-    std::unique_ptr<ClangTidyModule> Module(I->instantiate());
-    Module->addCheckFactories(*CheckFactories);
-  }
-}
-
-static void setStaticAnalyzerCheckerOpts(const ClangTidyOptions &Opts,
-                                         AnalyzerOptionsRef AnalyzerOptions) {
-  StringRef AnalyzerPrefix(AnalyzerCheckNamePrefix);
-  for (const auto &Opt : Opts.CheckOptions) {
-    StringRef OptName(Opt.first);
-    if (!OptName.startswith(AnalyzerPrefix))
-      continue;
-    AnalyzerOptions->Config[OptName.substr(AnalyzerPrefix.size())] = Opt.second;
-  }
-}
-
-std::unique_ptr<clang::ASTConsumer>
-ClangTidyASTConsumerFactory::CreateASTConsumer(
-    clang::CompilerInstance &Compiler, StringRef File) {
-  // FIXME: Move this to a separate method, so that CreateASTConsumer doesn't
-  // modify Compiler.
-  Context.setSourceManager(&Compiler.getSourceManager());
-  Context.setCurrentFile(File);
-  Context.setASTContext(&Compiler.getASTContext());
-
-  auto WorkingDir = Compiler.getSourceManager()
-                        .getFileManager()
-                        .getVirtualFileSystem()
-                        ->getCurrentWorkingDirectory();
-  if (WorkingDir)
-    Context.setCurrentBuildDirectory(WorkingDir.get());
-
-  std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
-  CheckFactories->createChecks(&Context, Checks);
-
-  ast_matchers::MatchFinder::MatchFinderOptions FinderOptions;
-  if (auto *P = Context.getCheckProfileData())
-    FinderOptions.CheckProfiling.emplace(P->Records);
-
-  std::unique_ptr<ast_matchers::MatchFinder> Finder(
-      new ast_matchers::MatchFinder(std::move(FinderOptions)));
-
-  for (auto &Check : Checks) {
-    Check->registerMatchers(&*Finder);
-    Check->registerPPCallbacks(Compiler);
-  }
-
-  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
-  if (!Checks.empty())
-    Consumers.push_back(Finder->newASTConsumer());
-
-  AnalyzerOptionsRef AnalyzerOptions = Compiler.getAnalyzerOpts();
-  // FIXME: Remove this option once clang's cfg-temporary-dtors option defaults
-  // to true.
-  AnalyzerOptions->Config["cfg-temporary-dtors"] =
-      Context.getOptions().AnalyzeTemporaryDtors ? "true" : "false";
-
-  GlobList &Filter = Context.getChecksFilter();
-  AnalyzerOptions->CheckersControlList = getCheckersControlList(Filter);
-  if (!AnalyzerOptions->CheckersControlList.empty()) {
-    setStaticAnalyzerCheckerOpts(Context.getOptions(), AnalyzerOptions);
-    AnalyzerOptions->AnalysisStoreOpt = RegionStoreModel;
-    AnalyzerOptions->AnalysisDiagOpt = PD_NONE;
-    AnalyzerOptions->AnalyzeNestedBlocks = true;
-    AnalyzerOptions->eagerlyAssumeBinOpBifurcation = true;
-    std::unique_ptr<ento::AnalysisASTConsumer> AnalysisConsumer =
-        ento::CreateAnalysisConsumer(Compiler);
-    AnalysisConsumer->AddDiagnosticConsumer(
-        new AnalyzerDiagnosticConsumer(Context));
-    Consumers.push_back(std::move(AnalysisConsumer));
-  }
-  return llvm::make_unique<ClangTidyASTConsumer>(
-      std::move(Consumers), std::move(Finder), std::move(Checks));
-}
-
-std::vector<std::string> ClangTidyASTConsumerFactory::getCheckNames() {
-  std::vector<std::string> CheckNames;
-  GlobList &Filter = Context.getChecksFilter();
-  for (const auto &CheckFactory : *CheckFactories) {
-    if (Filter.contains(CheckFactory.first))
-      CheckNames.push_back(CheckFactory.first);
-  }
-
-  for (const auto &AnalyzerCheck : getCheckersControlList(Filter))
-    CheckNames.push_back(AnalyzerCheckNamePrefix + AnalyzerCheck.first);
-
-  std::sort(CheckNames.begin(), CheckNames.end());
-  return CheckNames;
-}
-
-ClangTidyOptions::OptionMap ClangTidyASTConsumerFactory::getCheckOptions() {
-  ClangTidyOptions::OptionMap Options;
-  std::vector<std::unique_ptr<ClangTidyCheck>> Checks;
-  CheckFactories->createChecks(&Context, Checks);
-  for (const auto &Check : Checks)
-    Check->storeOptions(Options);
-  return Options;
-}
-
-ClangTidyASTConsumerFactory::CheckersList
-ClangTidyASTConsumerFactory::getCheckersControlList(GlobList &Filter) {
-  CheckersList List;
-
-  bool AnalyzerChecksEnabled = false;
-  for (StringRef CheckName : StaticAnalyzerChecks) {
-    std::string Checker((AnalyzerCheckNamePrefix + CheckName).str());
-    AnalyzerChecksEnabled =
-        AnalyzerChecksEnabled ||
-        (!CheckName.startswith("debug") && Filter.contains(Checker));
-  }
-
-  if (AnalyzerChecksEnabled) {
-    // Run our regex against all possible static analyzer checkers.  Note that
-    // debug checkers print values / run programs to visualize the CFG and are
-    // thus not applicable to clang-tidy in general.
-    //
-    // Always add all core checkers if any other static analyzer checks are
-    // enabled. This is currently necessary, as other path sensitive checks
-    // rely on the core checkers.
-    for (StringRef CheckName : StaticAnalyzerChecks) {
-      std::string Checker((AnalyzerCheckNamePrefix + CheckName).str());
-
-      if (CheckName.startswith("core") ||
-          (!CheckName.startswith("debug") && Filter.contains(Checker)))
-        List.push_back(std::make_pair(CheckName, true));
-    }
-  }
-  return List;
-}
-
-DiagnosticBuilder ClangTidyCheck::diag(SourceLocation Loc, StringRef Message,
-                                       DiagnosticIDs::Level Level) {
-  return Context->diag(CheckName, Loc, Message, Level);
-}
-
-void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
-  Context->setSourceManager(Result.SourceManager);
-  check(Result);
-}
-
-OptionsView::OptionsView(StringRef CheckName,
-                         const ClangTidyOptions::OptionMap &CheckOptions)
-    : NamePrefix(CheckName.str() + "."), CheckOptions(CheckOptions) {}
-
-std::string OptionsView::get(StringRef LocalName, StringRef Default) const {
-  const auto &Iter = CheckOptions.find(NamePrefix + LocalName.str());
-  if (Iter != CheckOptions.end())
-    return Iter->second;
-  return Default;
-}
-
-std::string OptionsView::getLocalOrGlobal(StringRef LocalName,
-                                          StringRef Default) const {
-  auto Iter = CheckOptions.find(NamePrefix + LocalName.str());
-  if (Iter != CheckOptions.end())
-    return Iter->second;
-  // Fallback to global setting, if present.
-  Iter = CheckOptions.find(LocalName.str());
-  if (Iter != CheckOptions.end())
-    return Iter->second;
-  return Default;
-}
-
-void OptionsView::store(ClangTidyOptions::OptionMap &Options,
-                        StringRef LocalName, StringRef Value) const {
-  Options[NamePrefix + LocalName.str()] = Value;
-}
-
-void OptionsView::store(ClangTidyOptions::OptionMap &Options,
-                        StringRef LocalName, int64_t Value) const {
-  store(Options, LocalName, llvm::itostr(Value));
-}
-
-std::vector<std::string> getCheckNames(const ClangTidyOptions &Options) {
-  clang::tidy::ClangTidyContext Context(
-      llvm::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
-                                                Options));
-  ClangTidyASTConsumerFactory Factory(Context);
-  return Factory.getCheckNames();
-}
-
-ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options) {
-  clang::tidy::ClangTidyContext Context(
-      llvm::make_unique<DefaultOptionsProvider>(ClangTidyGlobalOptions(),
-                                                Options));
-  ClangTidyASTConsumerFactory Factory(Context);
-  return Factory.getCheckOptions();
-}
-
-ClangTidyStats
-runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
-             const tooling::CompilationDatabase &Compilations,
-             ArrayRef<std::string> InputFiles,
-             std::vector<ClangTidyError> *Errors, ProfileData *Profile) {
-  ClangTool Tool(Compilations, InputFiles);
-  clang::tidy::ClangTidyContext Context(std::move(OptionsProvider));
-
-  // Add extra arguments passed by the clang-tidy command-line.
-  ArgumentsAdjuster PerFileExtraArgumentsInserter =
-      [&Context](const CommandLineArguments &Args, StringRef Filename) {
-        ClangTidyOptions Opts = Context.getOptionsForFile(Filename);
-        CommandLineArguments AdjustedArgs;
-        if (Opts.ExtraArgsBefore)
-          AdjustedArgs = *Opts.ExtraArgsBefore;
-        AdjustedArgs.insert(AdjustedArgs.begin(), Args.begin(), Args.end());
-        if (Opts.ExtraArgs)
-          AdjustedArgs.insert(AdjustedArgs.end(), Opts.ExtraArgs->begin(),
-                              Opts.ExtraArgs->end());
-        return AdjustedArgs;
-      };
-
-  // Remove plugins arguments.
-  ArgumentsAdjuster PluginArgumentsRemover =
-      [&Context](const CommandLineArguments &Args, StringRef Filename) {
-        CommandLineArguments AdjustedArgs;
-        for (size_t I = 0, E = Args.size(); I < E; ++I) {
-          if (I + 4 < Args.size() && Args[I] == "-Xclang" &&
-              (Args[I + 1] == "-load" || Args[I + 1] == "-add-plugin" ||
-               StringRef(Args[I + 1]).startswith("-plugin-arg-")) &&
-              Args[I + 2] == "-Xclang") {
-            I += 3;
-          } else
-            AdjustedArgs.push_back(Args[I]);
-        }
-        return AdjustedArgs;
-      };
-
-  Tool.appendArgumentsAdjuster(PerFileExtraArgumentsInserter);
-  Tool.appendArgumentsAdjuster(PluginArgumentsRemover);
-  if (Profile)
-    Context.setCheckProfileData(Profile);
-
-  ClangTidyDiagnosticConsumer DiagConsumer(Context);
-
-  Tool.setDiagnosticConsumer(&DiagConsumer);
-
-  class ActionFactory : public FrontendActionFactory {
-  public:
-    ActionFactory(ClangTidyContext &Context) : ConsumerFactory(Context) {}
-    FrontendAction *create() override { return new Action(&ConsumerFactory); }
-
-  private:
-    class Action : public ASTFrontendAction {
-    public:
-      Action(ClangTidyASTConsumerFactory *Factory) : Factory(Factory) {}
-      std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
-                                                     StringRef File) override {
-        return Factory->CreateASTConsumer(Compiler, File);
-      }
-
-    private:
-      ClangTidyASTConsumerFactory *Factory;
-    };
-
-    ClangTidyASTConsumerFactory ConsumerFactory;
-  };
-
-  ActionFactory Factory(Context);
-  Tool.run(&Factory);
-  *Errors = Context.getErrors();
-  return Context.getStats();
-}
-
-void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix,
-                  unsigned &WarningsAsErrorsCount) {
-  ErrorReporter Reporter(Fix);
-  vfs::FileSystem &FileSystem =
-      *Reporter.getSourceManager().getFileManager().getVirtualFileSystem();
-  auto InitialWorkingDir = FileSystem.getCurrentWorkingDirectory();
-  if (!InitialWorkingDir)
-    llvm::report_fatal_error("Cannot get current working path.");
-
-  for (const ClangTidyError &Error : Errors) {
-    if (!Error.BuildDirectory.empty()) {
-      // By default, the working directory of file system is the current
-      // clang-tidy running directory.
-      //
-      // Change the directory to the one used during the analysis.
-      FileSystem.setCurrentWorkingDirectory(Error.BuildDirectory);
-    }
-    Reporter.reportDiagnostic(Error);
-    // Return to the initial directory to correctly resolve next Error.
-    FileSystem.setCurrentWorkingDirectory(InitialWorkingDir.get());
-  }
-  Reporter.Finish();
-  WarningsAsErrorsCount += Reporter.getWarningsAsErrorsCount();
-}
-
-void exportReplacements(const std::vector<ClangTidyError> &Errors,
-                        raw_ostream &OS) {
-  tooling::TranslationUnitReplacements TUR;
-  for (const ClangTidyError &Error : Errors)
-    TUR.Replacements.insert(TUR.Replacements.end(), Error.Fix.begin(),
-                            Error.Fix.end());
-
-  yaml::Output YAML(OS);
-  YAML << TUR;
-}
-
-} // namespace tidy
-} // namespace clang

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

@@ -1,236 +0,0 @@
-//===--- ClangTidy.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_CLANGTIDY_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDY_H
-
-#include "ClangTidyDiagnosticConsumer.h"
-#include "ClangTidyOptions.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/SourceManager.h"
-#include "clang/Tooling/Refactoring.h"
-#include "llvm/ADT/StringExtras.h"
-#include "llvm/Support/raw_ostream.h"
-#include <memory>
-#include <type_traits>
-#include <vector>
-
-namespace clang {
-
-class CompilerInstance;
-namespace tooling {
-class CompilationDatabase;
-}
-
-namespace tidy {
-
-/// \brief Provides access to the ``ClangTidyCheck`` options via check-local
-/// names.
-///
-/// Methods of this class prepend ``CheckName + "."`` to translate check-local
-/// option names to global option names.
-class OptionsView {
-public:
-  /// \brief Initializes the instance using \p CheckName + "." as a prefix.
-  OptionsView(StringRef CheckName,
-              const ClangTidyOptions::OptionMap &CheckOptions);
-
-  /// \brief Read a named option from the ``Context``.
-  ///
-  /// Reads the option with the check-local name \p LocalName from the
-  /// ``CheckOptions``. If the corresponding key is not present, returns
-  /// \p Default.
-  std::string get(StringRef LocalName, StringRef Default) const;
-
-  /// \brief Read a named option from the ``Context``.
-  ///
-  /// Reads the option with the check-local name \p LocalName from local or
-  /// global ``CheckOptions``. Gets local option first. If local is not present,
-  /// falls back to get global option. If global option is not present either,
-  /// returns Default.
-  std::string getLocalOrGlobal(StringRef LocalName, StringRef Default) const;
-
-  /// \brief Read a named option from the ``Context`` and parse it as an
-  /// integral type ``T``.
-  ///
-  /// Reads the option with the check-local name \p LocalName from the
-  /// ``CheckOptions``. If the corresponding key is not present, returns
-  /// \p Default.
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, T>::type
-  get(StringRef LocalName, T Default) const {
-    std::string Value = get(LocalName, "");
-    T Result = Default;
-    if (!Value.empty())
-      StringRef(Value).getAsInteger(10, Result);
-    return Result;
-  }
-
-  /// \brief Stores an option with the check-local name \p LocalName with string
-  /// value \p Value to \p Options.
-  void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
-             StringRef Value) const;
-
-  /// \brief Stores an option with the check-local name \p LocalName with
-  /// ``int64_t`` value \p Value to \p Options.
-  void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
-             int64_t Value) const;
-
-private:
-  std::string NamePrefix;
-  const ClangTidyOptions::OptionMap &CheckOptions;
-};
-
-/// \brief Base class for all clang-tidy checks.
-///
-/// To implement a ``ClangTidyCheck``, write a subclass and override some of the
-/// base class's methods. E.g. to implement a check that validates namespace
-/// declarations, override ``registerMatchers``:
-///
-/// ~~~{.cpp}
-/// void registerMatchers(ast_matchers::MatchFinder *Finder) override {
-///   Finder->addMatcher(namespaceDecl().bind("namespace"), this);
-/// }
-/// ~~~
-///
-/// and then override ``check(const MatchResult &Result)`` to do the actual
-/// check for each match.
-///
-/// A new ``ClangTidyCheck`` instance is created per translation unit.
-///
-/// FIXME: Figure out whether carrying information from one TU to another is
-/// useful/necessary.
-class ClangTidyCheck : public ast_matchers::MatchFinder::MatchCallback {
-public:
-  /// \brief Initializes the check with \p CheckName and \p Context.
-  ///
-  /// Derived classes must implement the constructor with this signature or
-  /// delegate it. If a check needs to read options, it can do this in the
-  /// constructor using the Options.get() methods below.
-  ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context)
-      : CheckName(CheckName), Context(Context),
-        Options(CheckName, Context->getOptions().CheckOptions) {
-    assert(Context != nullptr);
-    assert(!CheckName.empty());
-  }
-
-  /// \brief Override this to register ``PPCallbacks`` with ``Compiler``.
-  ///
-  /// This should be used for clang-tidy checks that analyze preprocessor-
-  /// dependent properties, e.g. the order of include directives.
-  virtual void registerPPCallbacks(CompilerInstance &Compiler) {}
-
-  /// \brief Override this to register AST matchers with \p Finder.
-  ///
-  /// This should be used by clang-tidy checks that analyze code properties that
-  /// dependent on AST knowledge.
-  ///
-  /// You can register as many matchers as necessary with \p Finder. Usually,
-  /// "this" will be used as callback, but you can also specify other callback
-  /// classes. Thereby, different matchers can trigger different callbacks.
-  ///
-  /// If you need to merge information between the different matchers, you can
-  /// store these as members of the derived class. However, note that all
-  /// matches occur in the order of the AST traversal.
-  virtual void registerMatchers(ast_matchers::MatchFinder *Finder) {}
-
-  /// \brief ``ClangTidyChecks`` that register ASTMatchers should do the actual
-  /// work in here.
-  virtual void check(const ast_matchers::MatchFinder::MatchResult &Result) {}
-
-  /// \brief Add a diagnostic with the check's name.
-  DiagnosticBuilder diag(SourceLocation Loc, StringRef Description,
-                         DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
-
-  /// \brief Should store all options supported by this check with their
-  /// current values or default values for options that haven't been overridden.
-  ///
-  /// The check should use ``Options.store()`` to store each option it supports
-  /// whether it has the default value or it has been overridden.
-  virtual void storeOptions(ClangTidyOptions::OptionMap &Options) {}
-
-private:
-  void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  StringRef getID() const override { return CheckName; }
-  std::string CheckName;
-  ClangTidyContext *Context;
-
-protected:
-  OptionsView Options;
-  /// \brief Returns the main file name of the current translation unit.
-  StringRef getCurrentMainFile() const { return Context->getCurrentFile(); }
-  /// \brief Returns the language options from the context.
-  LangOptions getLangOpts() const { return Context->getLangOpts(); }
-};
-
-class ClangTidyCheckFactories;
-
-class ClangTidyASTConsumerFactory {
-public:
-  ClangTidyASTConsumerFactory(ClangTidyContext &Context);
-
-  /// \brief Returns an ASTConsumer that runs the specified clang-tidy checks.
-  std::unique_ptr<clang::ASTConsumer>
-  CreateASTConsumer(clang::CompilerInstance &Compiler, StringRef File);
-
-  /// \brief Get the list of enabled checks.
-  std::vector<std::string> getCheckNames();
-
-  /// \brief Get the union of options from all checks.
-  ClangTidyOptions::OptionMap getCheckOptions();
-
-private:
-  typedef std::vector<std::pair<std::string, bool>> CheckersList;
-  CheckersList getCheckersControlList(GlobList &Filter);
-
-  ClangTidyContext &Context;
-  std::unique_ptr<ClangTidyCheckFactories> CheckFactories;
-};
-
-/// \brief Fills the list of check names that are enabled when the provided
-/// filters are applied.
-std::vector<std::string> getCheckNames(const ClangTidyOptions &Options);
-
-/// \brief Returns the effective check-specific options.
-///
-/// The method configures ClangTidy with the specified \p Options and collects
-/// effective options from all created checks. The returned set of options
-/// includes default check-specific options for all keys not overridden by \p
-/// Options.
-ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options);
-
-/// \brief Run a set of clang-tidy checks on a set of files.
-///
-/// \param Profile if provided, it enables check profile collection in
-/// MatchFinder, and will contain the result of the profile.
-ClangTidyStats
-runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
-             const tooling::CompilationDatabase &Compilations,
-             ArrayRef<std::string> InputFiles,
-             std::vector<ClangTidyError> *Errors,
-             ProfileData *Profile = nullptr);
-
-// FIXME: This interface will need to be significantly extended to be useful.
-// FIXME: Implement confidence levels for displaying/fixing errors.
-//
-/// \brief Displays the found \p Errors to the users. If \p Fix is true, \p
-/// Errors containing fixes are automatically applied.
-void handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix,
-                  unsigned &WarningsAsErrorsCount);
-
-/// \brief Serializes replacements into YAML and writes them to the specified
-/// output stream.
-void exportReplacements(const std::vector<ClangTidyError> &Errors,
-                        raw_ostream &OS);
-
-} // end namespace tidy
-} // end namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDY_H

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

@@ -1,573 +0,0 @@
-//===--- tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp ----------=== //
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-///  \file This file implements ClangTidyDiagnosticConsumer, ClangTidyMessage,
-///  ClangTidyContext and ClangTidyError classes.
-///
-///  This tool uses the Clang Tooling infrastructure, see
-///    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
-///  for details on setting it up with LLVM source tree.
-///
-//===----------------------------------------------------------------------===//
-
-#include "ClangTidyDiagnosticConsumer.h"
-#include "ClangTidyOptions.h"
-#include "clang/AST/ASTDiagnostic.h"
-#include "clang/Basic/DiagnosticOptions.h"
-#include "clang/Frontend/DiagnosticRenderer.h"
-#include "llvm/ADT/SmallString.h"
-#include <tuple>
-#include <vector>
-using namespace clang;
-using namespace tidy;
-
-namespace {
-class ClangTidyDiagnosticRenderer : public DiagnosticRenderer {
-public:
-  ClangTidyDiagnosticRenderer(const LangOptions &LangOpts,
-                              DiagnosticOptions *DiagOpts,
-                              ClangTidyError &Error)
-      : DiagnosticRenderer(LangOpts, DiagOpts), Error(Error) {}
-
-protected:
-  void emitDiagnosticMessage(SourceLocation Loc, PresumedLoc PLoc,
-                             DiagnosticsEngine::Level Level, StringRef Message,
-                             ArrayRef<CharSourceRange> Ranges,
-                             const SourceManager *SM,
-                             DiagOrStoredDiag Info) override {
-    // Remove check name from the message.
-    // FIXME: Remove this once there's a better way to pass check names than
-    // appending the check name to the message in ClangTidyContext::diag and
-    // using getCustomDiagID.
-    std::string CheckNameInMessage = " [" + Error.CheckName + "]";
-    if (Message.endswith(CheckNameInMessage))
-      Message = Message.substr(0, Message.size() - CheckNameInMessage.size());
-
-    ClangTidyMessage TidyMessage = Loc.isValid()
-                                       ? ClangTidyMessage(Message, *SM, Loc)
-                                       : ClangTidyMessage(Message);
-    if (Level == DiagnosticsEngine::Note) {
-      Error.Notes.push_back(TidyMessage);
-      return;
-    }
-    assert(Error.Message.Message.empty() && "Overwriting a diagnostic message");
-    Error.Message = TidyMessage;
-  }
-
-  void emitDiagnosticLoc(SourceLocation Loc, PresumedLoc PLoc,
-                         DiagnosticsEngine::Level Level,
-                         ArrayRef<CharSourceRange> Ranges,
-                         const SourceManager &SM) override {}
-
-  void emitCodeContext(SourceLocation Loc, DiagnosticsEngine::Level Level,
-                       SmallVectorImpl<CharSourceRange> &Ranges,
-                       ArrayRef<FixItHint> Hints,
-                       const SourceManager &SM) override {
-    assert(Loc.isValid());
-    for (const auto &FixIt : Hints) {
-      CharSourceRange Range = FixIt.RemoveRange;
-      assert(Range.getBegin().isValid() && Range.getEnd().isValid() &&
-             "Invalid range in the fix-it hint.");
-      assert(Range.getBegin().isFileID() && Range.getEnd().isFileID() &&
-             "Only file locations supported in fix-it hints.");
-
-      Error.Fix.insert(tooling::Replacement(SM, Range, FixIt.CodeToInsert));
-    }
-  }
-
-  void emitIncludeLocation(SourceLocation Loc, PresumedLoc PLoc,
-                           const SourceManager &SM) override {}
-
-  void emitImportLocation(SourceLocation Loc, PresumedLoc PLoc,
-                          StringRef ModuleName,
-                          const SourceManager &SM) override {}
-
-  void emitBuildingModuleLocation(SourceLocation Loc, PresumedLoc PLoc,
-                                  StringRef ModuleName,
-                                  const SourceManager &SM) override {}
-
-  void endDiagnostic(DiagOrStoredDiag D,
-                     DiagnosticsEngine::Level Level) override {
-    assert(!Error.Message.Message.empty() && "Message has not been set");
-  }
-
-private:
-  ClangTidyError &Error;
-};
-} // end anonymous namespace
-
-ClangTidyMessage::ClangTidyMessage(StringRef Message)
-    : Message(Message), FileOffset(0) {}
-
-ClangTidyMessage::ClangTidyMessage(StringRef Message,
-                                   const SourceManager &Sources,
-                                   SourceLocation Loc)
-    : Message(Message) {
-  assert(Loc.isValid() && Loc.isFileID());
-  FilePath = Sources.getFilename(Loc);
-  FileOffset = Sources.getFileOffset(Loc);
-}
-
-ClangTidyError::ClangTidyError(StringRef CheckName,
-                               ClangTidyError::Level DiagLevel,
-                               bool IsWarningAsError,
-                               StringRef BuildDirectory)
-    : CheckName(CheckName), BuildDirectory(BuildDirectory), DiagLevel(DiagLevel),
-      IsWarningAsError(IsWarningAsError) {}
-
-// Returns true if GlobList starts with the negative indicator ('-'), removes it
-// from the GlobList.
-static bool ConsumeNegativeIndicator(StringRef &GlobList) {
-  if (GlobList.startswith("-")) {
-    GlobList = GlobList.substr(1);
-    return true;
-  }
-  return false;
-}
-// Converts first glob from the comma-separated list of globs to Regex and
-// removes it and the trailing comma from the GlobList.
-static llvm::Regex ConsumeGlob(StringRef &GlobList) {
-  StringRef Glob = GlobList.substr(0, GlobList.find(',')).trim();
-  GlobList = GlobList.substr(Glob.size() + 1);
-  SmallString<128> RegexText("^");
-  StringRef MetaChars("()^$|*+?.[]\\{}");
-  for (char C : Glob) {
-    if (C == '*')
-      RegexText.push_back('.');
-    else if (MetaChars.find(C) != StringRef::npos)
-      RegexText.push_back('\\');
-    RegexText.push_back(C);
-  }
-  RegexText.push_back('$');
-  return llvm::Regex(RegexText);
-}
-
-GlobList::GlobList(StringRef Globs)
-    : Positive(!ConsumeNegativeIndicator(Globs)), Regex(ConsumeGlob(Globs)),
-      NextGlob(Globs.empty() ? nullptr : new GlobList(Globs)) {}
-
-bool GlobList::contains(StringRef S, bool Contains) {
-  if (Regex.match(S))
-    Contains = Positive;
-
-  if (NextGlob)
-    Contains = NextGlob->contains(S, Contains);
-  return Contains;
-}
-
-ClangTidyContext::ClangTidyContext(
-    std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider)
-    : DiagEngine(nullptr), OptionsProvider(std::move(OptionsProvider)),
-      Profile(nullptr) {
-  // Before the first translation unit we can get errors related to command-line
-  // parsing, use empty string for the file name in this case.
-  setCurrentFile("");
-}
-
-DiagnosticBuilder ClangTidyContext::diag(
-    StringRef CheckName, SourceLocation Loc, StringRef Description,
-    DiagnosticIDs::Level Level /* = DiagnosticIDs::Warning*/) {
-  assert(Loc.isValid());
-  unsigned ID = DiagEngine->getDiagnosticIDs()->getCustomDiagID(
-      Level, (Description + " [" + CheckName + "]").str());
-  if (CheckNamesByDiagnosticID.count(ID) == 0)
-    CheckNamesByDiagnosticID.insert(std::make_pair(ID, CheckName.str()));
-  return DiagEngine->Report(Loc, ID);
-}
-
-void ClangTidyContext::setDiagnosticsEngine(DiagnosticsEngine *Engine) {
-  DiagEngine = Engine;
-}
-
-void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
-  DiagEngine->setSourceManager(SourceMgr);
-}
-
-void ClangTidyContext::setCurrentFile(StringRef File) {
-  CurrentFile = File;
-  CurrentOptions = getOptionsForFile(CurrentFile);
-  CheckFilter.reset(new GlobList(*getOptions().Checks));
-  WarningAsErrorFilter.reset(new GlobList(*getOptions().WarningsAsErrors));
-}
-
-void ClangTidyContext::setASTContext(ASTContext *Context) {
-  DiagEngine->SetArgToStringFn(&FormatASTNodeDiagnosticArgument, Context);
-  LangOpts = Context->getLangOpts();
-}
-
-const ClangTidyGlobalOptions &ClangTidyContext::getGlobalOptions() const {
-  return OptionsProvider->getGlobalOptions();
-}
-
-const ClangTidyOptions &ClangTidyContext::getOptions() const {
-  return CurrentOptions;
-}
-
-ClangTidyOptions ClangTidyContext::getOptionsForFile(StringRef File) const {
-  // Merge options on top of getDefaults() as a safeguard against options with
-  // unset values.
-  return ClangTidyOptions::getDefaults().mergeWith(
-      OptionsProvider->getOptions(File));
-}
-
-void ClangTidyContext::setCheckProfileData(ProfileData *P) { Profile = P; }
-
-GlobList &ClangTidyContext::getChecksFilter() {
-  assert(CheckFilter != nullptr);
-  return *CheckFilter;
-}
-
-GlobList &ClangTidyContext::getWarningAsErrorFilter() {
-  assert(WarningAsErrorFilter != nullptr);
-  return *WarningAsErrorFilter;
-}
-
-/// \brief Store a \c ClangTidyError.
-void ClangTidyContext::storeError(const ClangTidyError &Error) {
-  Errors.push_back(Error);
-}
-
-StringRef ClangTidyContext::getCheckName(unsigned DiagnosticID) const {
-  llvm::DenseMap<unsigned, std::string>::const_iterator I =
-      CheckNamesByDiagnosticID.find(DiagnosticID);
-  if (I != CheckNamesByDiagnosticID.end())
-    return I->second;
-  return "";
-}
-
-ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx)
-    : Context(Ctx), LastErrorRelatesToUserCode(false),
-      LastErrorPassesLineFilter(false) {
-  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
-  Diags.reset(new DiagnosticsEngine(
-      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
-      /*ShouldOwnClient=*/false));
-  Context.setDiagnosticsEngine(Diags.get());
-}
-
-void ClangTidyDiagnosticConsumer::finalizeLastError() {
-  if (!Errors.empty()) {
-    ClangTidyError &Error = Errors.back();
-    if (!Context.getChecksFilter().contains(Error.CheckName) &&
-        Error.DiagLevel != ClangTidyError::Error) {
-      ++Context.Stats.ErrorsIgnoredCheckFilter;
-      Errors.pop_back();
-    } else if (!LastErrorRelatesToUserCode) {
-      ++Context.Stats.ErrorsIgnoredNonUserCode;
-      Errors.pop_back();
-    } else if (!LastErrorPassesLineFilter) {
-      ++Context.Stats.ErrorsIgnoredLineFilter;
-      Errors.pop_back();
-    } else {
-      ++Context.Stats.ErrorsDisplayed;
-    }
-  }
-  LastErrorRelatesToUserCode = false;
-  LastErrorPassesLineFilter = false;
-}
-
-static bool LineIsMarkedWithNOLINT(SourceManager& SM, SourceLocation Loc) {
-  bool Invalid;
-  const char *CharacterData = SM.getCharacterData(Loc, &Invalid);
-  if (!Invalid) {
-    const char *P = CharacterData;
-    while (*P != '\0' && *P != '\r' && *P != '\n')
-      ++P;
-    StringRef RestOfLine(CharacterData, P - CharacterData + 1);
-    // FIXME: Handle /\bNOLINT\b(\([^)]*\))?/ as cpplint.py does.
-    if (RestOfLine.find("NOLINT") != StringRef::npos) {
-      return true;
-    }
-  }
-  return false;
-}
-
-void ClangTidyDiagnosticConsumer::HandleDiagnostic(
-    DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
-  if (Info.getLocation().isValid() &&
-      DiagLevel != DiagnosticsEngine::Error &&
-      DiagLevel != DiagnosticsEngine::Fatal &&
-      LineIsMarkedWithNOLINT(Diags->getSourceManager(), Info.getLocation())) {
-    ++Context.Stats.ErrorsIgnoredNOLINT;
-    return;
-  }
-  // Count warnings/errors.
-  DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
-
-  if (DiagLevel == DiagnosticsEngine::Note) {
-    assert(!Errors.empty() &&
-           "A diagnostic note can only be appended to a message.");
-  } else {
-    finalizeLastError();
-    StringRef WarningOption =
-        Context.DiagEngine->getDiagnosticIDs()->getWarningOptionForDiag(
-            Info.getID());
-    std::string CheckName = !WarningOption.empty()
-                                ? ("clang-diagnostic-" + WarningOption).str()
-                                : Context.getCheckName(Info.getID()).str();
-
-    if (CheckName.empty()) {
-      // This is a compiler diagnostic without a warning option. Assign check
-      // name based on its level.
-      switch (DiagLevel) {
-      case DiagnosticsEngine::Error:
-      case DiagnosticsEngine::Fatal:
-        CheckName = "clang-diagnostic-error";
-        break;
-      case DiagnosticsEngine::Warning:
-        CheckName = "clang-diagnostic-warning";
-        break;
-      default:
-        CheckName = "clang-diagnostic-unknown";
-        break;
-      }
-    }
-
-    ClangTidyError::Level Level = ClangTidyError::Warning;
-    if (DiagLevel == DiagnosticsEngine::Error ||
-        DiagLevel == DiagnosticsEngine::Fatal) {
-      // Force reporting of Clang errors regardless of filters and non-user
-      // code.
-      Level = ClangTidyError::Error;
-      LastErrorRelatesToUserCode = true;
-      LastErrorPassesLineFilter = true;
-    }
-    bool IsWarningAsError =
-        DiagLevel == DiagnosticsEngine::Warning &&
-        Context.getWarningAsErrorFilter().contains(CheckName);
-    Errors.push_back(ClangTidyError(CheckName, Level, IsWarningAsError,
-                                    Context.getCurrentBuildDirectory()));
-  }
-
-  ClangTidyDiagnosticRenderer Converter(
-      Context.getLangOpts(), &Context.DiagEngine->getDiagnosticOptions(),
-      Errors.back());
-  SmallString<100> Message;
-  Info.FormatDiagnostic(Message);
-  SourceManager *Sources = nullptr;
-  if (Info.hasSourceManager())
-    Sources = &Info.getSourceManager();
-  Converter.emitDiagnostic(Info.getLocation(), DiagLevel, Message,
-                           Info.getRanges(), Info.getFixItHints(), Sources);
-
-  checkFilters(Info.getLocation());
-}
-
-bool ClangTidyDiagnosticConsumer::passesLineFilter(StringRef FileName,
-                                                   unsigned LineNumber) const {
-  if (Context.getGlobalOptions().LineFilter.empty())
-    return true;
-  for (const FileFilter &Filter : Context.getGlobalOptions().LineFilter) {
-    if (FileName.endswith(Filter.Name)) {
-      if (Filter.LineRanges.empty())
-        return true;
-      for (const FileFilter::LineRange &Range : Filter.LineRanges) {
-        if (Range.first <= LineNumber && LineNumber <= Range.second)
-          return true;
-      }
-      return false;
-    }
-  }
-  return false;
-}
-
-void ClangTidyDiagnosticConsumer::checkFilters(SourceLocation Location) {
-  // Invalid location may mean a diagnostic in a command line, don't skip these.
-  if (!Location.isValid()) {
-    LastErrorRelatesToUserCode = true;
-    LastErrorPassesLineFilter = true;
-    return;
-  }
-
-  const SourceManager &Sources = Diags->getSourceManager();
-  if (!*Context.getOptions().SystemHeaders &&
-      Sources.isInSystemHeader(Location))
-    return;
-
-  // FIXME: We start with a conservative approach here, but the actual type of
-  // location needed depends on the check (in particular, where this check wants
-  // to apply fixes).
-  FileID FID = Sources.getDecomposedExpansionLoc(Location).first;
-  const FileEntry *File = Sources.getFileEntryForID(FID);
-
-  // -DMACRO definitions on the command line have locations in a virtual buffer
-  // that doesn't have a FileEntry. Don't skip these as well.
-  if (!File) {
-    LastErrorRelatesToUserCode = true;
-    LastErrorPassesLineFilter = true;
-    return;
-  }
-
-  StringRef FileName(File->getName());
-  LastErrorRelatesToUserCode = LastErrorRelatesToUserCode ||
-                               Sources.isInMainFile(Location) ||
-                               getHeaderFilter()->match(FileName);
-
-  unsigned LineNumber = Sources.getExpansionLineNumber(Location);
-  LastErrorPassesLineFilter =
-      LastErrorPassesLineFilter || passesLineFilter(FileName, LineNumber);
-}
-
-llvm::Regex *ClangTidyDiagnosticConsumer::getHeaderFilter() {
-  if (!HeaderFilter)
-    HeaderFilter.reset(
-        new llvm::Regex(*Context.getOptions().HeaderFilterRegex));
-  return HeaderFilter.get();
-}
-
-void ClangTidyDiagnosticConsumer::removeIncompatibleErrors(
-    SmallVectorImpl<ClangTidyError> &Errors) const {
-  // Each error is modelled as the set of intervals in which it applies
-  // replacements. To detect overlapping replacements, we use a sweep line
-  // algorithm over these sets of intervals.
-  // An event here consists of the opening or closing of an interval. During the
-  // proccess, we maintain a counter with the amount of open intervals. If we
-  // find an endpoint of an interval and this counter is different from 0, it
-  // means that this interval overlaps with another one, so we set it as
-  // inapplicable.
-  struct Event {
-    // An event can be either the begin or the end of an interval.
-    enum EventType {
-      ET_Begin = 1,
-      ET_End = -1,
-    };
-
-    Event(unsigned Begin, unsigned End, EventType Type, unsigned ErrorId,
-          unsigned ErrorSize)
-        : Type(Type), ErrorId(ErrorId) {
-      // The events are going to be sorted by their position. In case of draw:
-      //
-      // * If an interval ends at the same position at which other interval
-      //   begins, this is not an overlapping, so we want to remove the ending
-      //   interval before adding the starting one: end events have higher
-      //   priority than begin events.
-      //
-      // * If we have several begin points at the same position, we will mark as
-      //   inapplicable the ones that we proccess later, so the first one has to
-      //   be the one with the latest end point, because this one will contain
-      //   all the other intervals. For the same reason, if we have several end
-      //   points in the same position, the last one has to be the one with the
-      //   earliest begin point. In both cases, we sort non-increasingly by the
-      //   position of the complementary.
-      //
-      // * In case of two equal intervals, the one whose error is bigger can
-      //   potentially contain the other one, so we want to proccess its begin
-      //   points before and its end points later.
-      //
-      // * Finally, if we have two equal intervals whose errors have the same
-      //   size, none of them will be strictly contained inside the other.
-      //   Sorting by ErrorId will guarantee that the begin point of the first
-      //   one will be proccessed before, disallowing the second one, and the
-      //   end point of the first one will also be proccessed before,
-      //   disallowing the first one.
-      if (Type == ET_Begin)
-        Priority = std::make_tuple(Begin, Type, -End, -ErrorSize, ErrorId);
-      else
-        Priority = std::make_tuple(End, Type, -Begin, ErrorSize, ErrorId);
-    }
-
-    bool operator<(const Event &Other) const {
-      return Priority < Other.Priority;
-    }
-
-    // Determines if this event is the begin or the end of an interval.
-    EventType Type;
-    // The index of the error to which the interval that generated this event
-    // belongs.
-    unsigned ErrorId;
-    // The events will be sorted based on this field.
-    std::tuple<unsigned, EventType, int, int, unsigned> Priority;
-  };
-
-  // Compute error sizes.
-  std::vector<int> Sizes;
-  for (const auto &Error : Errors) {
-    int Size = 0;
-    for (const auto &Replace : Error.Fix)
-      Size += Replace.getLength();
-    Sizes.push_back(Size);
-  }
-
-  // Build events from error intervals.
-  std::map<std::string, std::vector<Event>> FileEvents;
-  for (unsigned I = 0; I < Errors.size(); ++I) {
-    for (const auto &Replace : Errors[I].Fix) {
-      unsigned Begin = Replace.getOffset();
-      unsigned End = Begin + Replace.getLength();
-      const std::string &FilePath = Replace.getFilePath();
-      // FIXME: Handle empty intervals, such as those from insertions.
-      if (Begin == End)
-        continue;
-      FileEvents[FilePath].push_back(
-          Event(Begin, End, Event::ET_Begin, I, Sizes[I]));
-      FileEvents[FilePath].push_back(
-          Event(Begin, End, Event::ET_End, I, Sizes[I]));
-    }
-  }
-
-  std::vector<bool> Apply(Errors.size(), true);
-  for (auto &FileAndEvents : FileEvents) {
-    std::vector<Event> &Events = FileAndEvents.second;
-    // Sweep.
-    std::sort(Events.begin(), Events.end());
-    int OpenIntervals = 0;
-    for (const auto &Event : Events) {
-      if (Event.Type == Event::ET_End)
-        --OpenIntervals;
-      // This has to be checked after removing the interval from the count if it
-      // is an end event, or before adding it if it is a begin event.
-      if (OpenIntervals != 0)
-        Apply[Event.ErrorId] = false;
-      if (Event.Type == Event::ET_Begin)
-        ++OpenIntervals;
-    }
-    assert(OpenIntervals == 0 && "Amount of begin/end points doesn't match");
-  }
-
-  for (unsigned I = 0; I < Errors.size(); ++I) {
-    if (!Apply[I]) {
-      Errors[I].Fix.clear();
-      Errors[I].Notes.push_back(
-          ClangTidyMessage("this fix will not be applied because"
-                           " it overlaps with another fix"));
-    }
-  }
-}
-
-namespace {
-struct LessClangTidyError {
-  bool operator()(const ClangTidyError &LHS, const ClangTidyError &RHS) const {
-    const ClangTidyMessage &M1 = LHS.Message;
-    const ClangTidyMessage &M2 = RHS.Message;
-
-    return std::tie(M1.FilePath, M1.FileOffset, M1.Message) <
-           std::tie(M2.FilePath, M2.FileOffset, M2.Message);
-  }
-};
-struct EqualClangTidyError {
-  bool operator()(const ClangTidyError &LHS, const ClangTidyError &RHS) const {
-    LessClangTidyError Less;
-    return !Less(LHS, RHS) && !Less(RHS, LHS);
-  }
-};
-} // end anonymous namespace
-
-// Flushes the internal diagnostics buffer to the ClangTidyContext.
-void ClangTidyDiagnosticConsumer::finish() {
-  finalizeLastError();
-
-  std::sort(Errors.begin(), Errors.end(), LessClangTidyError());
-  Errors.erase(std::unique(Errors.begin(), Errors.end(), EqualClangTidyError()),
-               Errors.end());
-  removeIncompatibleErrors(Errors);
-
-  for (const ClangTidyError &Error : Errors)
-    Context.storeError(Error);
-  Errors.clear();
-}

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

@@ -1,293 +0,0 @@
-//===--- ClangTidyDiagnosticConsumer.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_CLANGTIDYDIAGNOSTICCONSUMER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H
-
-#include "ClangTidyOptions.h"
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Basic/SourceManager.h"
-#include "clang/Tooling/Refactoring.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/Support/Regex.h"
-#include "llvm/Support/Timer.h"
-
-namespace clang {
-
-class ASTContext;
-class CompilerInstance;
-namespace ast_matchers {
-class MatchFinder;
-}
-namespace tooling {
-class CompilationDatabase;
-}
-
-namespace tidy {
-
-/// \brief A message from a clang-tidy check.
-///
-/// Note that this is independent of a \c SourceManager.
-struct ClangTidyMessage {
-  ClangTidyMessage(StringRef Message = "");
-  ClangTidyMessage(StringRef Message, const SourceManager &Sources,
-                   SourceLocation Loc);
-  std::string Message;
-  std::string FilePath;
-  unsigned FileOffset;
-};
-
-/// \brief A detected error complete with information to display diagnostic and
-/// automatic fix.
-///
-/// This is used as an intermediate format to transport Diagnostics without a
-/// dependency on a SourceManager.
-///
-/// FIXME: Make Diagnostics flexible enough to support this directly.
-struct ClangTidyError {
-  enum Level {
-    Warning = DiagnosticsEngine::Warning,
-    Error = DiagnosticsEngine::Error
-  };
-
-  ClangTidyError(StringRef CheckName, Level DiagLevel, bool IsWarningAsError,
-                 StringRef BuildDirectory);
-
-  std::string CheckName;
-  ClangTidyMessage Message;
-  tooling::Replacements Fix;
-  SmallVector<ClangTidyMessage, 1> Notes;
-
-  // A build directory of the diagnostic source file.
-  //
-  // It's an absolute path which is `directory` field of the source file in
-  // compilation database. If users don't specify the compilation database
-  // directory, it is the current directory where clang-tidy runs.
-  //
-  // Note: it is empty in unittest.
-  std::string BuildDirectory;
-
-  Level DiagLevel;
-  bool IsWarningAsError;
-};
-
-/// \brief Read-only set of strings represented as a list of positive and
-/// negative globs. Positive globs add all matched strings to the set, negative
-/// globs remove them in the order of appearance in the list.
-class GlobList {
-public:
-  /// \brief \p GlobList is a comma-separated list of globs (only '*'
-  /// metacharacter is supported) with optional '-' prefix to denote exclusion.
-  GlobList(StringRef Globs);
-
-  /// \brief Returns \c true if the pattern matches \p S. The result is the last
-  /// matching glob's Positive flag.
-  bool contains(StringRef S) { return contains(S, false); }
-
-private:
-  bool contains(StringRef S, bool Contains);
-
-  bool Positive;
-  llvm::Regex Regex;
-  std::unique_ptr<GlobList> NextGlob;
-};
-
-/// \brief Contains displayed and ignored diagnostic counters for a ClangTidy
-/// run.
-struct ClangTidyStats {
-  ClangTidyStats()
-      : ErrorsDisplayed(0), ErrorsIgnoredCheckFilter(0), ErrorsIgnoredNOLINT(0),
-        ErrorsIgnoredNonUserCode(0), ErrorsIgnoredLineFilter(0) {}
-
-  unsigned ErrorsDisplayed;
-  unsigned ErrorsIgnoredCheckFilter;
-  unsigned ErrorsIgnoredNOLINT;
-  unsigned ErrorsIgnoredNonUserCode;
-  unsigned ErrorsIgnoredLineFilter;
-
-  unsigned errorsIgnored() const {
-    return ErrorsIgnoredNOLINT + ErrorsIgnoredCheckFilter +
-           ErrorsIgnoredNonUserCode + ErrorsIgnoredLineFilter;
-  }
-};
-
-/// \brief Container for clang-tidy profiling data.
-struct ProfileData {
-  llvm::StringMap<llvm::TimeRecord> Records;
-};
-
-/// \brief Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
-/// provided by this context.
-///
-/// A \c ClangTidyCheck always has access to the active context to report
-/// warnings like:
-/// \code
-/// Context->Diag(Loc, "Single-argument constructors must be explicit")
-///     << FixItHint::CreateInsertion(Loc, "explicit ");
-/// \endcode
-class ClangTidyContext {
-public:
-  /// \brief Initializes \c ClangTidyContext instance.
-  ClangTidyContext(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider);
-
-  /// \brief Report any errors detected using this method.
-  ///
-  /// This is still under heavy development and will likely change towards using
-  /// tablegen'd diagnostic IDs.
-  /// FIXME: Figure out a way to manage ID spaces.
-  DiagnosticBuilder diag(StringRef CheckName, SourceLocation Loc,
-                         StringRef Message,
-                         DiagnosticIDs::Level Level = DiagnosticIDs::Warning);
-
-  /// \brief Sets the \c SourceManager of the used \c DiagnosticsEngine.
-  ///
-  /// This is called from the \c ClangTidyCheck base class.
-  void setSourceManager(SourceManager *SourceMgr);
-
-  /// \brief Should be called when starting to process new translation unit.
-  void setCurrentFile(StringRef File);
-
-  /// \brief Returns the main file name of the current translation unit.
-  StringRef getCurrentFile() const { return CurrentFile; }
-
-  /// \brief Sets ASTContext for the current translation unit.
-  void setASTContext(ASTContext *Context);
-
-  /// \brief Gets the language options from the AST context.
-  const LangOptions &getLangOpts() const { return LangOpts; }
-
-  /// \brief Returns the name of the clang-tidy check which produced this
-  /// diagnostic ID.
-  StringRef getCheckName(unsigned DiagnosticID) const;
-
-  /// \brief Returns check filter for the \c CurrentFile.
-  ///
-  /// The \c CurrentFile can be changed using \c setCurrentFile.
-  GlobList &getChecksFilter();
-
-  /// \brief Returns check filter for the \c CurrentFile which
-  /// selects checks for upgrade to error.
-  GlobList &getWarningAsErrorFilter();
-
-  /// \brief Returns global options.
-  const ClangTidyGlobalOptions &getGlobalOptions() const;
-
-  /// \brief Returns options for \c CurrentFile.
-  ///
-  /// The \c CurrentFile can be changed using \c setCurrentFile.
-  const ClangTidyOptions &getOptions() const;
-
-  /// \brief Returns options for \c File. Does not change or depend on
-  /// \c CurrentFile.
-  ClangTidyOptions getOptionsForFile(StringRef File) const;
-
-  /// \brief Returns \c ClangTidyStats containing issued and ignored diagnostic
-  /// counters.
-  const ClangTidyStats &getStats() const { return Stats; }
-
-  /// \brief Returns all collected errors.
-  const std::vector<ClangTidyError> &getErrors() const { return Errors; }
-
-  /// \brief Clears collected errors.
-  void clearErrors() { Errors.clear(); }
-
-  /// \brief Set the output struct for profile data.
-  ///
-  /// Setting a non-null pointer here will enable profile collection in
-  /// clang-tidy.
-  void setCheckProfileData(ProfileData *Profile);
-  ProfileData *getCheckProfileData() const { return Profile; }
-
-  /// \brief Should be called when starting to process new translation unit.
-  void setCurrentBuildDirectory(StringRef BuildDirectory) {
-    CurrentBuildDirectory = BuildDirectory;
-  }
-
-  /// \brief Returns build directory of the current translation unit.
-  const std::string &getCurrentBuildDirectory() {
-    return CurrentBuildDirectory;
-  }
-
-private:
-  // Calls setDiagnosticsEngine() and storeError().
-  friend class ClangTidyDiagnosticConsumer;
-  friend class ClangTidyPluginAction;
-
-  /// \brief Sets the \c DiagnosticsEngine so that Diagnostics can be generated
-  /// correctly.
-  void setDiagnosticsEngine(DiagnosticsEngine *Engine);
-
-  /// \brief Store an \p Error.
-  void storeError(const ClangTidyError &Error);
-
-  std::vector<ClangTidyError> Errors;
-  DiagnosticsEngine *DiagEngine;
-  std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
-
-  std::string CurrentFile;
-  ClangTidyOptions CurrentOptions;
-  std::unique_ptr<GlobList> CheckFilter;
-  std::unique_ptr<GlobList> WarningAsErrorFilter;
-
-  LangOptions LangOpts;
-
-  ClangTidyStats Stats;
-
-  std::string CurrentBuildDirectory;
-
-  llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
-
-  ProfileData *Profile;
-};
-
-/// \brief A diagnostic consumer that turns each \c Diagnostic into a
-/// \c SourceManager-independent \c ClangTidyError.
-//
-// FIXME: If we move away from unit-tests, this can be moved to a private
-// implementation file.
-class ClangTidyDiagnosticConsumer : public DiagnosticConsumer {
-public:
-  ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx);
-
-  // FIXME: The concept of converting between FixItHints and Replacements is
-  // more generic and should be pulled out into a more useful Diagnostics
-  // library.
-  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
-                        const Diagnostic &Info) override;
-
-  /// \brief Flushes the internal diagnostics buffer to the ClangTidyContext.
-  void finish() override;
-
-private:
-  void finalizeLastError();
-
-  void removeIncompatibleErrors(SmallVectorImpl<ClangTidyError> &Errors) const;
-
-  /// \brief Returns the \c HeaderFilter constructed for the options set in the
-  /// context.
-  llvm::Regex *getHeaderFilter();
-
-  /// \brief Updates \c LastErrorRelatesToUserCode and LastErrorPassesLineFilter
-  /// according to the diagnostic \p Location.
-  void checkFilters(SourceLocation Location);
-  bool passesLineFilter(StringRef FileName, unsigned LineNumber) const;
-
-  ClangTidyContext &Context;
-  std::unique_ptr<DiagnosticsEngine> Diags;
-  SmallVector<ClangTidyError, 8> Errors;
-  std::unique_ptr<llvm::Regex> HeaderFilter;
-  bool LastErrorRelatesToUserCode;
-  bool LastErrorPassesLineFilter;
-};
-
-} // end namespace tidy
-} // end namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYDIAGNOSTICCONSUMER_H

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

@@ -1,39 +0,0 @@
-//===--- tools/extra/clang-tidy/ClangTidyModule.cpp - Clang tidy tool -----===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-///  \file Implements classes required to build clang-tidy modules.
-///
-//===----------------------------------------------------------------------===//
-
-#include "ClangTidyModule.h"
-
-namespace clang {
-namespace tidy {
-
-void ClangTidyCheckFactories::registerCheckFactory(StringRef Name,
-                                                   CheckFactory Factory) {
-  Factories[Name] = std::move(Factory);
-}
-
-void ClangTidyCheckFactories::createChecks(
-    ClangTidyContext *Context,
-    std::vector<std::unique_ptr<ClangTidyCheck>> &Checks) {
-  GlobList &Filter = Context->getChecksFilter();
-  for (const auto &Factory : Factories) {
-    if (Filter.contains(Factory.first))
-      Checks.emplace_back(Factory.second(Factory.first, Context));
-  }
-}
-
-ClangTidyOptions ClangTidyModule::getModuleOptions() {
-  return ClangTidyOptions();
-}
-
-} // namespace tidy
-} // namespace clang

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

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

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

@@ -1,26 +0,0 @@
-//===--- ClangTidyModuleRegistry.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_CLANGTIDYMODULEREGISTRY_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULEREGISTRY_H
-
-#include "ClangTidyModule.h"
-#include "llvm/Support/Registry.h"
-
-extern template class llvm::Registry<clang::tidy::ClangTidyModule>;
-
-namespace clang {
-namespace tidy {
-
-typedef llvm::Registry<ClangTidyModule> ClangTidyModuleRegistry;
-
-} // end namespace tidy
-} // end namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULEREGISTRY_H

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

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

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

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

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

@@ -1,305 +0,0 @@
-#!/usr/bin/env python
-#
-#===- add_new_check.py - clang-tidy check generator ----------*- python -*--===#
-#
-#                     The LLVM Compiler Infrastructure
-#
-# This file is distributed under the University of Illinois Open Source
-# License. See LICENSE.TXT for details.
-#
-#===------------------------------------------------------------------------===#
-
-import os
-import re
-import sys
-
-
-# Adapts the module's CMakelist file. Returns 'True' if it could add a new entry
-# and 'False' if the entry already existed.
-def adapt_cmake(module_path, check_name_camel):
-  filename = os.path.join(module_path, 'CMakeLists.txt')
-  with open(filename, 'r') as f:
-    lines = f.readlines()
-
-  cpp_file = check_name_camel + '.cpp'
-
-  # Figure out whether this check already exists.
-  for line in lines:
-    if line.strip() == cpp_file:
-      return False
-
-  print('Updating %s...' % filename)
-  with open(filename, 'wb') as f:
-    cpp_found = False
-    file_added = False
-    for line in lines:
-      cpp_line = line.strip().endswith('.cpp')
-      if (not file_added) and (cpp_line or cpp_found):
-        cpp_found = True
-        if (line.strip() > cpp_file) or (not cpp_line):
-          f.write('  ' + cpp_file + '\n')
-          file_added = True
-      f.write(line)
-
-  return True
-
-
-# Adds a header for the new check.
-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, 'wb') as f:
-    header_guard = ('LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_' + module.upper() + '_'
-                    + check_name.upper().replace('-', '_') + '_H')
-    f.write('//===--- ')
-    f.write(os.path.basename(filename))
-    f.write(' - clang-tidy')
-    f.write('-' * max(0, 43 - len(os.path.basename(filename))))
-    f.write('*- C++ -*-===//')
-    f.write("""
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef %(header_guard)s
-#define %(header_guard)s
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace %(module)s {
-
-/// FIXME: Write a short description.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/%(check_name_dashes)s.html
-class %(check_name)s : public ClangTidyCheck {
-public:
-  %(check_name)s(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace %(module)s
-} // namespace tidy
-} // namespace clang
-
-#endif // %(header_guard)s
-""" % {'header_guard': header_guard,
-       'check_name': check_name_camel,
-       'check_name_dashes': check_name_dashes,
-       'module': module})
-
-
-# Adds the implementation of the new check.
-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, 'wb') as f:
-    f.write('//===--- ')
-    f.write(os.path.basename(filename))
-    f.write(' - clang-tidy')
-    f.write('-' * max(0, 52 - len(os.path.basename(filename))))
-    f.write('-===//')
-    f.write("""
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "%(check_name)s.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace %(module)s {
-
-void %(check_name)s::registerMatchers(MatchFinder *Finder) {
-  // FIXME: Add matchers.
-  Finder->addMatcher(functionDecl().bind("x"), this);
-}
-
-void %(check_name)s::check(const MatchFinder::MatchResult &Result) {
-  // FIXME: Add callback implementation.
-  const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("x");
-  if (MatchedDecl->getName().startswith("awesome_"))
-    return;
-  diag(MatchedDecl->getLocation(), "function %%0 is insufficiently awesome")
-      << MatchedDecl
-      << FixItHint::CreateInsertion(MatchedDecl->getLocation(), "awesome_");
-}
-
-} // namespace %(module)s
-} // namespace tidy
-} // namespace clang
-""" % {'check_name': check_name_camel,
-       'module': module})
-
-
-# Modifies the module to include the new check.
-def adapt_module(module_path, module, check_name, check_name_camel):
-  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, 'wb') as f:
-    header_added = False
-    header_found = False
-    check_added = False
-    check_decl = ('    CheckFactories.registerCheck<' + check_name_camel +
-                  '>(\n        "' + module + '-' + check_name + '");\n')
-
-    for line in lines:
-      if not header_added:
-        match = re.search('#include "(.*)"', line)
-        if match:
-          header_found = True
-          if match.group(1) > check_name_camel:
-            header_added = True
-            f.write('#include "' + check_name_camel + '.h"\n')
-        elif header_found:
-          header_added = True
-          f.write('#include "' + check_name_camel + '.h"\n')
-
-      if not check_added:
-        if line.strip() == '}':
-          check_added = True
-          f.write(check_decl)
-        else:
-          match = re.search('registerCheck<(.*)>', line)
-          if match and match.group(1) > check_name_camel:
-            check_added = True
-            f.write(check_decl)
-      f.write(line)
-
-
-# Adds a test for the check.
-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 + '.cpp'))
-  print('Creating %s...' % filename)
-  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.
-void f();
-// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'f' is insufficiently awesome [%(check_name_dashes)s]
-
-// FIXME: Verify the applied fix.
-//   * Make the CHECK patterns specific enough and try to make verified lines
-//     unique to avoid incorrect matches.
-//   * Use {{}} for regular expressions.
-// CHECK-FIXES: {{^}}void awesome_f();{{$}}
-
-// FIXME: Add something that doesn't trigger the check here.
-void awesome_f2();
-""" % {'check_name_dashes': check_name_dashes})
-
-
-# Recreates the list of checks in the docs/clang-tidy/checks directory.
-def update_checks_list(clang_tidy_path):
-  docs_dir = os.path.join(clang_tidy_path, '../docs/clang-tidy/checks')
-  filename = os.path.normpath(os.path.join(docs_dir, 'list.rst'))
-  with open(filename, 'r') as f:
-    lines = f.readlines()
-  doc_files = filter(lambda s: s.endswith('.rst') and s != 'list.rst',
-                     os.listdir(docs_dir))
-  doc_files.sort()
-
-  def format_link(doc_file):
-    check_name = doc_file.replace('.rst', '')
-    with open(os.path.join(docs_dir, doc_file), 'r') as doc:
-      match = re.search('.*:http-equiv=refresh: \d+;URL=(.*).html.*',
-                        doc.read())
-      if match:
-        return '   %(check)s (redirects to %(target)s) <%(check)s>\n' % {
-            'check': check_name,
-            'target': match.group(1)
-        }
-      return '   %s\n' % check_name
-
-  checks = map(format_link, doc_files)
-
-  print('Updating %s...' % filename)
-  with open(filename, 'wb') as f:
-    for line in lines:
-      f.write(line)
-      if line.startswith('.. toctree::'):
-        f.writelines(checks)
-        break
-
-
-# Adds a documentation for the check.
-def write_docs(module_path, module, check_name):
-  check_name_dashes = 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, 'wb') as f:
-    f.write(""".. title:: clang-tidy - %(check_name_dashes)s
-
-%(check_name_dashes)s
-%(underline)s
-
-FIXME: Describe what patterns does the check detect and why. Give examples.
-""" % {'check_name_dashes': check_name_dashes,
-       'underline': '=' * len(check_name_dashes)})
-
-
-def main():
-  if len(sys.argv) == 2 and sys.argv[1] == '--update-docs':
-    update_checks_list(os.path.dirname(sys.argv[0]))
-    return
-
-  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 = 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)
-    return
-  check_name_camel = ''.join(map(lambda elem: elem.capitalize(),
-                                 check_name.split('-'))) + 'Check'
-  clang_tidy_path = os.path.dirname(sys.argv[0])
-  module_path = os.path.join(clang_tidy_path, module)
-
-  if not adapt_cmake(module_path, check_name_camel):
-    return
-  write_header(module_path, module, check_name, check_name_camel)
-  write_implementation(module_path, module, check_name_camel)
-  adapt_module(module_path, module, check_name, check_name_camel)
-  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!')
-
-
-if __name__ == '__main__':
-  main()

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

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

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

@@ -1,14 +0,0 @@
-set(LLVM_LINK_COMPONENTS support)
-
-add_clang_library(clangTidyBoostModule
-  BoostTidyModule.cpp
-  UseToStringCheck.cpp
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangLex
-  clangTidy
-  clangTidyUtils
-  )

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

@@ -1,73 +0,0 @@
-//===--- UseToStringCheck.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 "UseToStringCheck.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace boost {
-
-AST_MATCHER(Type, isStrictlyInteger) {
-  return Node.isIntegerType() && !Node.isAnyCharacterType() &&
-         !Node.isBooleanType();
-}
-
-void UseToStringCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(
-      callExpr(
-          hasDeclaration(functionDecl(
-              returns(hasDeclaration(classTemplateSpecializationDecl(
-                  hasName("std::basic_string"),
-                  hasTemplateArgument(0,
-                                      templateArgument().bind("char_type"))))),
-              hasName("boost::lexical_cast"),
-              hasParameter(0, hasType(qualType(has(substTemplateTypeParmType(
-                                  isStrictlyInteger()))))))),
-          argumentCountIs(1), unless(isInTemplateInstantiation()))
-          .bind("to_string"),
-      this);
-}
-
-void UseToStringCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Call = Result.Nodes.getNodeAs<CallExpr>("to_string");
-  auto CharType =
-      Result.Nodes.getNodeAs<TemplateArgument>("char_type")->getAsType();
-
-  StringRef StringType;
-  if (CharType->isSpecificBuiltinType(BuiltinType::Char_S) ||
-      CharType->isSpecificBuiltinType(BuiltinType::Char_U))
-    StringType = "string";
-  else if (CharType->isSpecificBuiltinType(BuiltinType::WChar_S) ||
-           CharType->isSpecificBuiltinType(BuiltinType::WChar_U))
-    StringType = "wstring";
-  else
-    return;
-
-  auto Loc = Call->getLocStart();
-  auto Diag =
-      diag(Loc, "use std::to_%0 instead of boost::lexical_cast<std::%0>")
-      << StringType;
-
-  if (Loc.isMacroID())
-    return;
-
-  Diag << FixItHint::CreateReplacement(
-      CharSourceRange::getCharRange(Call->getLocStart(),
-                                    Call->getArg(0)->getLocStart()),
-      (llvm::Twine("std::to_") + StringType + "(").str());
-}
-
-} // namespace boost
-} // namespace tidy
-} // namespace clang

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

@@ -1,37 +0,0 @@
-//===--- UseToStringCheck.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_BOOST_USE_TO_STRING_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BOOST_USE_TO_STRING_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace boost {
-
-/// Finds calls to ``boost::lexical_cast<std::string>`` and
-/// ``boost::lexical_cast<std::wstring>`` and replaces them with
-/// ``std::to_string`` and ``std::to_wstring`` calls.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/boost-use-to-string.html
-class UseToStringCheck : public ClangTidyCheck {
-public:
-  UseToStringCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace boost
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BOOST_USE_TO_STRING_H

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

@@ -1,91 +0,0 @@
-//===--- CERTTidyModule.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 "../google/UnnamedNamespaceInHeaderCheck.h"
-#include "../misc/MoveConstructorInitCheck.h"
-#include "../misc/NewDeleteOverloadsCheck.h"
-#include "../misc/NonCopyableObjects.h"
-#include "../misc/StaticAssertCheck.h"
-#include "../misc/ThrowByValueCatchByReferenceCheck.h"
-#include "CommandProcessorCheck.h"
-#include "FloatLoopCounter.h"
-#include "SetLongJmpCheck.h"
-#include "StaticObjectExceptionCheck.h"
-#include "StrToNumCheck.h"
-#include "ThrownExceptionTypeCheck.h"
-#include "VariadicFunctionDefCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-class CERTModule : public ClangTidyModule {
-public:
-  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    // C++ checkers
-    // DCL
-    CheckFactories.registerCheck<VariadicFunctionDefCheck>(
-        "cert-dcl50-cpp");
-    CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
-        "cert-dcl54-cpp");
-    CheckFactories.registerCheck<google::build::UnnamedNamespaceInHeaderCheck>(
-        "cert-dcl59-cpp");
-    // OOP
-    CheckFactories.registerCheck<misc::MoveConstructorInitCheck>(
-        "cert-oop11-cpp");
-    // ERR
-    CheckFactories.registerCheck<SetLongJmpCheck>(
-        "cert-err52-cpp");
-    CheckFactories.registerCheck<StaticObjectExceptionCheck>(
-        "cert-err58-cpp");
-    CheckFactories.registerCheck<ThrownExceptionTypeCheck>(
-        "cert-err60-cpp");
-    CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(
-        "cert-err61-cpp");
-
-    // C checkers
-    // DCL
-    CheckFactories.registerCheck<misc::StaticAssertCheck>(
-        "cert-dcl03-c");
-    // ENV
-    CheckFactories.registerCheck<CommandProcessorCheck>(
-        "cert-env33-c");
-    // FLP
-    CheckFactories.registerCheck<FloatLoopCounter>(
-        "cert-flp30-c");
-    // FIO
-    CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>(
-        "cert-fio38-c");
-    // ERR
-    CheckFactories.registerCheck<StrToNumCheck>(
-        "cert-err34-c");
-  }
-  ClangTidyOptions getModuleOptions() override {
-    ClangTidyOptions Options;
-    Options.CheckOptions["cert-oop11-cpp.UseCERTSemantics"] = "1";
-    return Options;
-  }
-};
-
-} // namespace cert
-
-// Register the MiscTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<cert::CERTModule>
-X("cert-module",
-  "Adds lint checks corresponding to CERT secure coding guidelines.");
-
-// This anchor is used to force the linker to link in the generated object file
-// and thus register the CERTModule.
-volatile int CERTModuleAnchorSource = 0;
-
-} // namespace tidy
-} // namespace clang

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

@@ -1,23 +0,0 @@
-set(LLVM_LINK_COMPONENTS support)
-
-add_clang_library(clangTidyCERTModule
-  CERTTidyModule.cpp
-  CommandProcessorCheck.cpp
-  FloatLoopCounter.cpp
-  SetLongJmpCheck.cpp
-  StaticObjectExceptionCheck.cpp
-  StrToNumCheck.cpp
-  ThrownExceptionTypeCheck.cpp
-  VariadicFunctionDefCheck.cpp
-
-  LINK_LIBS
-  clangAnalysis
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangLex
-  clangTidy
-  clangTidyGoogleModule
-  clangTidyMiscModule
-  clangTidyUtils
-  )

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

@@ -1,45 +0,0 @@
-//===--- Env33CCheck.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 "CommandProcessorCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-void CommandProcessorCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      callExpr(
-          callee(functionDecl(anyOf(hasName("::system"), hasName("::popen"),
-                                    hasName("::_popen")))
-                     .bind("func")),
-          // Do not diagnose when the call expression passes a null pointer
-          // constant to system(); that only checks for the presence of a
-          // command processor, which is not a security risk by itself.
-          unless(callExpr(callee(functionDecl(hasName("::system"))),
-                          argumentCountIs(1),
-                          hasArgument(0, nullPointerConstant()))))
-          .bind("expr"),
-      this);
-}
-
-void CommandProcessorCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Fn = Result.Nodes.getNodeAs<FunctionDecl>("func");
-  const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr");
-
-  diag(E->getExprLoc(), "calling %0 uses a command processor") << Fn;
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

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

@@ -1,38 +0,0 @@
-//===--- CommandInterpreterCheck.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_COMMAND_PROCESSOR_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_COMMAND_PROCESSOR_CHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// Execution of a command processor can lead to security vulnerabilities,
-/// and is generally not required. Instead, prefer to launch executables
-/// directly via mechanisms that give you more control over what executable is
-/// actually launched.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-env33-c.html
-class CommandProcessorCheck : public ClangTidyCheck {
-public:
-  CommandProcessorCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_COMMAND_PROCESSOR_CHECK_H

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

@@ -1,35 +0,0 @@
-//===--- FloatLoopCounter.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 "FloatLoopCounter.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-void FloatLoopCounter::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      forStmt(hasIncrement(expr(hasType(realFloatingPointType())))).bind("for"),
-      this);
-}
-
-void FloatLoopCounter::check(const MatchFinder::MatchResult &Result) {
-  const auto *FS = Result.Nodes.getNodeAs<ForStmt>("for");
-
-  diag(FS->getInc()->getExprLoc(), "loop induction expression should not have "
-                                   "floating-point type");
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

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

@@ -1,37 +0,0 @@
-//===--- FloatLoopCounter.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_FLOAT_LOOP_COUNTER_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_FLOAT_LOOP_COUNTER_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// This check diagnoses when the loop induction expression of a for loop has
-/// floating-point type. The check corresponds to:
-/// https://www.securecoding.cert.org/confluence/display/c/FLP30-C.+Do+not+use+floating-point+variables+as+loop+counters
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-flp30-c.html
-class FloatLoopCounter : public ClangTidyCheck {
-public:
-  FloatLoopCounter(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_FLOAT_LOOP_COUNTER_H

clang-tools-extra/clang-tidy/cert/LICENSE.TXT

@@ -1,22 +0,0 @@
-------------------------------------------------------------------------------
-clang-tidy CERT Files
-------------------------------------------------------------------------------
-All clang-tidy files are licensed under the LLVM license with the following
-additions:
-
-Any file referencing a CERT Secure Coding guideline:
-Please allow this letter to serve as confirmation that open source projects on
-http://llvm.org are permitted to link via hypertext to the CERT(R) secure coding
-guidelines available at https://www.securecoding.cert.org.   
-
-The foregoing is permitted by the Terms of Use as follows:
-"Linking to the Service
-Because we update many of our Web documents regularly, we would prefer that you
-link to our Web pages whenever possible rather than reproduce them. It is not
-necessary to request permission to make referential hypertext links to The
-Service."
-http://www.sei.cmu.edu/legal/ip/index.cfm.
-
-Please allow this letter to also confirm that no formal permission is required
-to reproduce the title of the content being linked to, nor to reproduce any
-de Minimis description of such content.

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

@@ -1,79 +0,0 @@
-//===--- SetLongJmpCheck.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 "SetLongJmpCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Lex/PPCallbacks.h"
-#include "clang/Lex/Preprocessor.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-const char SetLongJmpCheck::DiagWording[] =
-    "do not call %0; consider using exception handling instead";
-
-namespace {
-class SetJmpMacroCallbacks : public PPCallbacks {
-  SetLongJmpCheck &Check;
-
-public:
-  explicit SetJmpMacroCallbacks(SetLongJmpCheck &Check) : Check(Check) {}
-
-  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
-                    SourceRange Range, const MacroArgs *Args) override {
-    const auto *II = MacroNameTok.getIdentifierInfo();
-    if (!II)
-      return;
-
-    if (II->getName() == "setjmp")
-      Check.diag(Range.getBegin(), Check.DiagWording) << II;
-  }
-};
-} // namespace
-
-void SetLongJmpCheck::registerPPCallbacks(CompilerInstance &Compiler) {
-  // This checker only applies to C++, where exception handling is a superior
-  // solution to setjmp/longjmp calls.
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  // Per [headers]p5, setjmp must be exposed as a macro instead of a function,
-  // despite the allowance in C for setjmp to also be an extern function.
-  Compiler.getPreprocessor().addPPCallbacks(
-      llvm::make_unique<SetJmpMacroCallbacks>(*this));
-}
-
-void SetLongJmpCheck::registerMatchers(MatchFinder *Finder) {
-  // This checker only applies to C++, where exception handling is a superior
-  // solution to setjmp/longjmp calls.
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  // In case there is an implementation that happens to define setjmp as a
-  // function instead of a macro, this will also catch use of it. However, we
-  // are primarily searching for uses of longjmp.
-  Finder->addMatcher(callExpr(callee(functionDecl(anyOf(hasName("setjmp"),
-                                                        hasName("longjmp")))))
-                         .bind("expr"),
-                     this);
-}
-
-void SetLongJmpCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr");
-  diag(E->getExprLoc(), DiagWording) << cast<NamedDecl>(E->getCalleeDecl());
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

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

@@ -1,38 +0,0 @@
-//===--- SetLongJmpCheck.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_SETLONGJMPCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_SETLONGJMPCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// Guards against use of setjmp/longjmp in C++ code
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-err52-cpp.html
-class SetLongJmpCheck : public ClangTidyCheck {
-public:
-  SetLongJmpCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-  void registerPPCallbacks(CompilerInstance &Compiler) override;
-
-  static const char DiagWording[];
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_SETLONGJMPCHECK_H

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

@@ -1,50 +0,0 @@
-//===--- StaticObjectExceptionCheck.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 "StaticObjectExceptionCheck.h"
-#include "../utils/Matchers.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-void StaticObjectExceptionCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  // Match any static or thread_local variable declaration that is initialized
-  // with a constructor that can throw.
-  Finder->addMatcher(
-      varDecl(anyOf(hasThreadStorageDuration(), hasStaticStorageDuration()),
-              hasInitializer(cxxConstructExpr(hasDeclaration(
-                  cxxConstructorDecl(unless(isNoThrow()))
-                      .bind("ctor")))))
-          .bind("var"),
-      this);
-}
-
-void StaticObjectExceptionCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *VD = Result.Nodes.getNodeAs<VarDecl>("var");
-  const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
-
-  diag(VD->getLocation(),
-       "construction of %0 with %select{static|thread_local}1 storage "
-       "duration may throw an exception that cannot be caught")
-      << VD << (VD->getStorageDuration() == SD_Static ? 0 : 1);
-  diag(Ctor->getLocation(), "possibly throwing constructor declared here",
-       DiagnosticIDs::Note);
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- StaticObjectExceptionCheck.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_ERR58_CPP_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_ERR58_CPP_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// Checks whether the constructor for a static or thread_local object will
-/// throw.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-err58-cpp.html
-class StaticObjectExceptionCheck : public ClangTidyCheck {
-public:
-  StaticObjectExceptionCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_ERR58_CPP_H

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

@@ -1,235 +0,0 @@
-//===--- Err34CCheck.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 "StrToNumCheck.h"
-#include "clang/Analysis/Analyses/FormatString.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "llvm/ADT/StringSwitch.h"
-#include <cassert>
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-void StrToNumCheck::registerMatchers(MatchFinder *Finder) {
-  // Match any function call to the C standard library string conversion
-  // functions that do no error checking.
-  Finder->addMatcher(
-      callExpr(
-          callee(functionDecl(anyOf(
-              functionDecl(hasAnyName("::atoi", "::atof", "::atol", "::atoll"))
-                  .bind("converter"),
-              functionDecl(hasAnyName("::scanf", "::sscanf", "::fscanf",
-                                      "::vfscanf", "::vscanf", "::vsscanf"))
-                  .bind("formatted")))))
-          .bind("expr"),
-      this);
-}
-
-namespace {
-enum class ConversionKind {
-  None,
-  ToInt,
-  ToUInt,
-  ToLongInt,
-  ToLongUInt,
-  ToIntMax,
-  ToUIntMax,
-  ToFloat,
-  ToDouble,
-  ToLongDouble
-};
-
-ConversionKind ClassifyConversionFunc(const FunctionDecl *FD) {
-  return llvm::StringSwitch<ConversionKind>(FD->getName())
-      .Cases("atoi", "atol", ConversionKind::ToInt)
-      .Case("atoll", ConversionKind::ToLongInt)
-      .Case("atof", ConversionKind::ToDouble)
-      .Default(ConversionKind::None);
-}
-
-ConversionKind ClassifyFormatString(StringRef Fmt, const LangOptions &LO,
-                                    const TargetInfo &TI) {
-  // Scan the format string for the first problematic format specifier, then
-  // report that as the conversion type. This will miss additional conversion
-  // specifiers, but that is acceptable behavior.
-
-  class Handler : public analyze_format_string::FormatStringHandler {
-    ConversionKind CK;
-
-    bool HandleScanfSpecifier(const analyze_scanf::ScanfSpecifier &FS,
-                              const char *startSpecifier,
-                              unsigned specifierLen) override {
-      // If we just consume the argument without assignment, we don't care
-      // about it having conversion errors.
-      if (!FS.consumesDataArgument())
-        return true;
-
-      // Get the conversion specifier and use it to determine the conversion
-      // kind.
-      analyze_scanf::ScanfConversionSpecifier SCS = FS.getConversionSpecifier();
-      if (SCS.isIntArg()) {
-        switch (FS.getLengthModifier().getKind()) {
-        case analyze_scanf::LengthModifier::AsLongLong:
-          CK = ConversionKind::ToLongInt;
-          break;
-        case analyze_scanf::LengthModifier::AsIntMax:
-          CK = ConversionKind::ToIntMax;
-          break;
-        default:
-          CK = ConversionKind::ToInt;
-          break;
-        }
-      } else if (SCS.isUIntArg()) {
-        switch (FS.getLengthModifier().getKind()) {
-        case analyze_scanf::LengthModifier::AsLongLong:
-          CK = ConversionKind::ToLongUInt;
-          break;
-        case analyze_scanf::LengthModifier::AsIntMax:
-          CK = ConversionKind::ToUIntMax;
-          break;
-        default:
-          CK = ConversionKind::ToUInt;
-          break;
-        }
-      } else if (SCS.isDoubleArg()) {
-        switch (FS.getLengthModifier().getKind()) {
-        case analyze_scanf::LengthModifier::AsLongDouble:
-          CK = ConversionKind::ToLongDouble;
-          break;
-        case analyze_scanf::LengthModifier::AsLong:
-          CK = ConversionKind::ToDouble;
-          break;
-        default:
-          CK = ConversionKind::ToFloat;
-          break;
-        }
-      }
-
-      // Continue if we have yet to find a conversion kind that we care about.
-      return CK == ConversionKind::None;
-    }
-
-  public:
-    Handler() : CK(ConversionKind::None) {}
-
-    ConversionKind get() const { return CK; }
-  };
-
-  Handler H;
-  analyze_format_string::ParseScanfString(H, Fmt.begin(), Fmt.end(), LO, TI);
-  
-  return H.get();
-}
-
-StringRef ClassifyConversionType(ConversionKind K) {
-  switch (K) {
-  case ConversionKind::None:
-    assert(false && "Unexpected conversion kind");
-  case ConversionKind::ToInt:
-  case ConversionKind::ToLongInt:
-  case ConversionKind::ToIntMax:
-    return "an integer value";
-  case ConversionKind::ToUInt:
-  case ConversionKind::ToLongUInt:
-  case ConversionKind::ToUIntMax:
-    return "an unsigned integer value";
-  case ConversionKind::ToFloat:
-  case ConversionKind::ToDouble:
-  case ConversionKind::ToLongDouble:
-    return "a floating-point value";
-  }
-  llvm_unreachable("Unknown conversion kind");
-}
-
-StringRef ClassifyReplacement(ConversionKind K) {
-  switch (K) {
-  case ConversionKind::None:
-    assert(false && "Unexpected conversion kind");
-  case ConversionKind::ToInt:
-    return "strtol";
-  case ConversionKind::ToUInt:
-    return "strtoul";
-  case ConversionKind::ToIntMax:
-    return "strtoimax";
-  case ConversionKind::ToLongInt:
-    return "strtoll";
-  case ConversionKind::ToLongUInt:
-    return "strtoull";
-  case ConversionKind::ToUIntMax:
-    return "strtoumax";
-  case ConversionKind::ToFloat:
-    return "strtof";
-  case ConversionKind::ToDouble:
-    return "strtod";
-  case ConversionKind::ToLongDouble:
-    return "strtold";
-  }
-  llvm_unreachable("Unknown conversion kind");
-}
-} // unnamed namespace
-
-void StrToNumCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Call = Result.Nodes.getNodeAs<CallExpr>("expr");
-  const FunctionDecl *FuncDecl = nullptr;
-  ConversionKind Conversion;
-
-  if (const auto *ConverterFunc =
-          Result.Nodes.getNodeAs<FunctionDecl>("converter")) {
-    // Converter functions are always incorrect to use.
-    FuncDecl = ConverterFunc;
-    Conversion = ClassifyConversionFunc(ConverterFunc);
-  } else if (const auto *FFD =
-                 Result.Nodes.getNodeAs<FunctionDecl>("formatted")) {
-    StringRef FmtStr;
-    // The format string comes from the call expression and depends on which
-    // flavor of scanf is called.
-    // Index 0: scanf, vscanf, Index 1: fscanf, sscanf, vfscanf, vsscanf.
-    unsigned Idx =
-        (FFD->getName() == "scanf" || FFD->getName() == "vscanf") ? 0 : 1;
-
-    // Given the index, see if the call expression argument at that index is
-    // a string literal.
-    if (Call->getNumArgs() < Idx)
-      return;
-
-    if (const Expr *Arg = Call->getArg(Idx)->IgnoreParenImpCasts()) {
-      if (const auto *SL = dyn_cast<StringLiteral>(Arg)) {
-        FmtStr = SL->getString();
-      }
-    }
-
-    // If we could not get the format string, bail out.
-    if (FmtStr.empty())
-      return;
-
-    // Formatted input functions need further checking of the format string to
-    // determine whether a problematic conversion may be happening.
-    Conversion = ClassifyFormatString(FmtStr, Result.Context->getLangOpts(),
-                                      Result.Context->getTargetInfo());
-    if (Conversion != ConversionKind::None)
-      FuncDecl = FFD;
-  }
-
-  if (!FuncDecl)
-    return;
-
-  diag(Call->getExprLoc(),
-       "%0 used to convert a string to %1, but function will not report "
-       "conversion errors; consider using '%2' instead")
-      << FuncDecl << ClassifyConversionType(Conversion)
-      << ClassifyReplacement(Conversion);
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- StrToNumCheck.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_STRTONUMCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_STRTONUMCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// Guards against use of string conversion functions that do not have
-/// reasonable error handling for conversion errors.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-err34-c.html
-class StrToNumCheck : public ClangTidyCheck {
-public:
-  StrToNumCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_STRTONUMCHECK_H

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

@@ -1,41 +0,0 @@
-//===--- ThrownExceptionTypeCheck.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 "ThrownExceptionTypeCheck.h"
-#include "../utils/Matchers.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(
-      cxxThrowExpr(has(ignoringParenImpCasts(
-          cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
-                               isCopyConstructor(), unless(isNoThrow()))))
-              .bind("expr")))),
-      this);
-}
-
-void ThrownExceptionTypeCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
-  diag(E->getExprLoc(),
-       "thrown exception type is not nothrow copy constructible");
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

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

@@ -1,35 +0,0 @@
-//===--- ThrownExceptionTypeCheck.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_THROWNEXCEPTIONTYPECHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_THROWNEXCEPTIONTYPECHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// Checks whether a thrown object is nothrow copy constructible.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-err60-cpp.html
-class ThrownExceptionTypeCheck : public ClangTidyCheck {
-public:
-  ThrownExceptionTypeCheck(StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_THROWNEXCEPTIONTYPECHECK_H

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

@@ -1,42 +0,0 @@
-//===--- VariadicfunctiondefCheck.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 "VariadicFunctionDefCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-void VariadicFunctionDefCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  // We only care about function *definitions* that are variadic, and do not
-  // have extern "C" language linkage.
-  Finder->addMatcher(
-      functionDecl(isDefinition(), isVariadic(), unless(isExternC()))
-          .bind("func"),
-      this);
-}
-
-void VariadicFunctionDefCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("func");
-
-  diag(FD->getLocation(),
-       "do not define a C-style variadic function; consider using a function "
-       "parameter pack or currying instead");
-}
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang

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

@@ -1,35 +0,0 @@
-//===--- VariadicFunctionDefCheck.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_VARIADICFUNCTIONDEF_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_VARIADICFUNCTIONDEF_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cert {
-
-/// Guards against any C-style variadic function definitions (not declarations).
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cert-dcl50-cpp.html
-class VariadicFunctionDefCheck : public ClangTidyCheck {
-public:
-  VariadicFunctionDefCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cert
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_VARIADICFUNCTIONDEF_H

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

@@ -1,26 +0,0 @@
-set(LLVM_LINK_COMPONENTS support)
-
-add_clang_library(clangTidyCppCoreGuidelinesModule
-  CppCoreGuidelinesTidyModule.cpp
-  InterfacesGlobalInitCheck.cpp
-  ProBoundsArrayToPointerDecayCheck.cpp
-  ProBoundsConstantArrayIndexCheck.cpp
-  ProBoundsPointerArithmeticCheck.cpp
-  ProTypeConstCastCheck.cpp
-  ProTypeCstyleCastCheck.cpp
-  ProTypeMemberInitCheck.cpp
-  ProTypeReinterpretCastCheck.cpp
-  ProTypeStaticCastDowncastCheck.cpp
-  ProTypeUnionAccessCheck.cpp
-  ProTypeVarargCheck.cpp
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangLex
-  clangTidy
-  clangTidyMiscModule
-  clangTidyUtils
-  clangTooling
-  )

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

@@ -1,72 +0,0 @@
-//===--- CppCoreGuidelinesModule.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 "../misc/UnconventionalAssignOperatorCheck.h"
-#include "InterfacesGlobalInitCheck.h"
-#include "ProBoundsArrayToPointerDecayCheck.h"
-#include "ProBoundsConstantArrayIndexCheck.h"
-#include "ProBoundsPointerArithmeticCheck.h"
-#include "ProTypeConstCastCheck.h"
-#include "ProTypeCstyleCastCheck.h"
-#include "ProTypeMemberInitCheck.h"
-#include "ProTypeReinterpretCastCheck.h"
-#include "ProTypeStaticCastDowncastCheck.h"
-#include "ProTypeUnionAccessCheck.h"
-#include "ProTypeVarargCheck.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// A module containing checks of the C++ Core Guidelines
-class CppCoreGuidelinesModule : public ClangTidyModule {
-public:
-  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    CheckFactories.registerCheck<InterfacesGlobalInitCheck>(
-        "cppcoreguidelines-interfaces-global-init");
-    CheckFactories.registerCheck<ProBoundsArrayToPointerDecayCheck>(
-        "cppcoreguidelines-pro-bounds-array-to-pointer-decay");
-    CheckFactories.registerCheck<ProBoundsConstantArrayIndexCheck>(
-        "cppcoreguidelines-pro-bounds-constant-array-index");
-    CheckFactories.registerCheck<ProBoundsPointerArithmeticCheck>(
-        "cppcoreguidelines-pro-bounds-pointer-arithmetic");
-    CheckFactories.registerCheck<ProTypeConstCastCheck>(
-        "cppcoreguidelines-pro-type-const-cast");
-    CheckFactories.registerCheck<ProTypeCstyleCastCheck>(
-        "cppcoreguidelines-pro-type-cstyle-cast");
-    CheckFactories.registerCheck<ProTypeMemberInitCheck>(
-        "cppcoreguidelines-pro-type-member-init");
-    CheckFactories.registerCheck<ProTypeReinterpretCastCheck>(
-        "cppcoreguidelines-pro-type-reinterpret-cast");
-    CheckFactories.registerCheck<ProTypeStaticCastDowncastCheck>(
-        "cppcoreguidelines-pro-type-static-cast-downcast");
-    CheckFactories.registerCheck<ProTypeUnionAccessCheck>(
-        "cppcoreguidelines-pro-type-union-access");
-    CheckFactories.registerCheck<ProTypeVarargCheck>(
-        "cppcoreguidelines-pro-type-vararg");
-    CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>(
-        "cppcoreguidelines-c-copy-assignment-signature");
-  }
-};
-
-// Register the LLVMTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<CppCoreGuidelinesModule>
-    X("cppcoreguidelines-module", "Adds checks for the C++ Core Guidelines.");
-
-} // namespace cppcoreguidelines
-
-// This anchor is used to force the linker to link in the generated object file
-// and thus register the CppCoreGuidelinesModule.
-volatile int CppCoreGuidelinesModuleAnchorSource = 0;
-
-} // namespace tidy
-} // namespace clang

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

@@ -1,59 +0,0 @@
-//===--- InterfacesGlobalInitCheck.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 "InterfacesGlobalInitCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-void InterfacesGlobalInitCheck::registerMatchers(MatchFinder *Finder) {
-  const auto IsGlobal =
-      allOf(hasGlobalStorage(),
-            hasDeclContext(anyOf(translationUnitDecl(), // Global scope.
-                                 namespaceDecl(),       // Namespace scope.
-                                 recordDecl())),        // Class scope.
-            unless(isConstexpr()));
-
-  const auto ReferencesUndefinedGlobalVar = declRefExpr(hasDeclaration(
-      varDecl(IsGlobal, unless(isDefinition())).bind("referencee")));
-
-  Finder->addMatcher(
-      varDecl(IsGlobal, isDefinition(),
-              hasInitializer(expr(hasDescendant(ReferencesUndefinedGlobalVar))))
-          .bind("var"),
-      this);
-}
-
-void InterfacesGlobalInitCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *const Var = Result.Nodes.getNodeAs<VarDecl>("var");
-  // For now assume that people who write macros know what they're doing.
-  if (Var->getLocation().isMacroID())
-    return;
-  const auto *const Referencee = Result.Nodes.getNodeAs<VarDecl>("referencee");
-  // If the variable has been defined, we're good.
-  const auto *const ReferenceeDef = Referencee->getDefinition();
-  if (ReferenceeDef != nullptr &&
-      Result.SourceManager->isBeforeInTranslationUnit(
-          ReferenceeDef->getLocation(), Var->getLocation())) {
-    return;
-  }
-  diag(Var->getLocation(),
-       "initializing non-local variable with non-const expression depending on "
-       "uninitialized non-local variable %0")
-      << Referencee;
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,35 +0,0 @@
-//===--- InterfacesGlobalInitCheck.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_INTERFACES_GLOBAL_INIT_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_INTERFACES_GLOBAL_INIT_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// Flags possible initialization order issues of static variables.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-interfaces-global-init.html
-class InterfacesGlobalInitCheck : public ClangTidyCheck {
-public:
-  InterfacesGlobalInitCheck(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_INTERFACES_GLOBAL_INIT_H

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

@@ -1,80 +0,0 @@
-//===--- ProBoundsArrayToPointerDecayCheck.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 "ProBoundsArrayToPointerDecayCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-AST_MATCHER_P(CXXForRangeStmt, hasRangeBeginEndStmt,
-              ast_matchers::internal::Matcher<DeclStmt>, InnerMatcher) {
-  for (const DeclStmt *Stmt : {Node.getBeginStmt(), Node.getEndStmt()})
-    if (Stmt != nullptr && InnerMatcher.matches(*Stmt, Finder, Builder))
-      return true;
-  return false;
-}
-
-AST_MATCHER(Stmt, isInsideOfRangeBeginEndStmt) {
-  return stmt(hasAncestor(cxxForRangeStmt(
-                  hasRangeBeginEndStmt(hasDescendant(equalsNode(&Node))))))
-      .matches(Node, Finder, Builder);
-}
-
-AST_MATCHER_P(Expr, hasParentIgnoringImpCasts,
-              ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
-  const Expr *E = &Node;
-  do {
-    ASTContext::DynTypedNodeList Parents =
-        Finder->getASTContext().getParents(*E);
-    if (Parents.size() != 1)
-      return false;
-    E = Parents[0].get<Expr>();
-    if (!E)
-      return false;
-  } while (isa<ImplicitCastExpr>(E));
-
-  return InnerMatcher.matches(*E, Finder, Builder);
-}
-
-void ProBoundsArrayToPointerDecayCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  // The only allowed array to pointer decay
-  // 1) just before array subscription
-  // 2) inside a range-for over an array
-  // 3) if it converts a string literal to a pointer
-  Finder->addMatcher(
-      implicitCastExpr(unless(hasParent(arraySubscriptExpr())),
-                       unless(hasParentIgnoringImpCasts(explicitCastExpr())),
-                       unless(isInsideOfRangeBeginEndStmt()),
-                       unless(hasSourceExpression(stringLiteral())))
-          .bind("cast"),
-      this);
-}
-
-void ProBoundsArrayToPointerDecayCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  const auto *MatchedCast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast");
-  if (MatchedCast->getCastKind() != CK_ArrayToPointerDecay)
-    return;
-
-  diag(MatchedCast->getExprLoc(), "do not implicitly decay an array into a "
-                                  "pointer; consider using gsl::array_view or "
-                                  "an explicit cast instead");
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,35 +0,0 @@
-//===--- ProBoundsArrayToPointerDecayCheck.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_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-	
-/// This check flags all array to pointer decays
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-array-to-pointer-decay.html
-class ProBoundsArrayToPointerDecayCheck : public ClangTidyCheck {
-public:
-  ProBoundsArrayToPointerDecayCheck(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_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H

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

@@ -1,138 +0,0 @@
-//===--- ProBoundsConstantArrayIndexCheck.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 "ProBoundsConstantArrayIndexCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Lex/Preprocessor.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-ProBoundsConstantArrayIndexCheck::ProBoundsConstantArrayIndexCheck(
-    StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")),
-      IncludeStyle(utils::IncludeSorter::parseIncludeStyle(
-          Options.get("IncludeStyle", "llvm"))) {}
-
-void ProBoundsConstantArrayIndexCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "GslHeader", GslHeader);
-  Options.store(Opts, "IncludeStyle", IncludeStyle);
-}
-
-void ProBoundsConstantArrayIndexCheck::registerPPCallbacks(
-    CompilerInstance &Compiler) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Inserter.reset(new utils::IncludeInserter(
-      Compiler.getSourceManager(), Compiler.getLangOpts(), IncludeStyle));
-  Compiler.getPreprocessor().addPPCallbacks(Inserter->CreatePPCallbacks());
-}
-
-void ProBoundsConstantArrayIndexCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(arraySubscriptExpr(hasBase(ignoringImpCasts(hasType(
-                                            constantArrayType().bind("type")))),
-                                        hasIndex(expr().bind("index")))
-                         .bind("expr"),
-                     this);
-
-  Finder->addMatcher(
-      cxxOperatorCallExpr(
-          hasOverloadedOperatorName("[]"),
-          hasArgument(
-              0, hasType(cxxRecordDecl(hasName("::std::array")).bind("type"))),
-          hasArgument(1, expr().bind("index")))
-          .bind("expr"),
-      this);
-}
-
-void ProBoundsConstantArrayIndexCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  const auto *Matched = Result.Nodes.getNodeAs<Expr>("expr");
-  const auto *IndexExpr = Result.Nodes.getNodeAs<Expr>("index");
-
-  if (IndexExpr->isValueDependent())
-    return; // We check in the specialization.
-
-  llvm::APSInt Index;
-  if (!IndexExpr->isIntegerConstantExpr(Index, *Result.Context, nullptr,
-                                        /*isEvaluated=*/true)) {
-    SourceRange BaseRange;
-    if (const auto *ArraySubscriptE = dyn_cast<ArraySubscriptExpr>(Matched))
-      BaseRange = ArraySubscriptE->getBase()->getSourceRange();
-    else
-      BaseRange =
-          dyn_cast<CXXOperatorCallExpr>(Matched)->getArg(0)->getSourceRange();
-    SourceRange IndexRange = IndexExpr->getSourceRange();
-
-    auto Diag = diag(Matched->getExprLoc(),
-                     "do not use array subscript when the index is "
-                     "not an integer constant expression; use gsl::at() "
-                     "instead");
-    if (!GslHeader.empty()) {
-      Diag << FixItHint::CreateInsertion(BaseRange.getBegin(), "gsl::at(")
-           << FixItHint::CreateReplacement(
-                  SourceRange(BaseRange.getEnd().getLocWithOffset(1),
-                              IndexRange.getBegin().getLocWithOffset(-1)),
-                  ", ")
-           << FixItHint::CreateReplacement(Matched->getLocEnd(), ")");
-
-      Optional<FixItHint> Insertion = Inserter->CreateIncludeInsertion(
-          Result.SourceManager->getMainFileID(), GslHeader,
-          /*IsAngled=*/false);
-      if (Insertion)
-        Diag << Insertion.getValue();
-    }
-    return;
-  }
-
-  const auto *StdArrayDecl =
-      Result.Nodes.getNodeAs<ClassTemplateSpecializationDecl>("type");
-
-  // For static arrays, this is handled in clang-diagnostic-array-bounds.
-  if (!StdArrayDecl)
-    return;
-
-  if (Index.isSigned() && Index.isNegative()) {
-    diag(Matched->getExprLoc(),
-         "std::array<> index %0 is negative")
-        << Index.toString(10);
-    return;
-  }
-
-  const TemplateArgumentList &TemplateArgs = StdArrayDecl->getTemplateArgs();
-  if (TemplateArgs.size() < 2)
-    return;
-  // First template arg of std::array is the type, second arg is the size.
-  const auto &SizeArg = TemplateArgs[1];
-  if (SizeArg.getKind() != TemplateArgument::Integral)
-    return;
-  llvm::APInt ArraySize = SizeArg.getAsIntegral();
-
-  // Get uint64_t values, because different bitwidths would lead to an assertion
-  // in APInt::uge.
-  if (Index.getZExtValue() >= ArraySize.getZExtValue()) {
-    diag(Matched->getExprLoc(), "std::array<> index %0 is past the end of the array "
-                                "(which contains %1 elements)")
-        << Index.toString(10) << ArraySize.toString(10, false);
-  }
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,42 +0,0 @@
-//===--- ProBoundsConstantArrayIndexCheck.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_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H
-
-#include "../ClangTidy.h"
-#include "../utils/IncludeInserter.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// This checks that all array subscriptions on static arrays and std::arrays
-/// have a constant index and are within bounds
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-constant-array-index.html
-class ProBoundsConstantArrayIndexCheck : public ClangTidyCheck {
-  const std::string GslHeader;
-  const utils::IncludeSorter::IncludeStyle IncludeStyle;
-  std::unique_ptr<utils::IncludeInserter> Inserter;
-
-public:
-  ProBoundsConstantArrayIndexCheck(StringRef Name, ClangTidyContext *Context);
-  void registerPPCallbacks(CompilerInstance &Compiler) override;
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H

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

@@ -1,59 +0,0 @@
-//===--- ProBoundsPointerArithmeticCheck.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 "ProBoundsPointerArithmeticCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-void ProBoundsPointerArithmeticCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  // Flag all operators +, -, +=, -=, ++, -- that result in a pointer
-  Finder->addMatcher(
-      binaryOperator(
-          anyOf(hasOperatorName("+"), hasOperatorName("-"),
-                hasOperatorName("+="), hasOperatorName("-=")),
-          hasType(pointerType()),
-          unless(hasLHS(ignoringImpCasts(declRefExpr(to(isImplicit()))))))
-          .bind("expr"),
-      this);
-
-  Finder->addMatcher(
-      unaryOperator(anyOf(hasOperatorName("++"), hasOperatorName("--")),
-                    hasType(pointerType()))
-          .bind("expr"),
-      this);
-
-  // Array subscript on a pointer (not an array) is also pointer arithmetic
-  Finder->addMatcher(
-      arraySubscriptExpr(
-          hasBase(ignoringImpCasts(
-              anyOf(hasType(pointerType()),
-                    hasType(decayedType(hasDecayedType(pointerType())))))))
-          .bind("expr"),
-      this);
-}
-
-void
-ProBoundsPointerArithmeticCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr");
-
-  diag(MatchedExpr->getExprLoc(), "do not use pointer arithmetic");
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- ProBoundsPointerArithmeticCheck.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_PRO_BOUNDS_POINTER_ARITHMETIC_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_POINTER_ARITHMETIC_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// Flags all kinds of pointer arithmetic that have result of pointer type, i.e.
-/// +, -, +=, -=, ++, --. In addition, the [] operator on pointers (not on arrays) is flagged.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-pointer-arithmetic.html
-class ProBoundsPointerArithmeticCheck : public ClangTidyCheck {
-public:
-  ProBoundsPointerArithmeticCheck(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_PRO_BOUNDS_POINTER_ARITHMETIC_H

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

@@ -1,34 +0,0 @@
-//===--- ProTypeConstCastCheck.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 "ProTypeConstCastCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-	
-void ProTypeConstCastCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(cxxConstCastExpr().bind("cast"), this);
-}
-
-void ProTypeConstCastCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *MatchedCast = Result.Nodes.getNodeAs<CXXConstCastExpr>("cast");
-  diag(MatchedCast->getOperatorLoc(), "do not use const_cast");
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,35 +0,0 @@
-//===--- ProTypeConstCastCheck.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_PRO_TYPE_CONST_CAST_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-	
-/// This check flags all instances of const_cast
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-const-cast.html
-class ProTypeConstCastCheck : public ClangTidyCheck {
-public:
-  ProTypeConstCastCheck(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_PRO_TYPE_CONST_CAST_H

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

@@ -1,109 +0,0 @@
-//===--- ProTypeCstyleCastCheck.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 "ProTypeCstyleCastCheck.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 cppcoreguidelines {
-
-static bool needsConstCast(QualType SourceType, QualType DestType) {
-  SourceType = SourceType.getNonReferenceType();
-  DestType = DestType.getNonReferenceType();
-  while (SourceType->isPointerType() && DestType->isPointerType()) {
-    SourceType = SourceType->getPointeeType();
-    DestType = DestType->getPointeeType();
-    if (SourceType.isConstQualified() && !DestType.isConstQualified())
-      return true;
-  }
-  return false;
-}
-
-void ProTypeCstyleCastCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(
-      cStyleCastExpr(unless(isInTemplateInstantiation())).bind("cast"), this);
-}
-
-void ProTypeCstyleCastCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *MatchedCast = Result.Nodes.getNodeAs<CStyleCastExpr>("cast");
-
-  if (MatchedCast->getCastKind() == CK_BitCast ||
-      MatchedCast->getCastKind() == CK_LValueBitCast ||
-      MatchedCast->getCastKind() == CK_IntegralToPointer ||
-      MatchedCast->getCastKind() == CK_PointerToIntegral ||
-      MatchedCast->getCastKind() == CK_ReinterpretMemberPointer) {
-    diag(MatchedCast->getLocStart(),
-         "do not use C-style cast to convert between unrelated types");
-    return;
-  }
-
-  QualType SourceType = MatchedCast->getSubExpr()->getType();
-
-  if (MatchedCast->getCastKind() == CK_BaseToDerived) {
-    const auto *SourceDecl = SourceType->getPointeeCXXRecordDecl();
-    if (!SourceDecl) // The cast is from object to reference.
-      SourceDecl = SourceType->getAsCXXRecordDecl();
-    if (!SourceDecl)
-      return;
-
-    if (SourceDecl->isPolymorphic()) {
-      // Leave type spelling exactly as it was (unlike
-      // getTypeAsWritten().getAsString() which would spell enum types 'enum
-      // X').
-      StringRef DestTypeString = Lexer::getSourceText(
-          CharSourceRange::getTokenRange(
-              MatchedCast->getLParenLoc().getLocWithOffset(1),
-              MatchedCast->getRParenLoc().getLocWithOffset(-1)),
-          *Result.SourceManager, Result.Context->getLangOpts());
-
-      auto diag_builder = diag(
-          MatchedCast->getLocStart(),
-          "do not use C-style cast to downcast from a base to a derived class; "
-          "use dynamic_cast instead");
-
-      const Expr *SubExpr =
-          MatchedCast->getSubExprAsWritten()->IgnoreImpCasts();
-      std::string CastText = ("dynamic_cast<" + DestTypeString + ">").str();
-      if (!isa<ParenExpr>(SubExpr)) {
-        CastText.push_back('(');
-        diag_builder << FixItHint::CreateInsertion(
-            Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0,
-                                       *Result.SourceManager,
-                                       Result.Context->getLangOpts()),
-            ")");
-      }
-      auto ParenRange = CharSourceRange::getTokenRange(
-          MatchedCast->getLParenLoc(), MatchedCast->getRParenLoc());
-      diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
-    } else {
-      diag(
-          MatchedCast->getLocStart(),
-          "do not use C-style cast to downcast from a base to a derived class");
-    }
-    return;
-  }
-
-  if (MatchedCast->getCastKind() == CK_NoOp &&
-      needsConstCast(SourceType, MatchedCast->getType())) {
-    diag(MatchedCast->getLocStart(),
-         "do not use C-style cast to cast away constness");
-  }
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- ProTypeCstyleCastCheck.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_PRO_TYPE_CSTYLE_CAST_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CSTYLE_CAST_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// This check flags all use of C-style casts that perform a static_cast
-/// downcast, const_cast, or reinterpret_cast.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-cstyle-cast.html
-class ProTypeCstyleCastCheck : public ClangTidyCheck {
-public:
-  ProTypeCstyleCastCheck(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_PRO_TYPE_CSTYLE_CAST_H

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

@@ -1,428 +0,0 @@
-//===--- ProTypeMemberInitCheck.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 "ProTypeMemberInitCheck.h"
-#include "../utils/LexerUtils.h"
-#include "../utils/Matchers.h"
-#include "../utils/TypeTraits.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Lex/Lexer.h"
-#include "llvm/ADT/SmallPtrSet.h"
-
-using namespace clang::ast_matchers;
-using namespace clang::tidy::matchers;
-using llvm::SmallPtrSet;
-using llvm::SmallPtrSetImpl;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-namespace {
-
-// Iterate over all the fields in a record type, both direct and indirect (e.g.
-// if the record contains an anonmyous struct). If OneFieldPerUnion is true and
-// the record type (or indirect field) is a union, forEachField will stop after
-// the first field.
-template <typename T, typename Func>
-void forEachField(const RecordDecl *Record, const T &Fields,
-                  bool OneFieldPerUnion, Func &&Fn) {
-  for (const FieldDecl *F : Fields) {
-    if (F->isAnonymousStructOrUnion()) {
-      if (const CXXRecordDecl *R = F->getType()->getAsCXXRecordDecl())
-        forEachField(R, R->fields(), OneFieldPerUnion, Fn);
-    } else {
-      Fn(F);
-    }
-
-    if (OneFieldPerUnion && Record->isUnion())
-      break;
-  }
-}
-
-void removeFieldsInitializedInBody(
-    const Stmt &Stmt, ASTContext &Context,
-    SmallPtrSetImpl<const FieldDecl *> &FieldDecls) {
-  auto Matches =
-      match(findAll(binaryOperator(
-                hasOperatorName("="),
-                hasLHS(memberExpr(member(fieldDecl().bind("fieldDecl")))))),
-            Stmt, Context);
-  for (const auto &Match : Matches)
-    FieldDecls.erase(Match.getNodeAs<FieldDecl>("fieldDecl"));
-}
-
-StringRef getName(const FieldDecl *Field) { return Field->getName(); }
-
-StringRef getName(const RecordDecl *Record) {
-  // Get the typedef name if this is a C-style anonymous struct and typedef.
-  if (const TypedefNameDecl *Typedef = Record->getTypedefNameForAnonDecl())
-    return Typedef->getName();
-  return Record->getName();
-}
-
-// Creates comma separated list of decls requiring initialization in order of
-// declaration.
-template <typename R, typename T>
-std::string
-toCommaSeparatedString(const R &OrderedDecls,
-                       const SmallPtrSetImpl<const T *> &DeclsToInit) {
-  SmallVector<StringRef, 16> Names;
-  for (const T *Decl : OrderedDecls) {
-    if (DeclsToInit.count(Decl))
-      Names.emplace_back(getName(Decl));
-  }
-  return llvm::join(Names.begin(), Names.end(), ", ");
-}
-
-SourceLocation getLocationForEndOfToken(const ASTContext &Context,
-                                        SourceLocation Location) {
-  return Lexer::getLocForEndOfToken(Location, 0, Context.getSourceManager(),
-                                    Context.getLangOpts());
-}
-
-// There are 3 kinds of insertion placements:
-enum class InitializerPlacement {
-  // 1. The fields are inserted after an existing CXXCtorInitializer stored in
-  // Where. This will be the case whenever there is a written initializer before
-  // the fields available.
-  After,
-
-  // 2. The fields are inserted before the first existing initializer stored in
-  // Where.
-  Before,
-
-  // 3. There are no written initializers and the fields will be inserted before
-  // the constructor's body creating a new initializer list including the ':'.
-  New
-};
-
-// An InitializerInsertion contains a list of fields and/or base classes to
-// insert into the initializer list of a constructor. We use this to ensure
-// proper absolute ordering according to the class declaration relative to the
-// (perhaps improper) ordering in the existing initializer list, if any.
-struct IntializerInsertion {
-  IntializerInsertion(InitializerPlacement Placement,
-                      const CXXCtorInitializer *Where)
-      : Placement(Placement), Where(Where) {}
-
-  SourceLocation getLocation(const ASTContext &Context,
-                             const CXXConstructorDecl &Constructor) const {
-    assert((Where != nullptr || Placement == InitializerPlacement::New) &&
-           "Location should be relative to an existing initializer or this "
-           "insertion represents a new initializer list.");
-    SourceLocation Location;
-    switch (Placement) {
-    case InitializerPlacement::New:
-      Location = utils::lexer::getPreviousNonCommentToken(
-                     Context, Constructor.getBody()->getLocStart())
-                     .getLocation();
-      break;
-    case InitializerPlacement::Before:
-      Location = utils::lexer::getPreviousNonCommentToken(
-                     Context, Where->getSourceRange().getBegin())
-                     .getLocation();
-      break;
-    case InitializerPlacement::After:
-      Location = Where->getRParenLoc();
-      break;
-    }
-    return getLocationForEndOfToken(Context, Location);
-  }
-
-  std::string codeToInsert() const {
-    assert(!Initializers.empty() && "No initializers to insert");
-    std::string Code;
-    llvm::raw_string_ostream Stream(Code);
-    std::string joined =
-        llvm::join(Initializers.begin(), Initializers.end(), "(), ");
-    switch (Placement) {
-    case InitializerPlacement::New:
-      Stream << " : " << joined << "()";
-      break;
-    case InitializerPlacement::Before:
-      Stream << " " << joined << "(),";
-      break;
-    case InitializerPlacement::After:
-      Stream << ", " << joined << "()";
-      break;
-    }
-    return Stream.str();
-  }
-
-  InitializerPlacement Placement;
-  const CXXCtorInitializer *Where;
-  SmallVector<std::string, 4> Initializers;
-};
-
-// Convenience utility to get a RecordDecl from a QualType.
-const RecordDecl *getCanonicalRecordDecl(const QualType &Type) {
-  if (const auto *RT = Type.getCanonicalType()->getAs<RecordType>())
-    return RT->getDecl();
-  return nullptr;
-}
-
-template <typename R, typename T>
-SmallVector<IntializerInsertion, 16>
-computeInsertions(const CXXConstructorDecl::init_const_range &Inits,
-                  const R &OrderedDecls,
-                  const SmallPtrSetImpl<const T *> &DeclsToInit) {
-  SmallVector<IntializerInsertion, 16> Insertions;
-  Insertions.emplace_back(InitializerPlacement::New, nullptr);
-
-  typename R::const_iterator Decl = std::begin(OrderedDecls);
-  for (const CXXCtorInitializer *Init : Inits) {
-    if (Init->isWritten()) {
-      if (Insertions.size() == 1)
-        Insertions.emplace_back(InitializerPlacement::Before, Init);
-
-      // Gets either the field or base class being initialized by the provided
-      // initializer.
-      const auto *InitDecl =
-          Init->isAnyMemberInitializer()
-              ? static_cast<const NamedDecl *>(Init->getAnyMember())
-              : Init->getBaseClass()->getAsCXXRecordDecl();
-
-      // Add all fields between current field up until the next intializer.
-      for (; Decl != std::end(OrderedDecls) && *Decl != InitDecl; ++Decl) {
-        if (const T *D = dyn_cast<T>(*Decl)) {
-          if (DeclsToInit.count(D) > 0)
-            Insertions.back().Initializers.emplace_back(getName(D));
-        }
-      }
-
-      Insertions.emplace_back(InitializerPlacement::After, Init);
-    }
-  }
-
-  // Add remaining decls that require initialization.
-  for (; Decl != std::end(OrderedDecls); ++Decl) {
-    if (const T *D = dyn_cast<T>(*Decl)) {
-      if (DeclsToInit.count(D) > 0)
-        Insertions.back().Initializers.emplace_back(getName(D));
-    }
-  }
-  return Insertions;
-}
-
-// Gets the list of bases and members that could possibly be initialized, in
-// order as they appear in the class declaration.
-void getInitializationsInOrder(const CXXRecordDecl *ClassDecl,
-                               SmallVectorImpl<const NamedDecl *> &Decls) {
-  Decls.clear();
-  for (const auto &Base : ClassDecl->bases()) {
-    // Decl may be null if the base class is a template parameter.
-    if (const NamedDecl *Decl = getCanonicalRecordDecl(Base.getType())) {
-      Decls.emplace_back(Decl);
-    }
-  }
-  forEachField(ClassDecl, ClassDecl->fields(), false,
-               [&](const FieldDecl *F) { Decls.push_back(F); });
-}
-
-template <typename T>
-void fixInitializerList(const ASTContext &Context, DiagnosticBuilder &Diag,
-                        const CXXConstructorDecl *Ctor,
-                        const SmallPtrSetImpl<const T *> &DeclsToInit) {
-  // Do not propose fixes in macros since we cannot place them correctly.
-  if (Ctor->getLocStart().isMacroID())
-    return;
-
-  SmallVector<const NamedDecl *, 16> OrderedDecls;
-  getInitializationsInOrder(Ctor->getParent(), OrderedDecls);
-
-  for (const auto &Insertion :
-       computeInsertions(Ctor->inits(), OrderedDecls, DeclsToInit)) {
-    if (!Insertion.Initializers.empty())
-      Diag << FixItHint::CreateInsertion(Insertion.getLocation(Context, *Ctor),
-                                         Insertion.codeToInsert());
-  }
-}
-
-} // anonymous namespace
-
-ProTypeMemberInitCheck::ProTypeMemberInitCheck(StringRef Name,
-                                               ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      IgnoreArrays(Options.get("IgnoreArrays", false)) {}
-
-void ProTypeMemberInitCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  auto IsUserProvidedNonDelegatingConstructor =
-      allOf(isUserProvided(),
-            unless(anyOf(isInstantiated(), isDelegatingConstructor())));
-  auto IsNonTrivialDefaultConstructor = allOf(
-      isDefaultConstructor(), unless(isUserProvided()),
-      hasParent(cxxRecordDecl(unless(isTriviallyDefaultConstructible()))));
-  Finder->addMatcher(
-      cxxConstructorDecl(isDefinition(),
-                         anyOf(IsUserProvidedNonDelegatingConstructor,
-                               IsNonTrivialDefaultConstructor))
-          .bind("ctor"),
-      this);
-  auto HasDefaultConstructor = hasInitializer(
-      cxxConstructExpr(unless(requiresZeroInitialization()),
-                       hasDeclaration(cxxConstructorDecl(
-                           isDefaultConstructor(), unless(isUserProvided())))));
-  Finder->addMatcher(
-      varDecl(isDefinition(), HasDefaultConstructor,
-              hasAutomaticStorageDuration(),
-              hasType(recordDecl(has(fieldDecl()),
-                                 isTriviallyDefaultConstructible())))
-          .bind("var"),
-      this);
-}
-
-void ProTypeMemberInitCheck::check(const MatchFinder::MatchResult &Result) {
-  if (const auto *Ctor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor")) {
-    // Skip declarations delayed by late template parsing without a body.
-    if (!Ctor->getBody())
-      return;
-    checkMissingMemberInitializer(*Result.Context, Ctor);
-    checkMissingBaseClassInitializer(*Result.Context, Ctor);
-  } else if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("var")) {
-    checkUninitializedTrivialType(*Result.Context, Var);
-  }
-}
-
-void ProTypeMemberInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "IgnoreArrays", IgnoreArrays);
-}
-
-void ProTypeMemberInitCheck::checkMissingMemberInitializer(
-    ASTContext &Context, const CXXConstructorDecl *Ctor) {
-  const CXXRecordDecl *ClassDecl = Ctor->getParent();
-  bool IsUnion = ClassDecl->isUnion();
-
-  if (IsUnion && ClassDecl->hasInClassInitializer())
-    return;
-
-  // Gather all fields (direct and indirect) that need to be initialized.
-  SmallPtrSet<const FieldDecl *, 16> FieldsToInit;
-  forEachField(ClassDecl, ClassDecl->fields(), false, [&](const FieldDecl *F) {
-    if (!F->hasInClassInitializer() &&
-        utils::type_traits::isTriviallyDefaultConstructible(F->getType(),
-                                                            Context))
-      FieldsToInit.insert(F);
-  });
-  if (FieldsToInit.empty())
-    return;
-
-  for (const CXXCtorInitializer *Init : Ctor->inits()) {
-    // Remove any fields that were explicitly written in the initializer list
-    // or in-class.
-    if (Init->isAnyMemberInitializer() && Init->isWritten()) {
-      if (IsUnion)
-        return; // We can only initialize one member of a union.
-      FieldsToInit.erase(Init->getAnyMember());
-    }
-  }
-  removeFieldsInitializedInBody(*Ctor->getBody(), Context, FieldsToInit);
-
-  // Collect all fields in order, both direct fields and indirect fields from
-  // anonmyous record types.
-  SmallVector<const FieldDecl *, 16> OrderedFields;
-  forEachField(ClassDecl, ClassDecl->fields(), false,
-               [&](const FieldDecl *F) { OrderedFields.push_back(F); });
-
-  // Collect all the fields we need to initialize, including indirect fields.
-  SmallPtrSet<const FieldDecl *, 16> AllFieldsToInit;
-  forEachField(ClassDecl, FieldsToInit, false,
-               [&](const FieldDecl *F) { AllFieldsToInit.insert(F); });
-  if (AllFieldsToInit.empty())
-    return;
-
-  DiagnosticBuilder Diag =
-      diag(Ctor->getLocStart(),
-           IsUnion
-               ? "union constructor should initialize one of these fields: %0"
-               : "constructor does not initialize these fields: %0")
-      << toCommaSeparatedString(OrderedFields, AllFieldsToInit);
-
-  // Do not propose fixes in macros since we cannot place them correctly.
-  if (Ctor->getLocStart().isMacroID())
-    return;
-
-  // Collect all fields but only suggest a fix for the first member of unions,
-  // as initializing more than one union member is an error.
-  SmallPtrSet<const FieldDecl *, 16> FieldsToFix;
-  forEachField(ClassDecl, FieldsToInit, true, [&](const FieldDecl *F) {
-    // Don't suggest fixes for enums because we don't know a good default.
-    if (!F->getType()->isEnumeralType())
-      FieldsToFix.insert(F);
-  });
-  if (FieldsToFix.empty())
-    return;
-
-  // Use in-class initialization if possible.
-  if (Context.getLangOpts().CPlusPlus11) {
-    for (const FieldDecl *Field : FieldsToFix) {
-      Diag << FixItHint::CreateInsertion(
-          getLocationForEndOfToken(Context, Field->getSourceRange().getEnd()),
-          "{}");
-    }
-  } else {
-    // Otherwise, rewrite the constructor's initializer list.
-    fixInitializerList(Context, Diag, Ctor, FieldsToFix);
-  }
-}
-
-void ProTypeMemberInitCheck::checkMissingBaseClassInitializer(
-    const ASTContext &Context, const CXXConstructorDecl *Ctor) {
-  const CXXRecordDecl *ClassDecl = Ctor->getParent();
-
-  // Gather any base classes that need to be initialized.
-  SmallVector<const RecordDecl *, 4> AllBases;
-  SmallPtrSet<const RecordDecl *, 4> BasesToInit;
-  for (const CXXBaseSpecifier &Base : ClassDecl->bases()) {
-    if (const auto *BaseClassDecl = getCanonicalRecordDecl(Base.getType())) {
-      AllBases.emplace_back(BaseClassDecl);
-      if (!BaseClassDecl->field_empty() &&
-          utils::type_traits::isTriviallyDefaultConstructible(Base.getType(),
-                                                              Context))
-        BasesToInit.insert(BaseClassDecl);
-    }
-  }
-
-  if (BasesToInit.empty())
-    return;
-
-  // Remove any bases that were explicitly written in the initializer list.
-  for (const CXXCtorInitializer *Init : Ctor->inits()) {
-    if (Init->isBaseInitializer() && Init->isWritten())
-      BasesToInit.erase(Init->getBaseClass()->getAsCXXRecordDecl());
-  }
-
-  if (BasesToInit.empty())
-    return;
-
-  DiagnosticBuilder Diag =
-      diag(Ctor->getLocStart(),
-           "constructor does not initialize these bases: %0")
-      << toCommaSeparatedString(AllBases, BasesToInit);
-
-  fixInitializerList(Context, Diag, Ctor, BasesToInit);
-}
-
-void ProTypeMemberInitCheck::checkUninitializedTrivialType(
-    const ASTContext &Context, const VarDecl *Var) {
-  DiagnosticBuilder Diag =
-      diag(Var->getLocStart(), "uninitialized record type: %0") << Var;
-
-  Diag << FixItHint::CreateInsertion(
-      getLocationForEndOfToken(Context, Var->getSourceRange().getEnd()),
-      Context.getLangOpts().CPlusPlus11 ? "{}" : " = {}");
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,72 +0,0 @@
-//===--- ProTypeMemberInitCheck.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_PRO_TYPE_MEMBER_INIT_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_MEMBER_INIT_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// \brief Implements C++ Core Guidelines Type.6.
-///
-/// Checks that every user-provided constructor value-initializes all class
-/// members and base classes that would have undefined behavior otherwise. Also
-/// check that any record types without user-provided default constructors are
-/// value-initialized where used.
-///
-/// Members initialized through function calls in the body of the constructor
-/// will result in false positives.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-member-init.html
-/// TODO: See if 'fixes' for false positives are optimized away by the compiler.
-/// TODO: For classes with multiple constructors, make sure that we don't offer
-///     multiple in-class initializer fixits for the same  member.
-class ProTypeMemberInitCheck : public ClangTidyCheck {
-public:
-  ProTypeMemberInitCheck(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:
-  // Checks Type.6 part 1:
-  // Issue a diagnostic for any constructor of a non-trivially-constructible
-  // type that does not initialize all member variables.
-  //
-  // To fix: Write a data member initializer, or mention it in the member
-  // initializer list.
-  void checkMissingMemberInitializer(ASTContext &Context,
-                                     const CXXConstructorDecl *Ctor);
-
-  // A subtle side effect of Type.6 part 2:
-  // Make sure to initialize trivially constructible base classes.
-  void checkMissingBaseClassInitializer(const ASTContext &Context,
-                                        const CXXConstructorDecl *Ctor);
-
-  // Checks Type.6 part 2:
-  // Issue a diagnostic when constructing an object of a trivially constructible
-  // type without () or {} to initialize its members.
-  //
-  // To fix: Add () or {}.
-  void checkUninitializedTrivialType(const ASTContext &Context,
-                                     const VarDecl *Var);
-
-  // Whether arrays need to be initialized or not. Default is false.
-  bool IgnoreArrays;
-};
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_MEMBER_INIT_H

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

@@ -1,36 +0,0 @@
-//===--- ProTypeReinterpretCastCheck.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 "ProTypeReinterpretCastCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-void ProTypeReinterpretCastCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(cxxReinterpretCastExpr().bind("cast"), this);
-}
-
-void ProTypeReinterpretCastCheck::check(
-    const MatchFinder::MatchResult &Result) {
-  const auto *MatchedCast =
-      Result.Nodes.getNodeAs<CXXReinterpretCastExpr>("cast");
-  diag(MatchedCast->getOperatorLoc(), "do not use reinterpret_cast");
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,35 +0,0 @@
-//===--- ProTypeReinterpretCast.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_PRO_TYPE_REINTERPRETCAST_CHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_REINTERPRETCAST_CHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// Flags all occurrences of reinterpret_cast
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-reinterpret-cast.html
-class ProTypeReinterpretCastCheck : public ClangTidyCheck {
-public:
-  ProTypeReinterpretCastCheck(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_PRO_TYPE_REINTERPRETCAST_CHECK_H

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

@@ -1,54 +0,0 @@
-//===--- ProTypeStaticCastDowncastCheck.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 "ProTypeStaticCastDowncastCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-  
-void ProTypeStaticCastDowncastCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(
-      cxxStaticCastExpr(unless(isInTemplateInstantiation())).bind("cast"),
-      this);
-}
-
-void ProTypeStaticCastDowncastCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *MatchedCast = Result.Nodes.getNodeAs<CXXStaticCastExpr>("cast");
-  if (MatchedCast->getCastKind() != CK_BaseToDerived)
-    return;
-
-  QualType SourceType = MatchedCast->getSubExpr()->getType();
-  const auto *SourceDecl = SourceType->getPointeeCXXRecordDecl();
-  if (!SourceDecl) // The cast is from object to reference
-    SourceDecl = SourceType->getAsCXXRecordDecl();
-  if (!SourceDecl)
-    return;
-
-  if (SourceDecl->isPolymorphic())
-    diag(MatchedCast->getOperatorLoc(),
-         "do not use static_cast to downcast from a base to a derived class; "
-         "use dynamic_cast instead")
-        << FixItHint::CreateReplacement(MatchedCast->getOperatorLoc(),
-                                        "dynamic_cast");
-  else
-    diag(MatchedCast->getOperatorLoc(),
-         "do not use static_cast to downcast from a base to a derived class");
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,35 +0,0 @@
-//===--- ProTypeStaticCastDowncastCheck.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_PRO_TYPE_STATIC_CAST_DOWNCAST_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-	
-/// Checks for usages of static_cast, where a base class is downcasted to a derived class.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-static-cast-downcast.html
-class ProTypeStaticCastDowncastCheck : public ClangTidyCheck {
-public:
-  ProTypeStaticCastDowncastCheck(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_PRO_TYPE_STATIC_CAST_DOWNCAST_H

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

@@ -1,35 +0,0 @@
-//===--- ProTypeUnionAccessCheck.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 "ProTypeUnionAccessCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-void ProTypeUnionAccessCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(memberExpr(hasObjectExpression(hasType(recordDecl(isUnion())))).bind("expr"), this);
-}
-
-void ProTypeUnionAccessCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *Matched = Result.Nodes.getNodeAs<MemberExpr>("expr");
-  diag(Matched->getMemberLoc(), "do not access members of unions; use (boost::)variant instead");
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
-

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

@@ -1,37 +0,0 @@
-//===--- ProTypeUnionAccessCheck.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_PRO_TYPE_UNION_ACCESS_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_UNION_ACCESS_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// This check flags all access to members of unions.
-/// Access to a union as a whole (e.g. passing to a function) is not flagged.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-union-access.html
-class ProTypeUnionAccessCheck : public ClangTidyCheck {
-public:
-  ProTypeUnionAccessCheck(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_PRO_TYPE_UNION_ACCESS_H
-

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

@@ -1,78 +0,0 @@
-//===--- ProTypeVarargCheck.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 "ProTypeVarargCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-const internal::VariadicDynCastAllOfMatcher<Stmt, VAArgExpr> vAArgExpr;
-
-void ProTypeVarargCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  Finder->addMatcher(vAArgExpr().bind("va_use"), this);
-
-  Finder->addMatcher(
-      callExpr(callee(functionDecl(isVariadic())))
-          .bind("callvararg"),
-      this);
-}
-
-static bool hasSingleVariadicArgumentWithValue(const CallExpr *C, uint64_t I) {
-  const auto *FDecl = dyn_cast<FunctionDecl>(C->getCalleeDecl());
-  if (!FDecl)
-    return false;
-
-  auto N = FDecl->getNumParams(); // Number of parameters without '...'
-  if (C->getNumArgs() != N + 1)
-    return false; // more/less than one argument passed to '...'
-
-  const auto *IntLit =
-      dyn_cast<IntegerLiteral>(C->getArg(N)->IgnoreParenImpCasts());
-  if (!IntLit)
-    return false;
-
-  if (IntLit->getValue() != I)
-    return false;
-
-  return true;
-}
-
-void ProTypeVarargCheck::check(const MatchFinder::MatchResult &Result) {
-  if (const auto *Matched = Result.Nodes.getNodeAs<CallExpr>("callvararg")) {
-    if (hasSingleVariadicArgumentWithValue(Matched, 0))
-      return;
-    diag(Matched->getExprLoc(), "do not call c-style vararg functions");
-  }
-
-  if (const auto *Matched = Result.Nodes.getNodeAs<Expr>("va_use")) {
-    diag(Matched->getExprLoc(),
-         "do not use va_start/va_arg to define c-style vararg functions; "
-         "use variadic templates instead");
-  }
-
-  if (const auto *Matched = Result.Nodes.getNodeAs<VarDecl>("va_list")) {
-    auto SR = Matched->getSourceRange();
-    if (SR.isInvalid())
-      return; // some implicitly generated builtins take va_list
-    diag(SR.getBegin(), "do not declare variables of type va_list; "
-                        "use variadic templates instead");
-  }
-}
-
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang

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

@@ -1,36 +0,0 @@
-//===--- ProTypeVarargCheck.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_PRO_TYPE_VARARG_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_VARARG_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
-
-/// This check flags all calls to c-style variadic functions and all use
-/// of va_arg.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-vararg.html
-class ProTypeVarargCheck : public ClangTidyCheck {
-public:
-  ProTypeVarargCheck(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_PRO_TYPE_VARARG_H

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

@@ -1,175 +0,0 @@
-//===--- AvoidCStyleCastsCheck.cpp - clang-tidy -----------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "AvoidCStyleCastsCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace google {
-namespace readability {
-
-void
-AvoidCStyleCastsCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
-  Finder->addMatcher(
-      cStyleCastExpr(
-          // Filter out (EnumType)IntegerLiteral construct, which is generated
-          // for non-type template arguments of enum types.
-          // FIXME: Remove this once this is fixed in the AST.
-          unless(hasParent(substNonTypeTemplateParmExpr())),
-          // Avoid matches in template instantiations.
-          unless(isInTemplateInstantiation())).bind("cast"),
-      this);
-}
-
-static bool needsConstCast(QualType SourceType, QualType DestType) {
-  SourceType = SourceType.getNonReferenceType();
-  DestType = DestType.getNonReferenceType();
-  while (SourceType->isPointerType() && DestType->isPointerType()) {
-    SourceType = SourceType->getPointeeType();
-    DestType = DestType->getPointeeType();
-    if (SourceType.isConstQualified() && !DestType.isConstQualified())
-      return true;
-  }
-  return false;
-}
-
-static bool pointedTypesAreEqual(QualType SourceType, QualType DestType) {
-  SourceType = SourceType.getNonReferenceType();
-  DestType = DestType.getNonReferenceType();
-  while (SourceType->isPointerType() && DestType->isPointerType()) {
-    SourceType = SourceType->getPointeeType();
-    DestType = DestType->getPointeeType();
-  }
-  return SourceType.getUnqualifiedType() == DestType.getUnqualifiedType();
-}
-
-void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *CastExpr = Result.Nodes.getNodeAs<CStyleCastExpr>("cast");
-
-  auto ParenRange = CharSourceRange::getTokenRange(CastExpr->getLParenLoc(),
-                                                   CastExpr->getRParenLoc());
-  // Ignore casts in macros.
-  if (ParenRange.getBegin().isMacroID() || ParenRange.getEnd().isMacroID())
-    return;
-
-  // Casting to void is an idiomatic way to mute "unused variable" and similar
-  // warnings.
-  if (CastExpr->getTypeAsWritten()->isVoidType())
-    return;
-
-  QualType SourceType = CastExpr->getSubExprAsWritten()->getType();
-  QualType DestType = CastExpr->getTypeAsWritten();
-
-  if (SourceType == DestType) {
-    diag(CastExpr->getLocStart(), "redundant cast to the same type")
-        << FixItHint::CreateRemoval(ParenRange);
-    return;
-  }
-  SourceType = SourceType.getCanonicalType();
-  DestType = DestType.getCanonicalType();
-  if (SourceType == DestType) {
-    diag(CastExpr->getLocStart(),
-         "possibly redundant cast between typedefs of the same type");
-    return;
-  }
-
-
-  // The rest of this check is only relevant to C++.
-  if (!Result.Context->getLangOpts().CPlusPlus)
-    return;
-  // Ignore code inside extern "C" {} blocks.
-  if (!match(expr(hasAncestor(linkageSpecDecl())), *CastExpr, *Result.Context)
-           .empty())
-    return;
-  // Ignore code in .c files and headers included from them, even if they are
-  // compiled as C++.
-  if (getCurrentMainFile().endswith(".c"))
-    return;
-  // Ignore code in .c files #included in other files (which shouldn't be done,
-  // but people still do this for test and other purposes).
-  SourceManager &SM = *Result.SourceManager;
-  if (SM.getFilename(SM.getSpellingLoc(CastExpr->getLocStart())).endswith(".c"))
-    return;
-
-  // Leave type spelling exactly as it was (unlike
-  // getTypeAsWritten().getAsString() which would spell enum types 'enum X').
-  StringRef DestTypeString =
-      Lexer::getSourceText(CharSourceRange::getTokenRange(
-                               CastExpr->getLParenLoc().getLocWithOffset(1),
-                               CastExpr->getRParenLoc().getLocWithOffset(-1)),
-                           SM, Result.Context->getLangOpts());
-
-  auto diag_builder =
-      diag(CastExpr->getLocStart(), "C-style casts are discouraged; use %0");
-
-  auto ReplaceWithCast = [&](StringRef CastType) {
-    diag_builder << CastType;
-
-    const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts();
-    std::string CastText = (CastType + "<" + DestTypeString + ">").str();
-    if (!isa<ParenExpr>(SubExpr)) {
-      CastText.push_back('(');
-      diag_builder << FixItHint::CreateInsertion(
-          Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0, SM,
-                                     Result.Context->getLangOpts()),
-          ")");
-    }
-    diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
-  };
-
-  // Suggest appropriate C++ cast. See [expr.cast] for cast notation semantics.
-  switch (CastExpr->getCastKind()) {
-  case CK_NoOp:
-    if (needsConstCast(SourceType, DestType) &&
-        pointedTypesAreEqual(SourceType, DestType)) {
-      ReplaceWithCast("const_cast");
-      return;
-    }
-    if (DestType->isReferenceType() &&
-        (SourceType.getNonReferenceType() ==
-             DestType.getNonReferenceType().withConst() ||
-         SourceType.getNonReferenceType() == DestType.getNonReferenceType())) {
-      ReplaceWithCast("const_cast");
-      return;
-    }
-    // FALLTHROUGH
-  case clang::CK_IntegralCast:
-    // Convert integral and no-op casts between builtin types and enums to
-    // static_cast. A cast from enum to integer may be unnecessary, but it's
-    // still retained.
-    if ((SourceType->isBuiltinType() || SourceType->isEnumeralType()) &&
-        (DestType->isBuiltinType() || DestType->isEnumeralType())) {
-      ReplaceWithCast("static_cast");
-      return;
-    }
-    break;
-  case CK_BitCast:
-    // FIXME: Suggest const_cast<...>(reinterpret_cast<...>(...)) replacement.
-    if (!needsConstCast(SourceType, DestType)) {
-      ReplaceWithCast("reinterpret_cast");
-      return;
-    }
-    break;
-  default:
-    break;
-  }
-
-  diag_builder << "static_cast/const_cast/reinterpret_cast";
-}
-
-} // namespace readability
-} // namespace google
-} // namespace tidy
-} // namespace clang

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

@@ -1,42 +0,0 @@
-//===--- AvoidCStyleCastsCheck.h - clang-tidy -------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDCSTYLECASTSCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDCSTYLECASTSCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace google {
-namespace readability {
-
-/// Finds usages of C-style casts.
-///
-/// https://google.github.io/styleguide/cppguide.html#Casting
-///
-/// Corresponding cpplint.py check name: 'readability/casting'.
-///
-/// This check is similar to `-Wold-style-cast`, but it suggests automated fixes
-/// in some cases. The reported locations should not be different from the
-/// ones generated by `-Wold-style-cast`.
-class AvoidCStyleCastsCheck : public ClangTidyCheck {
-public:
-  AvoidCStyleCastsCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace readability
-} // namespace google
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDCSTYLECASTSCHECK_H

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

@@ -1,27 +0,0 @@
-set(LLVM_LINK_COMPONENTS support)
-
-add_clang_library(clangTidyGoogleModule
-  AvoidCStyleCastsCheck.cpp
-  DefaultArgumentsCheck.cpp
-  ExplicitConstructorCheck.cpp
-  ExplicitMakePairCheck.cpp
-  GlobalNamesInHeadersCheck.cpp
-  GoogleTidyModule.cpp
-  IntegerTypesCheck.cpp
-  MemsetZeroLengthCheck.cpp
-  NonConstReferences.cpp
-  OverloadedUnaryAndCheck.cpp
-  StringReferenceMemberCheck.cpp
-  TodoCommentCheck.cpp
-  UnnamedNamespaceInHeaderCheck.cpp
-  UsingNamespaceDirectiveCheck.cpp
-
-  LINK_LIBS
-  clangAST
-  clangASTMatchers
-  clangBasic
-  clangLex
-  clangTidy
-  clangTidyReadabilityModule
-  clangTidyUtils
-  )

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

@@ -1,36 +0,0 @@
-//===--- DefaultArgumentsCheck.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 "DefaultArgumentsCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace google {
-
-void DefaultArgumentsCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(
-      cxxMethodDecl(anyOf(isOverride(), isVirtual()),
-                    hasAnyParameter(parmVarDecl(hasInitializer(expr()))))
-          .bind("Decl"),
-      this);
-}
-
-void DefaultArgumentsCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *MatchedDecl = Result.Nodes.getNodeAs<CXXMethodDecl>("Decl");
-  diag(MatchedDecl->getLocation(),
-       "default arguments on virtual or override methods are prohibited");
-}
-
-} // namespace google
-} // namespace tidy
-} // namespace clang

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

@@ -1,34 +0,0 @@
-//===--- DefaultArgumentsCheck.h - clang-tidy--------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_DEFAULT_ARGUMENTS_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_DEFAULT_ARGUMENTS_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace google {
-
-/// Checks that default parameters are not given for virtual methods.
-///
-/// See https://google.github.io/styleguide/cppguide.html#Default_Arguments
-class DefaultArgumentsCheck : public ClangTidyCheck {
-public:
-  DefaultArgumentsCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace google
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_DEFAULT_ARGUMENTS_H

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

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

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

@@ -1,34 +0,0 @@
-//===--- ExplicitConstructorCheck.h - clang-tidy ----------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITCONSTRUCTORCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITCONSTRUCTORCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace google {
-
-/// Checks that all single-argument constructors are explicit.
-///
-/// See https://google.github.io/styleguide/cppguide.html#Explicit_Constructors
-class ExplicitConstructorCheck : public ClangTidyCheck {
-public:
-  ExplicitConstructorCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace google
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITCONSTRUCTORCHECK_H

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

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

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

@@ -1,39 +0,0 @@
-//===--- ExplicitMakePairCheck.h - clang-tidy -------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITMAKEPAIRCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITMAKEPAIRCHECK_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace google {
-namespace build {
-
-/// Check that `make_pair`'s template arguments are deduced.
-///
-/// G++ 4.6 in C++11 mode fails badly if `make_pair`'s template arguments are
-/// specified explicitly, and such use isn't intended in any case.
-///
-/// Corresponding cpplint.py check name: 'build/explicit_make_pair'.
-class ExplicitMakePairCheck : public ClangTidyCheck {
-public:
-  ExplicitMakePairCheck(StringRef Name, ClangTidyContext *Context)
-      : ClangTidyCheck(Name, Context) {}
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-};
-
-} // namespace build
-} // namespace google
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITMAKEPAIRCHECK_H

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

@@ -1,81 +0,0 @@
-//===--- GlobalNamesInHeadersCheck.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 "GlobalNamesInHeadersCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Lex/Lexer.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace google {
-namespace readability {
-
-GlobalNamesInHeadersCheck::GlobalNamesInHeadersCheck(StringRef Name,
-                                                     ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      RawStringHeaderFileExtensions(
-          Options.getLocalOrGlobal("HeaderFileExtensions", "h")) {
-  if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
-                                        HeaderFileExtensions,
-                                        ',')) {
-    llvm::errs() << "Invalid header file extension: "
-                 << RawStringHeaderFileExtensions << "\n";
-  }
-}
-
-void GlobalNamesInHeadersCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);
-}
-
-void
-GlobalNamesInHeadersCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
-  Finder->addMatcher(
-      decl(anyOf(usingDecl(), usingDirectiveDecl()),
-           hasDeclContext(translationUnitDecl())).bind("using_decl"),
-      this);
-}
-
-void GlobalNamesInHeadersCheck::check(const MatchFinder::MatchResult &Result) {
-  const auto *D = Result.Nodes.getNodeAs<Decl>("using_decl");
-  // If it comes from a macro, we'll assume it is fine.
-  if (D->getLocStart().isMacroID())
-    return;
-
-  // Ignore if it comes from the "main" file ...
-  if (Result.SourceManager->isInMainFile(
-          Result.SourceManager->getExpansionLoc(D->getLocStart()))) {
-    // unless that file is a header.
-    if (!utils::isSpellingLocInHeaderFile(
-            D->getLocStart(), *Result.SourceManager, HeaderFileExtensions))
-      return;
-  }
-
-  if (const auto* UsingDirective = dyn_cast<UsingDirectiveDecl>(D)) {
-    if (UsingDirective->getNominatedNamespace()->isAnonymousNamespace()) {
-      // Anynoumous namespaces inject a using directive into the AST to import
-      // the names into the containing namespace.
-      // We should not have them in headers, but there is another warning for
-      // that.
-      return;
-    }
-  }
-
-  diag(D->getLocStart(),
-       "using declarations in the global namespace in headers are prohibited");
-}
-
-} // namespace readability
-} // namespace google
-} // namespace tidy
-} // namespace clang

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

@@ -1,47 +0,0 @@
-//===--- GlobalNamesInHeadersCheck.h - clang-tidy ---------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBALNAMESINHEADERSCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBALNAMESINHEADERSCHECK_H
-
-#include "../ClangTidy.h"
-#include "../utils/HeaderFileExtensionsUtils.h"
-
-namespace clang {
-namespace tidy {
-namespace google {
-namespace readability {
-
-/// Flag global namespace pollution in header files.
-/// Right now it only triggers on using declarations and directives.
-///
-/// The check supports these options:
-///   - `HeaderFileExtensions`: a comma-separated list of filename extensions
-///     of header files (the filename extensions should not contain "." prefix).
-///     "h" by default.
-///     For extension-less header files, using an empty string or leaving an
-///     empty string between "," if there are other filename extensions.
-class GlobalNamesInHeadersCheck : public ClangTidyCheck {
-public:
-  GlobalNamesInHeadersCheck(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 std::string RawStringHeaderFileExtensions;
-  utils::HeaderFileExtensionsSet HeaderFileExtensions;
-};
-
-} // namespace readability
-} // namespace google
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBALNAMESINHEADERSCHECK_H

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

@@ -1,102 +0,0 @@
-//===--- GoogleTidyModule.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 "../readability/BracesAroundStatementsCheck.h"
-#include "../readability/FunctionSizeCheck.h"
-#include "../readability/NamespaceCommentCheck.h"
-#include "../readability/RedundantSmartptrGetCheck.h"
-#include "AvoidCStyleCastsCheck.h"
-#include "DefaultArgumentsCheck.h"
-#include "ExplicitConstructorCheck.h"
-#include "ExplicitMakePairCheck.h"
-#include "GlobalNamesInHeadersCheck.h"
-#include "IntegerTypesCheck.h"
-#include "MemsetZeroLengthCheck.h"
-#include "OverloadedUnaryAndCheck.h"
-#include "NonConstReferences.h"
-#include "StringReferenceMemberCheck.h"
-#include "TodoCommentCheck.h"
-#include "UnnamedNamespaceInHeaderCheck.h"
-#include "UsingNamespaceDirectiveCheck.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace google {
-
-class GoogleModule : public ClangTidyModule {
-public:
-  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    CheckFactories.registerCheck<build::ExplicitMakePairCheck>(
-        "google-build-explicit-make-pair");
-    CheckFactories.registerCheck<build::UnnamedNamespaceInHeaderCheck>(
-        "google-build-namespaces");
-    CheckFactories.registerCheck<build::UsingNamespaceDirectiveCheck>(
-        "google-build-using-namespace");
-    CheckFactories.registerCheck<DefaultArgumentsCheck>(
-        "google-default-arguments");
-    CheckFactories.registerCheck<ExplicitConstructorCheck>(
-        "google-explicit-constructor");
-    CheckFactories.registerCheck<runtime::IntegerTypesCheck>(
-        "google-runtime-int");
-    CheckFactories.registerCheck<runtime::OverloadedUnaryAndCheck>(
-        "google-runtime-operator");
-    CheckFactories.registerCheck<runtime::NonConstReferences>(
-        "google-runtime-references");
-    CheckFactories.registerCheck<runtime::StringReferenceMemberCheck>(
-        "google-runtime-member-string-references");
-    CheckFactories.registerCheck<runtime::MemsetZeroLengthCheck>(
-        "google-runtime-memset");
-    CheckFactories.registerCheck<readability::AvoidCStyleCastsCheck>(
-        "google-readability-casting");
-    CheckFactories.registerCheck<readability::TodoCommentCheck>(
-        "google-readability-todo");
-    CheckFactories
-        .registerCheck<clang::tidy::readability::BracesAroundStatementsCheck>(
-            "google-readability-braces-around-statements");
-    CheckFactories.registerCheck<readability::GlobalNamesInHeadersCheck>(
-        "google-global-names-in-headers");
-    CheckFactories.registerCheck<clang::tidy::readability::FunctionSizeCheck>(
-        "google-readability-function-size");
-    CheckFactories
-        .registerCheck<clang::tidy::readability::NamespaceCommentCheck>(
-            "google-readability-namespace-comments");
-    CheckFactories
-        .registerCheck<clang::tidy::readability::RedundantSmartptrGetCheck>(
-            "google-readability-redundant-smartptr-get");
-  }
-
-  ClangTidyOptions getModuleOptions() override {
-    ClangTidyOptions Options;
-    auto &Opts = Options.CheckOptions;
-    Opts["google-readability-braces-around-statements.ShortStatementLines"] =
-        "1";
-    Opts["google-readability-function-size.StatementThreshold"] = "800";
-    Opts["google-readability-namespace-comments.ShortNamespaceLines"] = "10";
-    Opts["google-readability-namespace-comments.SpacesBeforeComments"] = "2";
-    return Options;
-  }
-};
-
-// Register the GoogleTidyModule using this statically initialized variable.
-static ClangTidyModuleRegistry::Add<GoogleModule> X("google-module",
-                                                    "Adds Google lint checks.");
-
-} // namespace google
-
-// This anchor is used to force the linker to link in the generated object file
-// and thus register the GoogleModule.
-volatile int GoogleModuleAnchorSource = 0;
-
-} // namespace tidy
-} // namespace clang

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

@@ -1,145 +0,0 @@
-//===--- IntegerTypesCheck.cpp - clang-tidy -------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "IntegerTypesCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
-#include "clang/Basic/CharInfo.h"
-#include "clang/Basic/IdentifierTable.h"
-#include "clang/Basic/TargetInfo.h"
-#include "clang/Lex/Lexer.h"
-
-namespace clang {
-
-using namespace ast_matchers;
-
-static Token getTokenAtLoc(SourceLocation Loc,
-                           const MatchFinder::MatchResult &MatchResult,
-                           IdentifierTable &IdentTable) {
-  Token Tok;
-  if (Lexer::getRawToken(Loc, Tok, *MatchResult.SourceManager,
-                         MatchResult.Context->getLangOpts(), false))
-    return Tok;
-
-  if (Tok.is(tok::raw_identifier)) {
-    IdentifierInfo &Info = IdentTable.get(Tok.getRawIdentifier());
-    Tok.setIdentifierInfo(&Info);
-    Tok.setKind(Info.getTokenID());
-  }
-  return Tok;
-}
-
-namespace tidy {
-namespace google {
-namespace runtime {
-
-
-IntegerTypesCheck::IntegerTypesCheck(StringRef Name, ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      UnsignedTypePrefix(Options.get("UnsignedTypePrefix", "uint")),
-      SignedTypePrefix(Options.get("SignedTypePrefix", "int")),
-      TypeSuffix(Options.get("TypeSuffix", "")) {}
-
-void IntegerTypesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "UnsignedTypePrefix", UnsignedTypePrefix);
-  Options.store(Opts, "SignedTypePrefix", SignedTypePrefix);
-  Options.store(Opts, "TypeSuffix", TypeSuffix);
-}
-
-void IntegerTypesCheck::registerMatchers(MatchFinder *Finder) {
-  // Find all TypeLocs. The relevant Style Guide rule only applies to C++.
-  if (!getLangOpts().CPlusPlus)
-    return;
-  Finder->addMatcher(typeLoc(loc(isInteger())).bind("tl"), this);
-  IdentTable = llvm::make_unique<IdentifierTable>(getLangOpts());
-}
-
-void IntegerTypesCheck::check(const MatchFinder::MatchResult &Result) {
-  auto TL = *Result.Nodes.getNodeAs<TypeLoc>("tl");
-  SourceLocation Loc = TL.getLocStart();
-
-  if (Loc.isInvalid() || Loc.isMacroID())
-    return;
-
-  // Look through qualification.
-  if (auto QualLoc = TL.getAs<QualifiedTypeLoc>())
-    TL = QualLoc.getUnqualifiedLoc();
-
-  auto BuiltinLoc = TL.getAs<BuiltinTypeLoc>();
-  if (!BuiltinLoc)
-    return;
-
-  Token Tok = getTokenAtLoc(Loc, Result, *IdentTable);
-  // Ensure the location actually points to one of the builting integral type
-  // names we're interested in. Otherwise, we might be getting this match from
-  // implicit code (e.g. an implicit assignment operator of a class containing
-  // an array of non-POD types).
-  if (!Tok.isOneOf(tok::kw_short, tok::kw_long, tok::kw_unsigned,
-                   tok::kw_signed))
-    return;
-
-  bool IsSigned;
-  unsigned Width;
-  const TargetInfo &TargetInfo = Result.Context->getTargetInfo();
-
-  // Look for uses of short, long, long long and their unsigned versions.
-  switch (BuiltinLoc.getTypePtr()->getKind()) {
-  case BuiltinType::Short:
-    Width = TargetInfo.getShortWidth();
-    IsSigned = true;
-    break;
-  case BuiltinType::Long:
-    Width = TargetInfo.getLongWidth();
-    IsSigned = true;
-    break;
-  case BuiltinType::LongLong:
-    Width = TargetInfo.getLongLongWidth();
-    IsSigned = true;
-    break;
-  case BuiltinType::UShort:
-    Width = TargetInfo.getShortWidth();
-    IsSigned = false;
-    break;
-  case BuiltinType::ULong:
-    Width = TargetInfo.getLongWidth();
-    IsSigned = false;
-    break;
-  case BuiltinType::ULongLong:
-    Width = TargetInfo.getLongLongWidth();
-    IsSigned = false;
-    break;
-  default:
-    return;
-  }
-
-  // We allow "unsigned short port" as that's reasonably common and required by
-  // the sockets API.
-  const StringRef Port = "unsigned short port";
-  const char *Data = Result.SourceManager->getCharacterData(Loc);
-  if (!std::strncmp(Data, Port.data(), Port.size()) &&
-      !isIdentifierBody(Data[Port.size()]))
-    return;
-
-  std::string Replacement =
-      ((IsSigned ? SignedTypePrefix : UnsignedTypePrefix) + Twine(Width) +
-       TypeSuffix)
-          .str();
-
-  // We don't add a fix-it as changing the type can easily break code,
-  // e.g. when a function requires a 'long' argument on all platforms.
-  // QualTypes are printed with implicit quotes.
-  diag(Loc, "consider replacing %0 with '%1'") << BuiltinLoc.getType()
-                                               << Replacement;
-}
-
-} // namespace runtime
-} // namespace google
-} // namespace tidy
-} // namespace clang