[clang-tools-extra] Format sources with clang-format. NFC.

[mgrang]

Summary

Ran clang-format on all .c/.cpp/.h files in clang-tools-extra.
Excluded the test, unittests, clang-reorder-fields, include-fixer, modularize and pptrace directories.

[alexfh]

I assume you've just run clang-format on the sources? If yes, please say so in the patch description. If no, why fix any whitespace manually?

[alexfh]

I assume you've just run clang-format on the sources? If yes, please say so in the patch description. If no, why fix any whitespace manually?

[mgrang]

Ran clang-format on all C\C++ source files in clang-tools-extra.

[alexfh]

Please revert all files in test/. In many cases whitespace is important there and I don't want anyone to spend time figuring out all these cases.

[alexfh]

1. Please revert clang-reorder-fields, include-fixer, modularize and pptrace. The patch is too large now to work conveniently with it.
2. Try using a fresher version of clang-format to fix the formatting of switch case labels (see inline comments for details).
3. Once you address the comments, mark them as "Done" and check that clang-tools-extra still compiles and the tests pass.

clang-tidy/cert/CERTTidyModule.cpp

48–69 ↗

(On Diff #77050)

<ignore this comment. phabricator doesn't let me delete it for some reason>

clang-tidy/cppcoreguidelines/SlicingCheck.h

21–25 ↗

(On Diff #77050)

Please revert this.

clang-tidy/google/GlobalNamesInHeadersCheck.cpp

1–2 ↗

(On Diff #77050)

Please fix.

clang-tidy/google/MemsetZeroLengthCheck.cpp

1–2 ↗

(On Diff #77050)

Please fix.

clang-tidy/google/MemsetZeroLengthCheck.h

1–2 ↗

(On Diff #77050)

Please fix.

clang-tidy/google/NonConstReferences.cpp

88–124 ↗

(On Diff #77050)

Case labels should be indented by 2. Looks like a bug in clang-format, which doesn't, however, manifest in the version I'm using. Please revert this block.

clang-tidy/google/StringReferenceMemberCheck.h

1–2 ↗

(On Diff #77050)

Please fix.

clang-tidy/misc/ArgumentCommentCheck.h

30–31 ↗

(On Diff #77050)

Please revert this line.

clang-tidy/misc/NoexceptMoveConstructorCheck.cpp

46–66 ↗

(On Diff #77050)

Case labels should be indented. Please revert this block or reformat using a fresher version of clang-format.

[mgrang]

Thanks Alexander for your comments. I have addressed all of them in this patch.

[mgrang]

clang-tools-extra compiles fine and tests pass:

Testing Time: 8.27s

Expected Passes    : 291
Expected Failures  : 1

[alexfh]

One nit, otherwise LG. Do you need me to commit this for you?

clang-tidy/google/MemsetZeroLengthCheck.cpp

1 ↗

(On Diff #77128)

The right way to fix this is to remove extra -s so that clang-format won't wrap the line next time.

[mgrang]

Thanks Alexander. I can commit this myself.

[mgrang]

I had to rebase the patch as one of the files (clang-tidy/misc/NonCopyableObjects.cpp) had changed since I pushed my patch.

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

fixUsingShadowDecl(Result, UsingDeclaration);
                  Result.Nodes.getNodeAs<NestedNameSpecifierLoc>(
                      "nested_specifier_loc")) {
     SourceLocation Start = Specifier->getBeginLoc();
     SourceLocation End = EndLocationForType(Specifier->getTypeLoc());
     fixTypeLoc(Result, Start, End, Specifier->getTypeLoc());
   } else if (const auto *TLoc = Result.Nodes.getNodeAs<TypeLoc>("type")) {
     fixTypeLoc(Result, startLocationForType(*TLoc), EndLocationForType(*TLoc),
                *TLoc);
-  } else if (const auto *VarRef = Result.Nodes.getNodeAs<DeclRefExpr>("var_ref")){
+  } else if (const auto *VarRef =
+                 Result.Nodes.getNodeAs<DeclRefExpr>("var_ref")) {
     const auto *Var = Result.Nodes.getNodeAs<VarDecl>("var_decl");
     assert(Var);
     if (Var->getCanonicalDecl()->isStaticDataMember())
       return;
     std::string Name = Var->getQualifiedNameAsString();
     const clang::Decl *Context = Result.Nodes.getNodeAs<clang::Decl>("dc");
     assert(Context && "Empty decl context.");
     clang::SourceRange VarRefRange = VarRef->getSourceRange();
     replaceQualifiedSymbolInDeclContext(Result, Context, VarRefRange.getBegin(),
                                         VarRefRange.getEnd(), Name);
   } else {
     const auto *Call = Result.Nodes.getNodeAs<clang::CallExpr>("call");
-    assert(Call != nullptr &&"Expecting callback for CallExpr.");
-    const clang::FunctionDecl* Func = Call->getDirectCallee();
+    assert(Call != nullptr && "Expecting callback for CallExpr.");
+    const clang::FunctionDecl *Func = Call->getDirectCallee();
     assert(Func != nullptr);
     // Ignore out-of-line static methods since they will be handled by nested
     // name specifiers.
     if (Func->getCanonicalDecl()->getStorageClass() ==
             clang::StorageClass::SC_Static &&
         Func->isOutOfLine())
       return;
     std::string Name = Func->getQualifiedNameAsString();
replaceQualifiedSymbolInDeclContext(Result, DeclCtx, Start, End,
                                       FromDecl->getQualifiedNameAsString());
 }
 
 void ChangeNamespaceTool::fixUsingShadowDecl(
     const ast_matchers::MatchFinder::MatchResult &Result,
     const UsingDecl *UsingDeclaration) {
   SourceLocation Start = UsingDeclaration->getLocStart();
   SourceLocation End = UsingDeclaration->getLocEnd();
-  if (Start.isInvalid() || End.isInvalid()) return;
+  if (Start.isInvalid() || End.isInvalid())
+    return;
 
   assert(UsingDeclaration->shadow_size() > 0);
   // FIXME: it might not be always accurate to use the first using-decl.
   const NamedDecl *TargetDecl =
       UsingDeclaration->shadow_begin()->getTargetDecl();
   std::string TargetDeclName = TargetDecl->getQualifiedNameAsString();
   // FIXME: check if target_decl_name is in moved ns, which doesn't make much
   // sense. If this happens, we need to use name with the new namespace.

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

 } // 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;
+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;

 /// \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);
+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,
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.
 ///

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

 #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) {
+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] == '.') {

 }
 
 // FIXME: Remove this function after changing clang-apply-replacements to use
 // Replacements class.
 bool applyAllReplacements(const std::vector<tooling::Replacement> &Replaces,
                           Rewriter &Rewrite) {
   bool Result = true;
   for (std::vector<tooling::Replacement>::const_iterator I = Replaces.begin(),
                                                          E = Replaces.end();
        I != E; ++I) {
     if (I->isApplicable()) {
       Result = I->apply(Rewrite) && Result;
     } else {
       Result = false;
     }
   }
   return Result;
 }
 
-
 // FIXME: moved from libToolingCore. remove this when std::vector<Replacement>
 // is replaced with tooling::Replacements class.
 static void deduplicate(std::vector<tooling::Replacement> &Replaces,
                         std::vector<tooling::Range> &Conflicts) {
   if (Replaces.empty())
     return;
 
   auto LessNoPath = [](const tooling::Replacement &LHS,
                        const tooling::Replacement &RHS) {
     if (LHS.getOffset() != RHS.getOffset())
       return LHS.getOffset() < RHS.getOffset();
     if (LHS.getLength() != RHS.getLength())

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

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);
-  }
+  ~ScopedFileRemover() { deleteReplacementFiles(TURFiles, Diag); }
 
 private:
   const TUReplacementFiles &TURFiles;
   clang::DiagnosticsEngine &Diag;
 };
 } // namespace
 
 static void printVersion() {

 /// 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 (Replacements.empty())
+    return true;
 
   if (!applyAllReplacements(Replacements, Rewrites))
     return false;
 
   SourceManager &SM = Rewrites.getSourceMgr();
   FileManager &Files = SM.getFileManager();
 
   StringRef FileName = Replacements.begin()->getFilePath();

 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());
+      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;

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

public:
   ///
   /// \param IncludeHeader The name of the file being included, as written in
   /// the source code.
   /// \param IsAngled Whether the file name was enclosed in angle brackets.
   /// \param SearchPath The search path which was used to find the IncludeHeader
   /// in the file system. It can be a relative path or an absolute path.
   /// \param FileName The name of file where the IncludeHeader comes from.
   /// \param SM The SourceManager.
-  void addIncludes(llvm::StringRef IncludeHeader,
-                   bool IsAngled,
-                   llvm::StringRef SearchPath,
-                   llvm::StringRef FileName,
-                   const SourceManager& SM);
+  void addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
+                   llvm::StringRef SearchPath, llvm::StringRef FileName,
+                   const SourceManager &SM);
 
 private:
   void removeClassDefinitionInOldFiles();
   void moveClassDefinitionToNewFiles();
 
   MoveDefinitionSpec Spec;
   // The Key is file path, value is the replacements being applied to the file.
   std::map<std::string, tooling::Replacements> &FileToReplacements;

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

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace move {
 namespace {
 
 // FIXME: Move to ASTMatchers.
-AST_MATCHER(VarDecl, isStaticDataMember) {
-  return Node.isStaticDataMember();
-}
+AST_MATCHER(VarDecl, isStaticDataMember) { return Node.isStaticDataMember(); }
 
 AST_MATCHER_P(Decl, hasOutermostEnclosingClass,
               ast_matchers::internal::Matcher<Decl>, InnerMatcher) {
-  const auto* Context = Node.getDeclContext();
-  if (!Context) return false;
+  const auto *Context = Node.getDeclContext();
+  if (!Context)
+    return false;
   while (const auto *NextContext = Context->getParent()) {
     if (isa<NamespaceDecl>(NextContext) ||
         isa<TranslationUnitDecl>(NextContext))
       break;
     Context = NextContext;
   }
   return InnerMatcher.matches(*Decl::castFromDeclContext(Context), Finder,
                               Builder);
 }
 
 AST_MATCHER_P(CXXMethodDecl, ofOutermostEnclosingClass,
               ast_matchers::internal::Matcher<CXXRecordDecl>, InnerMatcher) {
   const CXXRecordDecl *Parent = Node.getParent();
-  if (!Parent) return false;
+  if (!Parent)
+    return false;
   while (const auto *NextParent =
              dyn_cast<CXXRecordDecl>(Parent->getParent())) {
     Parent = NextParent;
   }
 
   return InnerMatcher.matches(*Parent, Finder, Builder);
 }
 
 // Make the Path absolute using the CurrentDir if the Path is not an absolute
 // path. An empty Path will result in an empty string.
 std::string MakeAbsolutePath(StringRef CurrentDir, StringRef Path) {
   if (Path.empty())
     return "";
   llvm::SmallString<128> InitialDirectory(CurrentDir);
   llvm::SmallString<128> AbsolutePath(Path);
   if (std::error_code EC =
           llvm::sys::fs::make_absolute(InitialDirectory, AbsolutePath))
-    llvm::errs() << "Warning: could not make absolute file: '" <<  EC.message()
+    llvm::errs() << "Warning: could not make absolute file: '" << EC.message()
                  << '\n';
   llvm::sys::path::remove_dots(AbsolutePath, /*remove_dot_dot=*/true);
   llvm::sys::path::native(AbsolutePath);
   return AbsolutePath.str();
 }
 
 // Make the Path absolute using the current working directory of the given
 // SourceManager if the Path is not an absolute path.
 //
 // The Path can be a path relative to the build directory, or retrieved from
 // the SourceManager.
-std::string MakeAbsolutePath(const SourceManager& SM, StringRef Path) {
+std::string MakeAbsolutePath(const SourceManager &SM, StringRef Path) {
   llvm::SmallString<128> AbsolutePath(Path);
   if (std::error_code EC =
-       SM.getFileManager().getVirtualFileSystem()->makeAbsolute(AbsolutePath))
-    llvm::errs() << "Warning: could not make absolute file: '" <<  EC.message()
+          SM.getFileManager().getVirtualFileSystem()->makeAbsolute(
+              AbsolutePath))
+    llvm::errs() << "Warning: could not make absolute file: '" << EC.message()
                  << '\n';
   // Handle symbolic link path cases.
   // We are trying to get the real file path of the symlink.
   const DirectoryEntry *Dir = SM.getFileManager().getDirectory(
-       llvm::sys::path::parent_path(AbsolutePath.str()));
   if (Dir) {
     StringRef DirName = SM.getFileManager().getCanonicalName(Dir);
     SmallVector<char, 128> AbsoluteFilename;
     llvm::sys::path::append(AbsoluteFilename, DirName,
                             llvm::sys::path::filename(AbsolutePath.str()));
     return llvm::StringRef(AbsoluteFilename.data(), AbsoluteFilename.size())
         .str();
   }
getLocForEndOfDecl(const clang::Decl *D, const SourceManager *SM,
   // Lex from the start of the given location.
   Lexer Lex(SM->getLocForStartOfFile(LocInfo.first), LangOpts, File.begin(),
             TokBegin, File.end());
 
   llvm::SmallVector<char, 16> Line;
   // FIXME: this is a bit hacky to get ReadToEndOfLine work.
   Lex.setParsingPreprocessorDirective(true);
   Lex.ReadToEndOfLine(&Line);
-  SourceLocation EndLoc  = D->getLocEnd().getLocWithOffset(Line.size());
+  SourceLocation EndLoc = D->getLocEnd().getLocWithOffset(Line.size());
   // If we already reach EOF, just return the EOF SourceLocation;
   // otherwise, move 1 offset ahead to include the trailing newline character
   // '\n'.
   return SM->getLocForEndOfFile(LocInfo.first) == EndLoc
              ? EndLoc
              : EndLoc.getLocWithOffset(1);
 }
 
 // Get full range of a Decl including the comments associated with it.
 clang::CharSourceRange
 GetFullRange(const clang::SourceManager *SM, const clang::Decl *D,
              const clang::LangOptions &options = clang::LangOptions()) {
   clang::SourceRange Full = D->getSourceRange();
   Full.setEnd(getLocForEndOfDecl(D, SM));
   // Expand to comments that are associated with the Decl.
-  if (const auto* Comment =
-          D->getASTContext().getRawCommentForDeclNoCache(D)) {
+  if (const auto *Comment = D->getASTContext().getRawCommentForDeclNoCache(D)) {
     if (SM->isBeforeInTranslationUnit(Full.getEnd(), Comment->getLocEnd()))
       Full.setEnd(Comment->getLocEnd());
     // FIXME: Don't delete a preceding comment, if there are no other entities
     // it could refer to.
-    if (SM->isBeforeInTranslationUnit(Comment->getLocStart(),
-                                      Full.getBegin()))
+    if (SM->isBeforeInTranslationUnit(Comment->getLocStart(), Full.getBegin()))
       Full.setBegin(Comment->getLocStart());
   }
 
   return clang::CharSourceRange::getCharRange(Full);
 }
 
 std::string getDeclarationSourceText(const clang::Decl *D,
                                      const clang::SourceManager *SM) {
std::vector<std::string> GetNamespaces(const clang::Decl *D) {
   }
   std::reverse(Namespaces.begin(), Namespaces.end());
   return Namespaces;
 }
 
 clang::tooling::Replacements
 createInsertedReplacements(const std::vector<std::string> &Includes,
                            const std::vector<ClangMoveTool::MovedDecl> &Decls,
-                           llvm::StringRef FileName,
-                           bool IsHeader = false) {
+                           llvm::StringRef FileName, bool IsHeader = false) {
   std::string NewCode;
   std::string GuardName(FileName);
   if (IsHeader) {
     for (size_t i = 0; i < GuardName.size(); ++i) {
       if (!isAlphanumeric(GuardName[i]))
         GuardName[i] = '_';
     }
     GuardName = StringRef(GuardName).upper();
void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
   }
   if (!InMovedClassNames) {
     llvm::errs() << "No classes being moved.\n";
     return;
   }
 
   auto InOldHeader = isExpansionInFile(
       MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader));
-  auto InOldCC = isExpansionInFile(
-      MakeAbsolutePath(OriginalRunningDirectory, Spec.OldCC));
+  auto InOldCC =
+      isExpansionInFile(MakeAbsolutePath(OriginalRunningDirectory, Spec.OldCC));
   auto InOldFiles = anyOf(InOldHeader, InOldCC);
   auto InMovedClass =
       hasOutermostEnclosingClass(cxxRecordDecl(*InMovedClassNames));
 
   // Match moved class declarations.
   auto MovedClass = cxxRecordDecl(
       InOldFiles, *InMovedClassNames, isDefinition(),
       hasDeclContext(anyOf(namespaceDecl(), translationUnitDecl())));
   Finder->addMatcher(MovedClass.bind("moved_class"), this);
 
   // Match moved class methods (static methods included) which are defined
   // outside moved class declaration.
   Finder->addMatcher(
       cxxMethodDecl(InOldFiles, ofOutermostEnclosingClass(*InMovedClassNames),
                     isDefinition())
           .bind("class_method"),
       this);
 
   // Match static member variable definition of the moved class.
-  Finder->addMatcher(varDecl(InMovedClass, InOldCC, isDefinition(),
-                             isStaticDataMember())
-                         .bind("class_static_var_decl"),
-                     this);
+  Finder->addMatcher(
+      varDecl(InMovedClass, InOldCC, isDefinition(), isStaticDataMember())
 
   auto InOldCCNamedNamespace =
       allOf(hasParent(namespaceDecl(unless(isAnonymous()))), InOldCC);
   // Matching using decls/type alias decls which are in named namespace. Those
   // in classes, functions and anonymous namespaces are covered in other
   // matchers.
   Finder->addMatcher(
-      namedDecl(
-          anyOf(usingDecl(InOldCCNamedNamespace),
+      namedDecl(anyOf(usingDecl(InOldCCNamedNamespace),
                       usingDirectiveDecl(InOldCC, InOldCCNamedNamespace),
                       typeAliasDecl(InOldCC, InOldCCNamedNamespace)))
           .bind("using_decl"),
       this);
 
   // Match anonymous namespace decl in old cc.
   Finder->addMatcher(namespaceDecl(isAnonymous(), InOldCC).bind("anonymous_ns"),
                      this);
 
   // Match static functions/variable definitions which are defined in named
   // namespaces.
   auto IsOldCCStaticDefinition =
       allOf(isDefinition(), unless(InMovedClass), InOldCCNamedNamespace,
             isStaticStorageClass());
-  Finder->addMatcher(
-      namedDecl(anyOf(functionDecl(IsOldCCStaticDefinition),
+  Finder->addMatcher(namedDecl(anyOf(functionDecl(IsOldCCStaticDefinition),
                                      varDecl(IsOldCCStaticDefinition)))
                          .bind("static_decls"),
                      this);
 
   // Match forward declarations in old header.
   Finder->addMatcher(
       cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition())), InOldHeader)
           .bind("fwd_decl"),
       this);
 }
 
if (const auto *CMD =
     // Skip all forwad declarations which appear after moved class declaration.
     if (RemovedDecls.empty()) {
       if (const auto *DCT = FWD->getDescribedClassTemplate()) {
         MovedDecls.emplace_back(DCT, &Result.Context->getSourceManager());
       } else {
         MovedDecls.emplace_back(FWD, &Result.Context->getSourceManager());
       }
     }
-  } else if (const auto *ANS = Result.Nodes.getNodeAs<clang::NamespaceDecl>(
-                 "anonymous_ns")) {
+  } else if (const auto *ANS =
+                 Result.Nodes.getNodeAs<clang::NamespaceDecl>("anonymous_ns")) {
     MovedDecls.emplace_back(ANS, &Result.Context->getSourceManager());
   } else if (const auto *ND =
                  Result.Nodes.getNodeAs<clang::NamedDecl>("static_decls")) {
     MovedDecls.emplace_back(ND, &Result.Context->getSourceManager());
   } else if (const auto *UD =
                  Result.Nodes.getNodeAs<clang::NamedDecl>("using_decl")) {
     MovedDecls.emplace_back(UD, &Result.Context->getSourceManager());
   }
 }
 
-void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader,
-                                bool IsAngled,
+void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
                                 llvm::StringRef SearchPath,
                                 llvm::StringRef FileName,
-                                const SourceManager& SM) {
+                                const SourceManager &SM) {
   SmallVector<char, 128> HeaderWithSearchPath;
   llvm::sys::path::append(HeaderWithSearchPath, SearchPath, IncludeHeader);
   std::string AbsoluteOldHeader =
       MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader);
   // FIXME: Add old.h to the new.cc/h when the new target has dependencies on
   // old.h/c. For instance, when moved class uses another class defined in
   // old.h, the old.h should be added in new.h.
   if (AbsoluteOldHeader ==
void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
   }
 }
 
 void ClangMoveTool::removeClassDefinitionInOldFiles() {
   for (const auto &MovedDecl : RemovedDecls) {
     const auto &SM = *MovedDecl.SM;
     auto Range = GetFullRange(&SM, MovedDecl.Decl);
     clang::tooling::Replacement RemoveReplacement(
-        *MovedDecl.SM, clang::CharSourceRange::getCharRange(
-                           Range.getBegin(), Range.getEnd()),
+        *MovedDecl.SM,
+        clang::CharSourceRange::getCharRange(Range.getBegin(), Range.getEnd()),
         "");
     std::string FilePath = RemoveReplacement.getFilePath().str();
     auto Err = FileToReplacements[FilePath].add(RemoveReplacement);
     if (Err) {
       llvm::errs() << llvm::toString(std::move(Err)) << "\n";
       continue;
     }
 

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

 
 } // namespace
 
 int main(int argc, const char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
   // Add "-fparse-all-comments" compile option to make clang parse all comments,
   // otherwise, ordinary comments like "//" and "/*" won't get parsed (This is
   // a bit of hacky).
-  std::vector<std::string> ExtraArgs( argv, argv + argc );
-  ExtraArgs.insert(ExtraArgs.begin()+1, "-extra-arg=-fparse-all-comments");
+  std::vector<std::string> ExtraArgs(argv, argv + argc);
+  ExtraArgs.insert(ExtraArgs.begin() + 1, "-extra-arg=-fparse-all-comments");
   std::unique_ptr<const char *[]> RawExtraArgs(
       new const char *[ExtraArgs.size()]);
   for (size_t i = 0; i < ExtraArgs.size(); ++i)
     RawExtraArgs[i] = ExtraArgs[i].c_str();
   int Argc = argc + 1;
   tooling::CommonOptionsParser OptionsParser(Argc, RawExtraArgs.get(),
                                              ClangMoveCategory);
 
   tooling::RefactoringTool Tool(OptionsParser.getCompilations(),
                                 OptionsParser.getSourcePathList());
   move::ClangMoveTool::MoveDefinitionSpec Spec;
-  Spec.Names = { Names.begin(), Names.end() };
+  Spec.Names = {Names.begin(), Names.end()};
   Spec.OldHeader = OldHeader;
   Spec.NewHeader = NewHeader;
   Spec.OldCC = OldCC;
   Spec.NewCC = NewCC;
 
   llvm::SmallString<128> InitialDirectory;
   if (std::error_code EC = llvm::sys::fs::current_path(InitialDirectory))
     llvm::report_fatal_error("Cannot detect current path: " +

clang-tools-extra/trunk/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 OutputKind { OK_Diag, OK_Print, OK_Dump };
 
 enum QueryKind {
   QK_Invalid,
   QK_NoOp,
   QK_Help,
   QK_Let,
   QK_Match,
   QK_SetBool,

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

 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
+} // 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;
for (std::vector<BoundNodes>::iterator MI = Matches.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,
+            TD.emitDiagnostic(R.getBegin(), DiagnosticsEngine::Note,
                               "\"" + BI->first + "\" binds here",
-                CharSourceRange::getTokenRange(R),
-                None, &AST->getSourceManager());
+                              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;

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

public:
   /// 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) {}
+      : 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();

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

LexOrCompleteWord &Case(const char (&S)[N], const T &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);
-  }
+  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;
enum ParsedQueryKind {
   PQK_Help,
   PQK_Let,
   PQK_Match,
   PQK_Set,
   PQK_Unlet,
   PQK_Quit
 };
 
-enum ParsedQueryVariable {
-  PQV_Invalid,
-  PQV_Output,
-  PQV_BindRoot
-};
+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
+} // 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) {

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

for (const auto &FixIt : Hints) {
              "Only file locations supported in fix-it hints.");
 
       tooling::Replacement Replacement(SM, Range, FixIt.CodeToInsert);
       llvm::Error Err = Error.Fix[Replacement.getFilePath()].add(Replacement);
       // FIXME: better error handling (at least, don't let other replacements be
       // applied).
       if (Err) {
         llvm::errs() << "Fix conflicts with existing fix! "
                      << llvm::toString(std::move(Err)) << "\n";
         assert(false && "Fix conflicts with existing fix!");
       }
     }
   }
 
   void emitIncludeLocation(SourceLocation Loc, PresumedLoc PLoc,
                            const SourceManager &SM) override {}
 
ClangTidyMessage::ClangTidyMessage(StringRef Message,
     : 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) {}
+                               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;
   }
if (!Errors.empty()) {
     } else {
       ++Context.Stats.ErrorsDisplayed;
     }
   }
   LastErrorRelatesToUserCode = false;
   LastErrorPassesLineFilter = false;
 }
 
-static bool LineIsMarkedWithNOLINT(SourceManager& SM, SourceLocation Loc) {
+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.
static bool LineIsMarkedWithNOLINTinMacro(SourceManager &SM,
   return false;
 }
 
 void ClangTidyDiagnosticConsumer::HandleDiagnostic(
     DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
   if (LastErrorWasIgnored && DiagLevel == DiagnosticsEngine::Note)
     return;
 
-  if (Info.getLocation().isValid() &&
-      DiagLevel != DiagnosticsEngine::Error &&
+  if (Info.getLocation().isValid() && DiagLevel != DiagnosticsEngine::Error &&
       DiagLevel != DiagnosticsEngine::Fatal &&
-      LineIsMarkedWithNOLINTinMacro(Diags->getSourceManager(), Info.getLocation())) {
+      LineIsMarkedWithNOLINTinMacro(Diags->getSourceManager(),
+                                    Info.getLocation())) {
     ++Context.Stats.ErrorsIgnoredNOLINT;
     // Ignored a warning, should ignore related notes as well
     LastErrorWasIgnored = true;
     return;
   }
 
   LastErrorWasIgnored = false;
   // Count warnings/errors.

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

 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;
+  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.
   ///
public:
   ///   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);

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

 /// \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;
+                                     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:

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

 }
 
 FileOptionsProvider::FileOptionsProvider(
     const ClangTidyGlobalOptions &GlobalOptions,
     const ClangTidyOptions &DefaultOptions,
     const ClangTidyOptions &OverrideOptions,
     const FileOptionsProvider::ConfigFileHandlers &ConfigHandlers)
     : DefaultOptionsProvider(GlobalOptions, DefaultOptions),
-      OverrideOptions(OverrideOptions), ConfigHandlers(ConfigHandlers) {
-}
+      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");
 

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

 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<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<misc::ThrowByValueCatchByReferenceCheck>(
         "cert-err09-cpp");
-    CheckFactories.registerCheck<SetLongJmpCheck>(
-        "cert-err52-cpp");
-    CheckFactories.registerCheck<StaticObjectExceptionCheck>(
-        "cert-err58-cpp");
-    CheckFactories.registerCheck<ThrownExceptionTypeCheck>(
-        "cert-err60-cpp");
+    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");
     // MSC
-    CheckFactories.registerCheck<LimitedRandomnessCheck>(
-        "cert-msc50-cpp");
+    CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc50-cpp");
 
     // C checkers
     // DCL
-    CheckFactories.registerCheck<misc::StaticAssertCheck>(
-        "cert-dcl03-c");
+    CheckFactories.registerCheck<misc::StaticAssertCheck>("cert-dcl03-c");
     // ENV
-    CheckFactories.registerCheck<CommandProcessorCheck>(
-        "cert-env33-c");
+    CheckFactories.registerCheck<CommandProcessorCheck>("cert-env33-c");
     // FLP
-    CheckFactories.registerCheck<FloatLoopCounter>(
-        "cert-flp30-c");
+    CheckFactories.registerCheck<FloatLoopCounter>("cert-flp30-c");
     // FIO
-    CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>(
-        "cert-fio38-c");
+    CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>("cert-fio38-c");
     // ERR
-    CheckFactories.registerCheck<StrToNumCheck>(
-        "cert-err34-c");
+    CheckFactories.registerCheck<StrToNumCheck>("cert-err34-c");
     // MSC
-    CheckFactories.registerCheck<LimitedRandomnessCheck>(
-        "cert-msc30-c");
+    CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc30-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/trunk/clang-tidy/cert/LimitedRandomnessCheck.cpp

 }
 
 void LimitedRandomnessCheck::check(const MatchFinder::MatchResult &Result) {
   std::string msg = "";
   if (getLangOpts().CPlusPlus)
     msg = "; use C++11 random library instead";
 
   const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator");
-  diag(MatchedDecl->getLocStart(),
-       "rand() has limited randomness" + msg);
+  diag(MatchedDecl->getLocStart(), "rand() has limited randomness" + msg);
 }
 
 } // namespace cert
 } // namespace tidy
 } // namespace clang
-

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

void StaticObjectExceptionCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func");
 
   diag(VD->getLocation(),
        "initialization 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);
 
   SourceLocation FuncLocation = Func->getLocation();
-  if(FuncLocation.isValid()) {
+  if (FuncLocation.isValid()) {
     diag(FuncLocation,
          "possibly throwing %select{constructor|function}0 declared here",
          DiagnosticIDs::Note)
         << (isa<CXXConstructorDecl>(Func) ? 0 : 1);
   }
 }
 
 } // namespace cert
 } // namespace tidy
 } // namespace clang

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

 //===--- 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 "clang/Analysis/Analyses/FormatString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include <cassert>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace cert {

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

 
 /// 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/trunk/clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

 #include "ProBoundsPointerArithmeticCheck.h"
 #include "ProTypeConstCastCheck.h"
 #include "ProTypeCstyleCastCheck.h"
 #include "ProTypeMemberInitCheck.h"
 #include "ProTypeReinterpretCastCheck.h"
 #include "ProTypeStaticCastDowncastCheck.h"
 #include "ProTypeUnionAccessCheck.h"
 #include "ProTypeVarargCheck.h"
-#include "SpecialMemberFunctionsCheck.h"
 #include "SlicingCheck.h"
+#include "SpecialMemberFunctionsCheck.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<ProTypeStaticCastDowncastCheck>(
         "cppcoreguidelines-pro-type-static-cast-downcast");
     CheckFactories.registerCheck<ProTypeUnionAccessCheck>(
         "cppcoreguidelines-pro-type-union-access");
     CheckFactories.registerCheck<ProTypeVarargCheck>(
         "cppcoreguidelines-pro-type-vararg");
     CheckFactories.registerCheck<SpecialMemberFunctionsCheck>(
         "cppcoreguidelines-special-member-functions");
-    CheckFactories.registerCheck<SlicingCheck>(
-        "cppcoreguidelines-slicing");
+    CheckFactories.registerCheck<SlicingCheck>("cppcoreguidelines-slicing");
     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.");

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

 }
 
 void ProBoundsConstantArrayIndexCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   // Note: if a struct contains an array member, the compiler-generated
   // constructor has an arraySubscriptExpr.
-  Finder->addMatcher(arraySubscriptExpr(hasBase(ignoringImpCasts(hasType(
-                                            constantArrayType().bind("type")))),
-                                        hasIndex(expr().bind("index")),
-                                        unless(hasAncestor(isImplicit())))
-                         .bind("expr"),
-                     this);
+  Finder->addMatcher(
+      arraySubscriptExpr(
+          hasBase(ignoringImpCasts(hasType(constantArrayType().bind("type")))),
+          hasIndex(expr().bind("index")), unless(hasAncestor(isImplicit())))
 
   Finder->addMatcher(
       cxxOperatorCallExpr(
           hasOverloadedOperatorName("[]"),
           hasArgument(
               0, hasType(cxxRecordDecl(hasName("::std::array")).bind("type"))),
           hasArgument(1, expr().bind("index")))
           .bind("expr"),
void ProBoundsConstantArrayIndexCheck::check(
   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")
+    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)")
+    diag(Matched->getExprLoc(),
+         "std::array<> index %0 is past the end of the array "
         << Index.toString(10) << ArraySize.toString(10, false);
   }
 }
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.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.
+/// +, -, +=, -=, ++, --. 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/trunk/clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp

Finder->addMatcher(
       arraySubscriptExpr(
           hasBase(ignoringImpCasts(
               anyOf(hasType(pointerType()),
                     hasType(decayedType(hasDecayedType(pointerType())))))))
           .bind("expr"),
       this);
 }
 
-void
-ProBoundsPointerArithmeticCheck::check(const MatchFinder::MatchResult &Result) {
+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/trunk/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp

Finder->addMatcher(
                                IsNonTrivialDefaultConstructor))
           .bind("ctor"),
       this);
 
   // Match classes with a default constructor that is defaulted or is not in the
   // AST.
   Finder->addMatcher(
       cxxRecordDecl(
-          isDefinition(), unless(isInstantiated()),
-          hasDefaultConstructor(),
+          isDefinition(), unless(isInstantiated()), hasDefaultConstructor(),
           anyOf(has(cxxConstructorDecl(isDefaultConstructor(), isDefaulted(),
                                        unless(isImplicit()))),
                 unless(has(cxxConstructorDecl()))),
           unless(isTriviallyDefaultConstructible()))
           .bind("record"),
       this);
 
   auto HasDefaultConstructor = hasInitializer(
if (BasesToInit.empty())
     return;
 
   DiagnosticBuilder Diag =
       diag(Ctor ? Ctor->getLocStart() : ClassDecl.getLocation(),
            "constructor does not initialize these bases: %0")
       << toCommaSeparatedString(AllBases, BasesToInit);
 
   if (Ctor)
-      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/trunk/clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.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.
+/// 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/trunk/clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.cpp

void ProTypeStaticCastDowncastCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(
       cxxStaticCastExpr(unless(isInTemplateInstantiation())).bind("cast"),
       this);
 }
 
-void ProTypeStaticCastDowncastCheck::check(const MatchFinder::MatchResult &Result) {
+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();

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

public:
   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/trunk/clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.cpp

 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);
+  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");
+  diag(Matched->getMemberLoc(),
+       "do not access members of unions; use (boost::)variant instead");
 }
 
 } // namespace cppcoreguidelines
 } // namespace tidy
 } // namespace clang
-

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

 
 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);
+      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 '...'

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

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace readability {
 
-void
-AvoidCStyleCastsCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
+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"),
+          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();
case CK_NoOp:
     }
     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;

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

AST_MATCHER(DeclRefExpr, hasExplicitTemplateArgs) {
   return Node.hasExplicitTemplateArgs();
 }
 } // namespace
 
 namespace tidy {
 namespace google {
 namespace build {
 
-void
-ExplicitMakePairCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
+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"),
+                       .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/trunk/clang-tidy/google/GlobalNamesInHeadersCheck.cpp

 namespace readability {
 
 GlobalNamesInHeadersCheck::GlobalNamesInHeadersCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       RawStringHeaderFileExtensions(
           Options.getLocalOrGlobal("HeaderFileExtensions", "h")) {
   if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
-                                        HeaderFileExtensions,
-                                        ',')) {
+                                        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"),
+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 (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;
     }
   }

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

 #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 "OverloadedUnaryAndCheck.h"
 #include "StringReferenceMemberCheck.h"
 #include "TodoCommentCheck.h"
 #include "UnnamedNamespaceInHeaderCheck.h"
 #include "UsingNamespaceDirectiveCheck.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {

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

static Token getTokenAtLoc(SourceLocation Loc,
   }
   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);

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

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace runtime {
 
-void
-MemsetZeroLengthCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
+void MemsetZeroLengthCheck::registerMatchers(
+    ast_matchers::MatchFinder *Finder) {
   // Look for memset(x, y, 0) as those is most likely an argument swap.
   // TODO: Also handle other standard functions that suffer from the same
   //       problem, e.g. memchr.
-  Finder->addMatcher(
-      callExpr(callee(functionDecl(hasName("::memset"))), argumentCountIs(3),
-               unless(isInTemplateInstantiation())).bind("decl"),
+  Finder->addMatcher(callExpr(callee(functionDecl(hasName("::memset"))),
+                              argumentCountIs(3),
+                              unless(isInTemplateInstantiation()))
+                         .bind("decl"),
                      this);
 }
 
 /// \brief Get a StringRef representing a SourceRange.
 static StringRef getAsString(const MatchFinder::MatchResult &Result,
                              SourceRange R) {
   const SourceManager &SM = *Result.SourceManager;
   // Don't even try to resolve macro or include contraptions. Not worth emitting
   // a fixit for.

clang-tools-extra/trunk/clang-tidy/google/NonConstReferences.cpp

 
 NonConstReferences::NonConstReferences(StringRef Name,
                                        ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       WhiteListTypes(
           utils::options::parseStringList(Options.get("WhiteListTypes", ""))) {}
 
 void NonConstReferences::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-   Options.store(Opts, "WhiteListTypes",
-                 utils::options::serializeStringList(WhiteListTypes));
 }
 
 void NonConstReferences::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
   Finder->addMatcher(
       parmVarDecl(
void NonConstReferences::check(const MatchFinder::MatchResult &Result) {
   if (Function->getDeclName().isIdentifier() && Function->getName() == "swap")
     return;
 
   // iostream parameters are typically passed by non-const reference.
   if (StringRef(ReferencedType.getAsString()).endswith("stream"))
     return;
 
   if (Parameter->getName().empty()) {
-    diag(Parameter->getLocation(),
-         "non-const reference parameter at index %0, "
+    diag(Parameter->getLocation(), "non-const reference parameter at index %0, "
                                    "make it const or use a pointer")
         << Parameter->getFunctionScopeIndex();
   } else {
     diag(Parameter->getLocation(),
          "non-const reference parameter %0, make it const or use a pointer")
         << Parameter;
   }
 }
 
 } // namespace runtime
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/google/OverloadedUnaryAndCheck.cpp

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace google {
 namespace runtime {
 
-void
-OverloadedUnaryAndCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
+void OverloadedUnaryAndCheck::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;
 
   // Match unary methods that overload operator&.
   Finder->addMatcher(
       cxxMethodDecl(parameterCountIs(0), hasOverloadedOperatorName("&"))
           .bind("overload"),
       this);
   // Also match freestanding unary operator& overloads. Be careful not to match
   // binary methods.
   Finder->addMatcher(
-      functionDecl(
-          allOf(unless(cxxMethodDecl()),
-                functionDecl(parameterCountIs(1),
-                             hasOverloadedOperatorName("&")).bind("overload"))),
+      functionDecl(allOf(
+          unless(cxxMethodDecl()),
+          functionDecl(parameterCountIs(1), hasOverloadedOperatorName("&"))
+              .bind("overload"))),
       this);
 }
 
 void OverloadedUnaryAndCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Decl = Result.Nodes.getNodeAs<FunctionDecl>("overload");
   diag(Decl->getLocStart(),
        "do not overload unary operator&, it is dangerous.");
 }
 
 } // namespace runtime
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/google/StringReferenceMemberCheck.cpp

if (!getLangOpts().CPlusPlus)
     return;
 
   // Look for const references to std::string or ::string.
   auto String = anyOf(recordDecl(hasName("::std::basic_string")),
                       recordDecl(hasName("::string")));
   auto ConstString = qualType(isConstQualified(), hasDeclaration(String));
 
   // Ignore members in template instantiations.
-  Finder->addMatcher(fieldDecl(hasType(references(ConstString)),
-                               unless(isInstantiated())).bind("member"),
-                     this);
+  Finder->addMatcher(
+      fieldDecl(hasType(references(ConstString)), unless(isInstantiated()))
+          .bind("member"),
 }
 
-void
-StringReferenceMemberCheck::check(const MatchFinder::MatchResult &Result) {
+void StringReferenceMemberCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Member = Result.Nodes.getNodeAs<FieldDecl>("member");
   diag(Member->getLocStart(), "const string& members are dangerous; it is much "
                               "better to use alternatives, such as pointers or "
                               "simple constants");
 }
 
 } // namespace runtime
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/google/UnnamedNamespaceInHeaderCheck.cpp

 namespace build {
 
 UnnamedNamespaceInHeaderCheck::UnnamedNamespaceInHeaderCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       RawStringHeaderFileExtensions(
           Options.getLocalOrGlobal("HeaderFileExtensions", "h,hh,hpp,hxx")) {
   if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
-                                        HeaderFileExtensions,
-                                        ',')) {
+                                        HeaderFileExtensions, ',')) {
     llvm::errs() << "Invalid header file extension: "
                  << RawStringHeaderFileExtensions << "\n";
   }
 }
 
 void UnnamedNamespaceInHeaderCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions);
 }
 
 void UnnamedNamespaceInHeaderCheck::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)
     Finder->addMatcher(namespaceDecl(isAnonymous()).bind("anonymousNamespace"),
                        this);
 }
 
-void
-UnnamedNamespaceInHeaderCheck::check(const MatchFinder::MatchResult &Result) {
+void UnnamedNamespaceInHeaderCheck::check(
+    const MatchFinder::MatchResult &Result) {
   const auto *N = Result.Nodes.getNodeAs<NamespaceDecl>("anonymousNamespace");
   SourceLocation Loc = N->getLocStart();
   if (!Loc.isValid())
     return;
 
   if (utils::isPresumedLocInHeaderFile(Loc, *Result.SourceManager,
                                        HeaderFileExtensions))
     diag(Loc, "do not use unnamed namespaces in header files");
 }
 
 } // namespace build
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/google/UsingNamespaceDirectiveCheck.cpp

 void UsingNamespaceDirectiveCheck::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)
     Finder->addMatcher(usingDirectiveDecl().bind("usingNamespace"), this);
 }
 
-void
-UsingNamespaceDirectiveCheck::check(const MatchFinder::MatchResult &Result) {
+void UsingNamespaceDirectiveCheck::check(
+    const MatchFinder::MatchResult &Result) {
   const auto *U = Result.Nodes.getNodeAs<UsingDirectiveDecl>("usingNamespace");
   SourceLocation Loc = U->getLocStart();
   if (U->isImplicit() || !Loc.isValid())
     return;
 
   diag(Loc, "do not use namespace using-directives; "
             "use using-declarations instead");
   // TODO: We could suggest a list of using directives replacing the using
   //       namespace directive.
 }
 
 } // namespace build
 } // namespace google
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/llvm/HeaderGuardCheck.cpp

 //===--- HeaderGuardCheck.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 "HeaderGuardCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace llvm {
 
 LLVMHeaderGuardCheck::LLVMHeaderGuardCheck(StringRef Name,
-                                           ClangTidyContext* Context)
+                                           ClangTidyContext *Context)
     : HeaderGuardCheck(Name, Context),
       RawStringHeaderFileExtensions(
           Options.getLocalOrGlobal("HeaderFileExtensions", ",h,hh,hpp,hxx")) {
   utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
                                    HeaderFileExtensions, ',');
 }
 
 void LLVMHeaderGuardCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {

clang-tools-extra/trunk/clang-tidy/misc/ArgumentCommentCheck.h

 ///
 /// The check tries to detect typos and suggest automated fixes for them.
 class ArgumentCommentCheck : public ClangTidyCheck {
 public:
   ArgumentCommentCheck(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;
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
 
 private:
   const bool StrictMode;
   llvm::Regex IdentRE;
 
   bool isLikelyTypo(llvm::ArrayRef<ParmVarDecl *> Params, StringRef ArgName,
                     unsigned ArgIndex);
   void checkCallArgs(ASTContext *Ctx, const FunctionDecl *Callee,

clang-tools-extra/trunk/clang-tidy/misc/ArgumentCommentCheck.cpp

for (auto Comment : getCommentsInRange(Ctx, BeforeArgument)) {
         if (!sameName(Matches[2], II->getName(), StrictMode)) {
           {
             DiagnosticBuilder Diag =
                 diag(Comment.first, "argument name '%0' in comment does not "
                                     "match parameter name %1")
                 << Matches[2] << II;
             if (isLikelyTypo(Callee->parameters(), Matches[2], I)) {
               Diag << FixItHint::CreateReplacement(
-                          Comment.first,
-                          (Matches[1] + II->getName() + Matches[3]).str());
             }
           }
           diag(PVD->getLocation(), "%0 declared here", DiagnosticIDs::Note)
               << II;
         }
       }
     }
   }

clang-tools-extra/trunk/clang-tidy/misc/BoolPointerImplicitConversionCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BOOLPOINTERIMPLICITCONVERSIONCHECK_H
-

clang-tools-extra/trunk/clang-tidy/misc/BoolPointerImplicitConversionCheck.cpp

void BoolPointerImplicitConversionCheck::registerMatchers(MatchFinder *Finder) {
   // condition. Filter negations.
   Finder->addMatcher(
       ifStmt(hasCondition(findAll(implicitCastExpr(
                  allOf(unless(hasParent(unaryOperator(hasOperatorName("!")))),
                        hasSourceExpression(expr(
                            hasType(pointerType(pointee(booleanType()))),
                            ignoringParenImpCasts(declRefExpr().bind("expr")))),
                        hasCastKind(CK_PointerToBoolean))))),
-             unless(isInTemplateInstantiation())).bind("if"),
+             unless(isInTemplateInstantiation()))
+          .bind("if"),
       this);
 }
 
 void BoolPointerImplicitConversionCheck::check(
     const MatchFinder::MatchResult &Result) {
   auto *If = Result.Nodes.getStmtAs<IfStmt>("if");
   auto *Var = Result.Nodes.getStmtAs<DeclRefExpr>("expr");
 

clang-tools-extra/trunk/clang-tidy/misc/DefinitionsInHeadersCheck.cpp

 
 DefinitionsInHeadersCheck::DefinitionsInHeadersCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       UseHeaderFileExtension(Options.get("UseHeaderFileExtension", true)),
       RawStringHeaderFileExtensions(
           Options.getLocalOrGlobal("HeaderFileExtensions", ",h,hh,hpp,hxx")) {
   if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
-                                        HeaderFileExtensions,
-                                        ',')) {
+                                        HeaderFileExtensions, ',')) {
     // FIXME: Find a more suitable way to handle invalid configuration
     // options.
     llvm::errs() << "Invalid header file extension: "
                  << RawStringHeaderFileExtensions << "\n";
   }
 }
 
 void DefinitionsInHeadersCheck::storeOptions(

clang-tools-extra/trunk/clang-tidy/misc/ForwardDeclarationNamespaceCheck.h

 //===--- ForwardDeclarationNamespaceCheck.h - clang-tidy --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_FORWARDDECLARATIONNAMESPACECHECK_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_FORWARDDECLARATIONNAMESPACECHECK_H
 
+#include "../ClangTidy.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include <set>
 #include <vector>
-#include "llvm/ADT/SmallPtrSet.h"
-#include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 /// Checks if an unused forward declaration is in a wrong namespace.
 ///
 /// The check inspects all unused forward declarations and checks if there is

clang-tools-extra/trunk/clang-tidy/misc/ForwardDeclarationNamespaceCheck.cpp

 //===--- ForwardDeclarationNamespaceCheck.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 "ForwardDeclarationNamespaceCheck.h"
-#include <stack>
-#include <string>
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
+#include <stack>
+#include <string>
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 void ForwardDeclarationNamespaceCheck::registerMatchers(MatchFinder *Finder) {

clang-tools-extra/trunk/clang-tidy/misc/IncorrectRoundings.h

public:
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
-#endif  // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCORRECTROUNDINGS_H_
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCORRECTROUNDINGS_H_

clang-tools-extra/trunk/clang-tidy/misc/IncorrectRoundings.cpp

AST_MATCHER(FloatingLiteral, floatHalf) {
   if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle)
     return literal.convertToFloat() == 0.5f;
   if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble)
     return literal.convertToDouble() == 0.5;
   return false;
 }
 } // namespace
 
-
 void IncorrectRoundings::registerMatchers(MatchFinder *MatchFinder) {
   // Match a floating literal with value 0.5.
   auto FloatHalf = floatLiteral(floatHalf());
 
   // Match a floating point expression.
   auto FloatType = expr(hasType(realFloatingPointType()));
 
   // Match a floating literal of 0.5 or a floating literal of 0.5 implicitly.

clang-tools-extra/trunk/clang-tidy/misc/MacroParenthesesCheck.cpp

return T.isOneOf(tok::kw_bool, tok::kw_char, tok::kw_short, tok::kw_int,
                    tok::kw_signed, tok::kw_unsigned);
 }
 
 /// Is there a possible variable declaration at Tok?
 static bool possibleVarDecl(const MacroInfo *MI, const Token *Tok) {
   if (Tok == MI->tokens_end())
     return false;
 
-  // If we see int/short/struct/etc., just assume this is a variable declaration.
+  // If we see int/short/struct/etc., just assume this is a variable
+  // declaration.
   if (isVarDeclKeyword(*Tok))
     return true;
 
   // Variable declarations start with identifier or coloncolon.
   if (!Tok->isOneOf(tok::identifier, tok::raw_identifier, tok::coloncolon))
     return false;
 
   // Skip possible types, etc
-  while (
-      Tok != MI->tokens_end() &&
+  while (Tok != MI->tokens_end() &&
          Tok->isOneOf(tok::identifier, tok::raw_identifier, tok::coloncolon,
-                    tok::star, tok::amp, tok::ampamp, tok::less, tok::greater))
+                      tok::star, tok::amp, tok::ampamp, tok::less,
+                      tok::greater))
     Tok++;
 
   // Return true for possible variable declarations.
   return Tok == MI->tokens_end() ||
          Tok->isOneOf(tok::equal, tok::semi, tok::l_square, tok::l_paren) ||
          isVarDeclKeyword(*Tok);
 }
 

clang-tools-extra/trunk/clang-tidy/misc/MacroRepeatedSideEffectsCheck.cpp

 //===--- MacroRepeatedSideEffectsCheck.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 "MacroRepeatedSideEffectsCheck.h"
 #include "clang/Frontend/CompilerInstance.h"
+#include "clang/Lex/MacroArgs.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
-#include "clang/Lex/MacroArgs.h"
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 namespace {
 class MacroRepeatedPPCallbacks : public PPCallbacks {
 public:

clang-tools-extra/trunk/clang-tidy/misc/MiscTidyModule.cpp

 //===--- MiscTidyModule.cpp - clang-tidy ----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "ArgumentCommentCheck.h"
 #include "AssertSideEffectCheck.h"
-#include "MisplacedConstCheck.h"
-#include "UnconventionalAssignOperatorCheck.h"
 #include "BoolPointerImplicitConversionCheck.h"
 #include "DanglingHandleCheck.h"
 #include "DefinitionsInHeadersCheck.h"
 #include "FoldInitTypeCheck.h"
 #include "ForwardDeclarationNamespaceCheck.h"
 #include "InaccurateEraseCheck.h"
 #include "IncorrectRoundings.h"
 #include "InefficientAlgorithmCheck.h"
 #include "MacroParenthesesCheck.h"
 #include "MacroRepeatedSideEffectsCheck.h"
+#include "MisplacedConstCheck.h"
 #include "MisplacedWideningCastCheck.h"
 #include "MoveConstantArgumentCheck.h"
 #include "MoveConstructorInitCheck.h"
 #include "MoveForwardingReferenceCheck.h"
 #include "MultipleStatementMacroCheck.h"
 #include "NewDeleteOverloadsCheck.h"
 #include "NoexceptMoveConstructorCheck.h"
 #include "NonCopyableObjects.h"
 #include "RedundantExpressionCheck.h"
 #include "SizeofContainerCheck.h"
 #include "SizeofExpressionCheck.h"
 #include "StaticAssertCheck.h"
 #include "StringConstructorCheck.h"
 #include "StringIntegerAssignmentCheck.h"
 #include "StringLiteralWithEmbeddedNulCheck.h"
 #include "SuspiciousMissingCommaCheck.h"
 #include "SuspiciousSemicolonCheck.h"
 #include "SuspiciousStringCompareCheck.h"
 #include "SwappedArgumentsCheck.h"
 #include "ThrowByValueCatchByReferenceCheck.h"
+#include "UnconventionalAssignOperatorCheck.h"
 #include "UndelegatedConstructor.h"
 #include "UniqueptrResetReleaseCheck.h"
 #include "UnusedAliasDeclsCheck.h"
 #include "UnusedParametersCheck.h"
 #include "UnusedRAIICheck.h"
 #include "UnusedUsingDeclsCheck.h"
 #include "UseAfterMoveCheck.h"
 #include "VirtualNearMissCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 class MiscModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ArgumentCommentCheck>("misc-argument-comment");
     CheckFactories.registerCheck<AssertSideEffectCheck>(
         "misc-assert-side-effect");
-    CheckFactories.registerCheck<MisplacedConstCheck>(
-        "misc-misplaced-const");
+    CheckFactories.registerCheck<MisplacedConstCheck>("misc-misplaced-const");
     CheckFactories.registerCheck<UnconventionalAssignOperatorCheck>(
         "misc-unconventional-assign-operator");
     CheckFactories.registerCheck<BoolPointerImplicitConversionCheck>(
         "misc-bool-pointer-implicit-conversion");
-    CheckFactories.registerCheck<DanglingHandleCheck>(
-        "misc-dangling-handle");
+    CheckFactories.registerCheck<DanglingHandleCheck>("misc-dangling-handle");
     CheckFactories.registerCheck<DefinitionsInHeadersCheck>(
         "misc-definitions-in-headers");
-    CheckFactories.registerCheck<FoldInitTypeCheck>(
-        "misc-fold-init-type");
+    CheckFactories.registerCheck<FoldInitTypeCheck>("misc-fold-init-type");
     CheckFactories.registerCheck<ForwardDeclarationNamespaceCheck>(
         "misc-forward-declaration-namespace");
-    CheckFactories.registerCheck<InaccurateEraseCheck>(
-        "misc-inaccurate-erase");
+    CheckFactories.registerCheck<InaccurateEraseCheck>("misc-inaccurate-erase");
     CheckFactories.registerCheck<IncorrectRoundings>(
         "misc-incorrect-roundings");
     CheckFactories.registerCheck<InefficientAlgorithmCheck>(
         "misc-inefficient-algorithm");
     CheckFactories.registerCheck<MacroParenthesesCheck>(
         "misc-macro-parentheses");
     CheckFactories.registerCheck<MacroRepeatedSideEffectsCheck>(
         "misc-macro-repeated-side-effects");
CheckFactories.registerCheck<NoexceptMoveConstructorCheck>(
         "misc-noexcept-move-constructor");
     CheckFactories.registerCheck<NonCopyableObjectsCheck>(
         "misc-non-copyable-objects");
     CheckFactories.registerCheck<RedundantExpressionCheck>(
         "misc-redundant-expression");
     CheckFactories.registerCheck<SizeofContainerCheck>("misc-sizeof-container");
     CheckFactories.registerCheck<SizeofExpressionCheck>(
         "misc-sizeof-expression");
-    CheckFactories.registerCheck<StaticAssertCheck>(
-        "misc-static-assert");
+    CheckFactories.registerCheck<StaticAssertCheck>("misc-static-assert");
     CheckFactories.registerCheck<StringConstructorCheck>(
         "misc-string-constructor");
     CheckFactories.registerCheck<StringIntegerAssignmentCheck>(
         "misc-string-integer-assignment");
     CheckFactories.registerCheck<StringLiteralWithEmbeddedNulCheck>(
         "misc-string-literal-with-embedded-nul");
     CheckFactories.registerCheck<SuspiciousMissingCommaCheck>(
         "misc-suspicious-missing-comma");
CheckFactories.registerCheck<VirtualNearMissCheck>(
         "misc-virtual-near-miss");
   }
 };
 
 } // namespace misc
 
 // Register the MiscTidyModule using this statically initialized variable.
 static ClangTidyModuleRegistry::Add<misc::MiscModule>
     X("misc-module", "Adds miscellaneous lint checks.");
 
 // This anchor is used to force the linker to link in the generated object file
 // and thus register the MiscModule.
 volatile int MiscModuleAnchorSource = 0;
 
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/MisplacedWideningCastCheck.cpp

 //===--- MisplacedWideningCastCheck.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 "MisplacedWideningCastCheck.h"
+#include "../utils/Matchers.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "../utils/Matchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 MisplacedWideningCastCheck::MisplacedWideningCastCheck(
const auto ImplicitCast =
                        has(ignoringParenImpCasts(Calc)));
   const auto Cast = expr(anyOf(ExplicitCast, ImplicitCast)).bind("Cast");
 
   Finder->addMatcher(varDecl(hasInitializer(Cast)), this);
   Finder->addMatcher(returnStmt(hasReturnValue(Cast)), this);
   Finder->addMatcher(callExpr(hasAnyArgument(Cast)), this);
   Finder->addMatcher(binaryOperator(hasOperatorName("="), hasRHS(Cast)), this);
   Finder->addMatcher(
-      binaryOperator(matchers::isComparisonOperator(),
-                     hasEitherOperand(Cast)),
+      binaryOperator(matchers::isComparisonOperator(), hasEitherOperand(Cast)),
       this);
 }
 
 static unsigned getMaxCalculationWidth(const ASTContext &Context,
                                        const Expr *E) {
   E = E->IgnoreParenImpCasts();
 
   if (const auto *Bop = dyn_cast<BinaryOperator>(E)) {

clang-tools-extra/trunk/clang-tidy/misc/MoveConstantArgumentCheck.cpp

const auto *Var =
         IsVariable ? dyn_cast<DeclRefExpr>(Arg)->getDecl() : nullptr;
     auto Diag = diag(FileMoveRange.getBegin(),
                      "std::move of the %select{|const }0"
                      "%select{expression|variable %4}1 "
                      "%select{|of the trivially-copyable type %5 }2"
                      "has no effect; remove std::move()"
                      "%select{| or make the variable non-const}3")
                 << IsConstArg << IsVariable << IsTriviallyCopyable
-                << (IsConstArg && IsVariable && !IsTriviallyCopyable)
-                << Var << Arg->getType();
+                << (IsConstArg && IsVariable && !IsTriviallyCopyable) << Var
+                << Arg->getType();
 
     ReplaceCallWithArg(CallMove, Diag, SM, getLangOpts());
   } else if (ReceivingExpr) {
     auto Diag = diag(FileMoveRange.getBegin(),
                      "passing result of std::move() as a const reference "
                      "argument; no move will actually happen");
 
     ReplaceCallWithArg(CallMove, Diag, SM, getLangOpts());
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/MoveConstructorInitCheck.cpp

if (auto IncludeFixit = Inserter->CreateIncludeInsertion(
           /*IsAngled=*/true)) {
     DiagOut << *IncludeFixit;
   }
 }
 
 void MoveConstructorInitCheck::handleMoveConstructor(
     const MatchFinder::MatchResult &Result) {
   const auto *CopyCtor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
-  const auto *Initializer = Result.Nodes.getNodeAs<CXXCtorInitializer>("move-init");
+  const auto *Initializer =
+      Result.Nodes.getNodeAs<CXXCtorInitializer>("move-init");
 
   // Do not diagnose if the expression used to perform the initialization is a
   // trivially-copyable type.
   QualType QT = Initializer->getInit()->getType();
   if (QT.isTriviallyCopyableType(*Result.Context))
     return;
 
   const auto *RD = QT->getAsCXXRecordDecl();

clang-tools-extra/trunk/clang-tidy/misc/MultipleStatementMacroCheck.cpp

 /// \brief Find the next statement after `S`.
 const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) {
   auto Parents = Result.Context->getParents(*S);
   if (Parents.empty())
     return nullptr;
   const Stmt *Parent = Parents[0].get<Stmt>();
   if (!Parent)
     return nullptr;
-  const Stmt* Prev = nullptr;
+  const Stmt *Prev = nullptr;
   for (const Stmt *Child : Parent->children()) {
     if (Prev == S)
       return Child;
     Prev = Child;
   }
   return nextStmt(Result, Parent);
 }
 
 using ExpansionRanges = std::vector<std::pair<SourceLocation, SourceLocation>>;
 
 /// \bried Get all the macro expansion ranges related to `Loc`.
 ///
 /// The result is ordered from most inner to most outer.
 ExpansionRanges getExpansionRanges(SourceLocation Loc,
                                    const MatchFinder::MatchResult &Result) {
   ExpansionRanges Locs;
   while (Loc.isMacroID()) {
     Locs.push_back(Result.SourceManager->getImmediateExpansionRange(Loc));
     Loc = Locs.back().first;
   }
   return Locs;
 }
 
-}  // namespace
+} // namespace
 
 void MultipleStatementMacroCheck::registerMatchers(MatchFinder *Finder) {
   const auto Inner = expr(isInMacro(), unless(compoundStmt())).bind("inner");
   Finder->addMatcher(
       stmt(anyOf(ifStmt(hasThen(Inner)), ifStmt(hasElse(Inner)).bind("else"),
                  whileStmt(hasBody(Inner)), forStmt(hasBody(Inner))))
           .bind("outer"),
       this);

clang-tools-extra/trunk/clang-tidy/misc/NewDeleteOverloadsCheck.h

 #include <map>
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 class NewDeleteOverloadsCheck : public ClangTidyCheck {
   std::map<const clang::CXXRecordDecl *,
-           llvm::SmallVector<const clang::FunctionDecl *, 4>> Overloads;
+           llvm::SmallVector<const clang::FunctionDecl *, 4>>
+      Overloads;
 
 public:
   NewDeleteOverloadsCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
   void onEndOfTranslationUnit() override;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NEWDELETEOVERLOADS_H

clang-tools-extra/trunk/clang-tidy/misc/NewDeleteOverloadsCheck.cpp

if (Ctx.getLangOpts().SizedDeallocation &&
       Ctx.hasSameType(FPT->getParamType(1), Ctx.getSizeType()))
     return false;
 
   return true;
 }
 
 OverloadedOperatorKind getCorrespondingOverload(const FunctionDecl *FD) {
   switch (FD->getOverloadedOperator()) {
-  default: break;
+  default:
+    break;
   case OO_New:
     return OO_Delete;
   case OO_Delete:
     return OO_New;
   case OO_Array_New:
     return OO_Array_Delete;
   case OO_Array_Delete:
     return OO_Array_New;
   }
   llvm_unreachable("Not an overloaded allocation operator");
 }
 
 const char *getOperatorName(OverloadedOperatorKind K) {
   switch (K) {
-  default: break;
+  default:
+    break;
   case OO_New:
     return "operator new";
   case OO_Delete:
     return "operator delete";
   case OO_Array_New:
     return "operator new[]";
   case OO_Array_Delete:
     return "operator delete[]";
void NewDeleteOverloadsCheck::registerMatchers(MatchFinder *Finder) {
   // forms). Do not match implicit operators, placement operators, or
   // deleted/private operators.
   //
   // Technically, trivially-defined operator delete seems like a reasonable
   // thing to also skip. e.g., void operator delete(void *) {}
   // However, I think it's more reasonable to warn in this case as the user
   // should really be writing that as a deleted function.
   Finder->addMatcher(
-      functionDecl(
-          unless(anyOf(isImplicit(), isPlacementOverload(), isDeleted(),
-                       cxxMethodDecl(isPrivate()))),
+      functionDecl(unless(anyOf(isImplicit(), isPlacementOverload(),
+                                isDeleted(), cxxMethodDecl(isPrivate()))),
                    anyOf(hasOverloadedOperatorName("new"),
                          hasOverloadedOperatorName("new[]"),
                          hasOverloadedOperatorName("delete"),
                          hasOverloadedOperatorName("delete[]")))
           .bind("func"),
       this);
 }
 
 void NewDeleteOverloadsCheck::check(const MatchFinder::MatchResult &Result) {
   // Add any matches we locate to the list of things to be checked at the
   // end of the translation unit.
   const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("func");

clang-tools-extra/trunk/clang-tidy/misc/NoexceptMoveConstructorCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NOEXCEPTMOVECONSTRUCTORCHECK_H
-

clang-tools-extra/trunk/clang-tidy/misc/NoexceptMoveConstructorCheck.cpp

if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(Decl)) {
       if (!Ctor->isMoveConstructor())
         return;
       MethodType = "constructor";
     } else if (!Decl->isMoveAssignmentOperator()) {
       return;
     }
 
     const auto *ProtoType = Decl->getType()->getAs<FunctionProtoType>();
-    switch(ProtoType->getNoexceptSpec(*Result.Context)) {
-      case  FunctionProtoType::NR_NoNoexcept:
+    switch (ProtoType->getNoexceptSpec(*Result.Context)) {
+      case FunctionProtoType::NR_NoNoexcept:
         diag(Decl->getLocation(), "move %0s should be marked noexcept")
             << MethodType;
         // FIXME: Add a fixit.
         break;
       case FunctionProtoType::NR_Throw:
         // Don't complain about nothrow(false), but complain on nothrow(expr)
         // where expr evaluates to false.
         if (const Expr *E = ProtoType->getNoexceptExpr()) {
switch (ProtoType->getNoexceptSpec(*Result.Context)) {
         break;
     }
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
-

clang-tools-extra/trunk/clang-tidy/misc/NonCopyableObjects.h

 namespace tidy {
 namespace misc {
 
 /// The check flags dereferences and non-pointer declarations of objects that
 /// are not meant to be passed by value, such as C FILE objects.
 class NonCopyableObjectsCheck : public ClangTidyCheck {
 public:
   NonCopyableObjectsCheck(StringRef Name, ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTS_H

clang-tools-extra/trunk/clang-tidy/misc/SizeofContainerCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SIZEOF_CONTAINER_H
-

clang-tools-extra/trunk/clang-tidy/misc/SizeofContainerCheck.cpp

void SizeofContainerCheck::check(const MatchFinder::MatchResult &Result) {
   auto Diag =
       diag(SizeOf->getLocStart(), "sizeof() doesn't return the size of the "
                                   "container; did you mean .size()?");
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
-

clang-tools-extra/trunk/clang-tidy/misc/SizeofExpressionCheck.cpp

 //===--- SizeofExpressionCheck.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 "SizeofExpressionCheck.h"
+#include "../utils/Matchers.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "../utils/Matchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 namespace {

clang-tools-extra/trunk/clang-tidy/misc/StringIntegerAssignmentCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_INTEGER_ASSIGNMENT_H
-

clang-tools-extra/trunk/clang-tidy/misc/SuspiciousMissingCommaCheck.h

 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SUSPICIOUS_MISSING_COMMA_H
 
 #include "../ClangTidy.h"
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
-/// This check finds string literals which are probably concatenated accidentally.
+/// This check finds string literals which are probably concatenated
+/// accidentally.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/misc-suspicious-missing-comma.html
 class SuspiciousMissingCommaCheck : public ClangTidyCheck {
 public:
   SuspiciousMissingCommaCheck(StringRef Name, ClangTidyContext *Context);
   void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;

clang-tools-extra/trunk/clang-tidy/misc/SuspiciousMissingCommaCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 namespace {
 
-bool isConcatenatedLiteralsOnPurpose(ASTContext* Ctx,
-                                     const StringLiteral* Lit) {
+bool isConcatenatedLiteralsOnPurpose(ASTContext *Ctx,
+                                     const StringLiteral *Lit) {
   // String literals surrounded by parentheses are assumed to be on purpose.
   //    i.e.:  const char* Array[] = { ("a" "b" "c"), "d", [...] };
   auto Parents = Ctx->getParents(*Lit);
   if (Parents.size() == 1 && Parents[0].get<ParenExpr>() != nullptr)
     return true;
 
   // Appropriately indented string literals are assumed to be on purpose.
   // The following frequent indentation is accepted:
   //     const char* Array[] = {
   //       "first literal"
   //           "indented literal"
   //           "indented literal",
   //       "second literal",
   //       [...]
   //     };
-  const SourceManager& SM = Ctx->getSourceManager();
+  const SourceManager &SM = Ctx->getSourceManager();
   bool IndentedCorrectly = true;
   SourceLocation FirstToken = Lit->getStrTokenLoc(0);
   FileID BaseFID = SM.getFileID(FirstToken);
   unsigned int BaseIndent = SM.getSpellingColumnNumber(FirstToken);
   unsigned int BaseLine = SM.getSpellingLineNumber(FirstToken);
-  for (unsigned int TokNum = 1; TokNum < Lit->getNumConcatenated(); ++ TokNum) {
+  for (unsigned int TokNum = 1; TokNum < Lit->getNumConcatenated(); ++TokNum) {
     SourceLocation Token = Lit->getStrTokenLoc(TokNum);
     FileID FID = SM.getFileID(Token);
     unsigned int Indent = SM.getSpellingColumnNumber(Token);
     unsigned int Line = SM.getSpellingLineNumber(Token);
     if (FID != BaseFID || Line != BaseLine + TokNum || Indent <= BaseIndent) {
       IndentedCorrectly = false;
       break;
     }
   }
   if (IndentedCorrectly)
     return true;
 
   // There is no pattern recognized by the checker, assume it's not on purpose.
   return false;
 }
 
-AST_MATCHER_P(StringLiteral, isConcatenatedLiteral,
-              unsigned, MaxConcatenatedTokens) {
+AST_MATCHER_P(StringLiteral, isConcatenatedLiteral, unsigned,
+              MaxConcatenatedTokens) {
   return Node.getNumConcatenated() > 1 &&
          Node.getNumConcatenated() < MaxConcatenatedTokens &&
          !isConcatenatedLiteralsOnPurpose(&Finder->getASTContext(), &Node);
 }
 
-}  // namespace
+} // namespace
 
 SuspiciousMissingCommaCheck::SuspiciousMissingCommaCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       SizeThreshold(Options.get("SizeThreshold", 5U)),
       RatioThreshold(std::stod(Options.get("RatioThreshold", ".2"))),
       MaxConcatenatedTokens(Options.get("MaxConcatenatedTokens", 5U)) {}
 
void SuspiciousMissingCommaCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *InitializerList = Result.Nodes.getNodeAs<InitListExpr>("list");
   const auto *ConcatenatedLiteral =
       Result.Nodes.getNodeAs<StringLiteral>("str");
   assert(InitializerList && ConcatenatedLiteral);
 
   // Skip small arrays as they often generate false-positive.
   unsigned int Size = InitializerList->getNumInits();
-  if (Size < SizeThreshold) return;
+  if (Size < SizeThreshold)
+    return;
 
   // Count the number of occurence of concatenated string literal.
   unsigned int Count = 0;
   for (unsigned int i = 0; i < Size; ++i) {
     const Expr *Child = InitializerList->getInit(i)->IgnoreImpCasts();
     if (const auto *Literal = dyn_cast<StringLiteral>(Child)) {
-      if (Literal->getNumConcatenated() > 1) ++Count;
+      if (Literal->getNumConcatenated() > 1)
+        ++Count;
     }
   }
 
   // Warn only when concatenation is not common in this initializer list.
   // The current threshold is set to less than 1/5 of the string literals.
-  if (double(Count) / Size > RatioThreshold) return;
+  if (double(Count) / Size > RatioThreshold)
+    return;
 
   diag(ConcatenatedLiteral->getLocStart(),
        "suspicious string literal, probably missing a comma");
 }
 
-}  // namespace misc
-}  // namespace tidy
-}  // namespace clang
+} // namespace misc
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/SuspiciousStringCompareCheck.cpp

 #include "clang/Lex/Lexer.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
-
 // Semicolon separated list of known string compare-like functions. The list
 // must ends with a semicolon.
 static const char KnownStringCompareFunctions[] = "__builtin_memcmp;"
                                                   "__builtin_strcasecmp;"
                                                   "__builtin_strcmp;"
                                                   "__builtin_strncasecmp;"
                                                   "__builtin_strncmp;"
                                                   "_mbscmp;"
void SuspiciousStringCompareCheck::registerMatchers(MatchFinder *Finder) {
 
   // Match a call to a string compare functions.
   const auto FunctionCompareDecl =
       functionDecl(hasAnyName(std::vector<StringRef>(FunctionNames.begin(),
                                                      FunctionNames.end())))
           .bind("decl");
   const auto DirectStringCompareCallExpr =
       callExpr(hasDeclaration(FunctionCompareDecl)).bind("call");
-  const auto MacroStringCompareCallExpr =
-      conditionalOperator(
-        anyOf(hasTrueExpression(ignoringParenImpCasts(DirectStringCompareCallExpr)),
-              hasFalseExpression(ignoringParenImpCasts(DirectStringCompareCallExpr))));
+  const auto MacroStringCompareCallExpr = conditionalOperator(anyOf(
+      hasTrueExpression(ignoringParenImpCasts(DirectStringCompareCallExpr)),
   // The implicit cast is not present in C.
   const auto StringCompareCallExpr = ignoringParenImpCasts(
-        anyOf(DirectStringCompareCallExpr, MacroStringCompareCallExpr));
 
   if (WarnOnImplicitComparison) {
     // Detect suspicious calls to string compare:
     //     'if (strcmp())'  ->  'if (strcmp() != 0)'
     Finder->addMatcher(
         stmt(anyOf(ifStmt(hasCondition(StringCompareCallExpr)),
                    whileStmt(hasCondition(StringCompareCallExpr)),
                    doStmt(hasCondition(StringCompareCallExpr)),
void SuspiciousStringCompareCheck::check(
   }
 
   if (Result.Nodes.getNodeAs<Stmt>("invalid-comparison")) {
     diag(Call->getLocStart(),
          "function %0 is compared to a suspicious constant")
         << Decl;
   }
 
-  if (const auto* BinOp = Result.Nodes.getNodeAs<BinaryOperator>("suspicious-operator")) {
+  if (const auto *BinOp =
+          Result.Nodes.getNodeAs<BinaryOperator>("suspicious-operator")) {
     diag(Call->getLocStart(), "results of function %0 used by operator '%1'")
         << Decl << BinOp->getOpcodeStr();
   }
 
   if (Result.Nodes.getNodeAs<Stmt>("invalid-conversion")) {
     diag(Call->getLocStart(), "function %0 has suspicious implicit cast")
         << Decl;
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp

 //===--- ThrowByValueCatchByReferenceCheck.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 "ThrowByValueCatchByReferenceCheck.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/AST/OperationKinds.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
 ThrowByValueCatchByReferenceCheck::ThrowByValueCatchByReferenceCheck(

clang-tools-extra/trunk/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp

 #include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace misc {
 
-void UnconventionalAssignOperatorCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
+void UnconventionalAssignOperatorCheck::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;
 
   const auto HasGoodReturnType = cxxMethodDecl(returns(
       lValueReferenceType(pointee(unless(isConstQualified()),
                                   hasDeclaration(equalsBoundNode("class"))))));
const auto IsBadReturnStatement = returnStmt(unless(has(ignoringParenImpCasts(
       unaryOperator(hasOperatorName("*"), hasUnaryOperand(cxxThisExpr()))))));
   const auto IsGoodAssign = cxxMethodDecl(IsAssign, HasGoodReturnType);
 
   Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))
                          .bind("returnStmt"),
                      this);
 }
 
-void UnconventionalAssignOperatorCheck::check(const MatchFinder::MatchResult &Result) {
+void UnconventionalAssignOperatorCheck::check(
+    const MatchFinder::MatchResult &Result) {
   if (const auto *RetStmt = Result.Nodes.getNodeAs<ReturnStmt>("returnStmt")) {
     diag(RetStmt->getLocStart(), "operator=() should always return '*this'");
   } else {
     static const char *const Messages[][2] = {
         {"ReturnType", "operator=() should return '%0&'"},
         {"ArgumentType", "operator=() should take '%0 const&', '%0&&' or '%0'"},
         {"cv", "operator=() should not be marked '%1'"}};
 

clang-tools-extra/trunk/clang-tidy/misc/UndelegatedConstructor.cpp

Finder->addMatcher(
           forEach(ignoringTemporaryExpr(
               cxxConstructExpr(hasDeclaration(cxxConstructorDecl(ofClass(
                                    cxxRecordDecl(baseOfBoundNode("parent"))))))
                   .bind("construct"))),
           unless(isInTemplateInstantiation())),
       this);
 }
 
-void UndelegatedConstructorCheck::check(const MatchFinder::MatchResult &Result) {
+void UndelegatedConstructorCheck::check(
+    const MatchFinder::MatchResult &Result) {
   const auto *E = Result.Nodes.getStmtAs<CXXConstructExpr>("construct");
   diag(E->getLocStart(), "did you intend to call a delegated constructor? "
                          "A temporary object is created here instead");
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp

if (LeftAsTemplate && RightAsTemplate &&
     // are compatible.
     // This handles things like std::default_delete<Base> vs.
     // std::default_delete<Derived>.
     return true;
   }
   return false;
 }
 
-}  // namespace
+} // namespace
 
 void UniqueptrResetReleaseCheck::check(const MatchFinder::MatchResult &Result) {
   if (!areDeletersCompatible(Result))
     return;
 
   const auto *ResetMember = Result.Nodes.getNodeAs<MemberExpr>("reset_member");
   const auto *ReleaseMember =
       Result.Nodes.getNodeAs<MemberExpr>("release_member");
if (!Right->isRValue() || ReleaseMember->isArrow()) {
     RightText = "std::move(" + RightText + ")";
     DiagText = "prefer ptr1 = std::move(ptr2) over ptr1.reset(ptr2.release())";
   } else {
     DiagText =
         "prefer ptr = ReturnUnique() over ptr.reset(ReturnUnique().release())";
   }
   std::string NewText = LeftText + " = " + RightText;
 
-  diag(ResetMember->getExprLoc(), DiagText)
-      << FixItHint::CreateReplacement(
-          CharSourceRange::getTokenRange(ResetCall->getSourceRange()), NewText);
+  diag(ResetMember->getExprLoc(), DiagText) << FixItHint::CreateReplacement(
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/UnusedAliasDeclsCheck.h

private:
   llvm::DenseMap<const NamedDecl *, CharSourceRange> FoundDecls;
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H
-

clang-tools-extra/trunk/clang-tidy/misc/UnusedParametersCheck.h

warnOnUnusedParameter(const ast_matchers::MatchFinder::MatchResult &Result,
                         const FunctionDecl *Function, unsigned ParamIndex);
 };
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H
-

clang-tools-extra/trunk/clang-tidy/misc/UnusedParametersCheck.cpp

void UnusedParametersCheck::warnOnUnusedParameter(
   for (const auto &Match : CallMatches)
     MyDiag << removeArgument(Result, Match.getNodeAs<CallExpr>("x"),
                              ParamIndex);
 }
 
 void UnusedParametersCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("function");
   if (!Function->doesThisDeclarationHaveABody() ||
-      !Function->hasWrittenPrototype() ||
-      Function->isTemplateInstantiation())
+      !Function->hasWrittenPrototype() || Function->isTemplateInstantiation())
     return;
   if (const auto *Method = dyn_cast<CXXMethodDecl>(Function))
     if (Method->isLambdaStaticInvoker())
       return;
   for (unsigned i = 0, e = Function->getNumParams(); i != e; ++i) {
     const auto *Param = Function->getParamDecl(i);
     if (Param->isUsed() || Param->isReferenced() || !Param->getDeclName() ||
         Param->hasAttr<UnusedAttr>())
       continue;
     warnOnUnusedParameter(Result, Function, i);
   }
 }
 
 } // namespace misc
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/UnusedUsingDeclsCheck.cpp

void UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(declRefExpr().bind("used"), this);
   Finder->addMatcher(callExpr(callee(unresolvedLookupExpr().bind("used"))),
                      this);
   Finder->addMatcher(
       callExpr(hasDeclaration(functionDecl(hasAnyTemplateArgument(
           anyOf(refersToTemplate(templateName().bind("used")),
                 refersToDeclaration(functionDecl().bind("used"))))))),
       this);
-  Finder->addMatcher(loc(templateSpecializationType(
-      hasAnyTemplateArgument(templateArgument().bind("used")))), this);
+  Finder->addMatcher(loc(templateSpecializationType(hasAnyTemplateArgument(
+                         templateArgument().bind("used")))),
+                     this);
 }
 
 void UnusedUsingDeclsCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
     // Ignores using-declarations defined in macros.
     if (Using->getLocation().isMacroID())
       return;
 
if (const auto *DRE = Result.Nodes.getNodeAs<DeclRefExpr>("used")) {
     } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
       removeFromFoundDecls(ECD);
       if (const auto *ET = ECD->getType()->getAs<EnumType>())
         removeFromFoundDecls(ET->getDecl());
     }
   }
   // Check the uninstantiated template function usage.
   if (const auto *ULE = Result.Nodes.getNodeAs<UnresolvedLookupExpr>("used")) {
-    for (const NamedDecl* ND : ULE->decls()) {
+    for (const NamedDecl *ND : ULE->decls()) {
       if (const auto *USD = dyn_cast<UsingShadowDecl>(ND))
         removeFromFoundDecls(USD->getTargetDecl()->getCanonicalDecl());
     }
   }
 }
 
 void UnusedUsingDeclsCheck::removeFromFoundDecls(const Decl *D) {
   if (!D)

clang-tools-extra/trunk/clang-tidy/misc/UseAfterMoveCheck.cpp

for (const auto &Match : Matches) {
         // before adding it to the set.
         if (TheDeclRef)
           DeclRefs->insert(TheDeclRef);
       }
     }
   }
 }
 
-static void emitDiagnostic(const Expr *MovingCall,
-                           const DeclRefExpr *MoveArg,
+static void emitDiagnostic(const Expr *MovingCall, const DeclRefExpr *MoveArg,
                            const UseAfterMove &Use, ClangTidyCheck *Check,
                            ASTContext *Context) {
   SourceLocation UseLoc = Use.DeclRef->getExprLoc();
   SourceLocation MoveLoc = MovingCall->getExprLoc();
 
   Check->diag(UseLoc, "'%0' used after it was moved")
       << MoveArg->getDecl()->getName();
   Check->diag(MoveLoc, "move occurred here", DiagnosticIDs::Note);
static void emitDiagnostic(const Expr *MovingCall, const DeclRefExpr *MoveArg,
   }
 }
 
 void UseAfterMoveCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus11)
     return;
 
   auto CallMoveMatcher =
-      callExpr(
-          callee(functionDecl(hasName("::std::move"))), argumentCountIs(1),
+      callExpr(callee(functionDecl(hasName("::std::move"))), argumentCountIs(1),
                hasArgument(0, declRefExpr().bind("arg")),
                anyOf(hasAncestor(lambdaExpr().bind("containing-lambda")),
                      hasAncestor(functionDecl().bind("containing-func"))),
                unless(inDecltypeOrTemplateArg()))
           .bind("call-move");
 
   Finder->addMatcher(
       // To find the Stmt that we assume performs the actual move, we look for
       // the direct ancestor of the std::move() that isn't one of the node
       // types ignored by ignoringParenImpCasts().
       stmt(forEach(expr(ignoringParenImpCasts(CallMoveMatcher))),
            unless(expr(ignoringParenImpCasts(equalsBoundNode("call-move")))))

clang-tools-extra/trunk/clang-tidy/modernize/AvoidBindCheck.cpp

void AvoidBindCheck::check(const MatchFinder::MatchResult &Result) {
 
   bool HasCapturedArgument = llvm::any_of(
       Args, [](const BindArgument &B) { return B.Kind == BK_Other; });
   const auto *Ref = Result.Nodes.getNodeAs<DeclRefExpr>("ref");
   Stream << "[" << (HasCapturedArgument ? "=" : "") << "]";
   addPlaceholderArgs(Args, Stream);
   Stream << " { return ";
   Ref->printPretty(Stream, nullptr, Result.Context->getPrintingPolicy());
-  Stream<< "(";
+  Stream << "(";
   addFunctionCallArgs(Args, Stream);
   Stream << "); };";
 
   Diag << FixItHint::CreateReplacement(MatchedDecl->getSourceRange(),
                                        Stream.str());
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/MakeUniqueCheck.h

protected:
   SmartPtrTypeMatcher getSmartPointerTypeMatcher() const override;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_UNIQUE_H
-

clang-tools-extra/trunk/clang-tidy/modernize/ModernizeTidyModule.cpp

 
 namespace clang {
 namespace tidy {
 namespace modernize {
 
 class ModernizeModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    CheckFactories.registerCheck<AvoidBindCheck>(
-        "modernize-avoid-bind");
+    CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind");
     CheckFactories.registerCheck<DeprecatedHeadersCheck>(
         "modernize-deprecated-headers");
     CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert");
     CheckFactories.registerCheck<MakeSharedCheck>("modernize-make-shared");
     CheckFactories.registerCheck<MakeUniqueCheck>("modernize-make-unique");
     CheckFactories.registerCheck<PassByValueCheck>("modernize-pass-by-value");
     CheckFactories.registerCheck<RawStringLiteralCheck>(
         "modernize-raw-string-literal");

clang-tools-extra/trunk/clang-tidy/modernize/RawStringLiteralCheck.cpp

 void RawStringLiteralCheck::replaceWithRawStringLiteral(
     const MatchFinder::MatchResult &Result, const StringLiteral *Literal) {
   CharSourceRange CharRange = Lexer::makeFileCharRange(
       CharSourceRange::getTokenRange(Literal->getSourceRange()),
       *Result.SourceManager, getLangOpts());
   diag(Literal->getLocStart(),
        "escaped string literal can be written as a raw string literal")
       << FixItHint::CreateReplacement(
              CharRange, asRawStringLiteral(Literal, DelimiterStem));
 }
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/modernize/UseAutoCheck.cpp

 //===--- UseAutoCheck.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 "UseAutoCheck.h"
 #include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
 
 using namespace clang;
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::internal;
 
 namespace clang {
 namespace tidy {
 namespace modernize {

 ///   class vector {};
 ///   class forward_list {};
 ///   class my_ver{};
 /// \endcode
 ///
 /// recordDecl(hasStdContainerName()) matches \c vector and \c forward_list
 /// but not \c my_vec.
 AST_MATCHER(NamedDecl, hasStdContainerName) {
-  static const char *const ContainerNames[] = {"array",         "deque",
-                                               "forward_list",  "list",
-                                               "vector",
+  static const char *const ContainerNames[] = {
+      "array",         "deque",
 
-                                               "map",           "multimap",
-                                               "set",           "multiset",
 
-                                               "unordered_map",
-                                               "unordered_multimap",
-                                               "unordered_set",
-                                               "unordered_multiset",
+      "unordered_map", "unordered_multimap",
+      "unordered_set", "unordered_multiset",
 
-                                               "queue",         "priority_queue",
-                                               "stack"};
 
   for (const char *Name : ContainerNames) {
     if (hasName(Name).matches(Node, Finder, Builder))
       return true;
   }
   return false;
 }
 

clang-tools-extra/trunk/clang-tidy/modernize/UseDefaultCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace modernize
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_DEFAULT_H
-

clang-tools-extra/trunk/clang-tidy/modernize/UseNullptrCheck.cpp

 
 /// \brief Create a matcher that finds implicit casts as well as the head of a
 /// sequence of zero or more nested explicit casts that have an implicit cast
 /// to null within.
 /// Finding sequences of explict casts is necessary so that an entire sequence
 /// can be replaced instead of just the inner-most implicit cast.
 StatementMatcher makeCastSequenceMatcher() {
   StatementMatcher ImplicitCastToNull = implicitCastExpr(
-      anyOf(hasCastKind(CK_NullToPointer),
-            hasCastKind(CK_NullToMemberPointer)),
+      anyOf(hasCastKind(CK_NullToPointer), hasCastKind(CK_NullToMemberPointer)),
       unless(hasSourceExpression(hasType(sugaredNullptrType()))));
 
   return castExpr(anyOf(ImplicitCastToNull,
                         explicitCastExpr(hasDescendant(ImplicitCastToNull))),
                   unless(hasAncestor(explicitCastExpr())))
       .bind(CastSequence);
 }
 

clang-tools-extra/trunk/clang-tidy/mpi/TypeMismatchCheck.h

private:
   /// Check if the buffer type MPI datatype pairs match.
   ///
   /// \param BufferTypes buffer types
   /// \param BufferExprs buffer arguments as expressions
   /// \param MPIDatatypes MPI datatype
   /// \param LO language options
   void checkArguments(ArrayRef<const Type *> BufferTypes,
                       ArrayRef<const Expr *> BufferExprs,
-                      ArrayRef<StringRef> MPIDatatypes,
-                      const LangOptions &LO);
+                      ArrayRef<StringRef> MPIDatatypes, const LangOptions &LO);
 };
 
 } // namespace mpi
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MPI_TYPE_MISMATCH_H

clang-tools-extra/trunk/clang-tidy/performance/FasterStringFindCheck.cpp

 llvm::Optional<std::string> MakeCharacterLiteral(const StringLiteral *Literal) {
   std::string Result;
   {
     llvm::raw_string_ostream OS(Result);
     Literal->outputString(OS);
   }
   // Now replace the " with '.
   auto pos = Result.find_first_of('"');
-  if (pos == Result.npos) return llvm::None;
+  if (pos == Result.npos)
+    return llvm::None;
   Result[pos] = '\'';
   pos = Result.find_last_of('"');
-  if (pos == Result.npos) return llvm::None;
+  if (pos == Result.npos)
+    return llvm::None;
   Result[pos] = '\'';
   return Result;
 }
 
 AST_MATCHER_FUNCTION(ast_matchers::internal::Matcher<Expr>,
                      hasSubstitutedType) {
   return hasType(qualType(anyOf(substTemplateTypeParmType(),
                                 hasDescendant(substTemplateTypeParmType()))));
 }
 
 } // namespace
 
 FasterStringFindCheck::FasterStringFindCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       StringLikeClasses(utils::options::parseStringList(
-          Options.get("StringLikeClasses", "std::basic_string"))) {
-}
+          Options.get("StringLikeClasses", "std::basic_string"))) {}
 
 void FasterStringFindCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StringLikeClasses",
                 utils::options::serializeStringList(StringLikeClasses));
 }
 
 void FasterStringFindCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)

clang-tools-extra/trunk/clang-tidy/performance/ImplicitCastInLoopCheck.h

 namespace clang {
 namespace tidy {
 namespace performance {
 
 // Checks that in a for range loop, if the provided type is a reference, then
 // the underlying type is the one returned by the iterator (i.e. that there
 // isn't any implicit conversion).
 class ImplicitCastInLoopCheck : public ClangTidyCheck {
- public:
-   ImplicitCastInLoopCheck(StringRef Name, ClangTidyContext *Context)
-       : ClangTidyCheck(Name, Context) {}
-   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
- private:
   void ReportAndFix(const ASTContext *Context, const VarDecl *VD,
                     const CXXOperatorCallExpr *OperatorCall);
 };
 
 } // namespace performance
 } // namespace tidy
 } // namespace clang
 
-#endif  // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_IMPLICIT_CAST_IN_LOOP_CHECK_H_
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_IMPLICIT_CAST_IN_LOOP_CHECK_H_

clang-tools-extra/trunk/clang-tidy/performance/ImplicitCastInLoopCheck.cpp

 namespace {
 // Checks if the stmt is a ImplicitCastExpr with a CastKind that is not a NoOp.
 // The subtelty is that in some cases (user defined conversions), we can
 // get to ImplicitCastExpr inside each other, with the outer one a NoOp. In this
 // case we skip the first cast expr.
 bool IsNonTrivialImplicitCast(const Stmt *ST) {
   if (const auto *ICE = dyn_cast<ImplicitCastExpr>(ST)) {
     return (ICE->getCastKind() != CK_NoOp) ||
-            IsNonTrivialImplicitCast(ICE->getSubExpr());
   }
   return false;
 }
 } // namespace
 
 void ImplicitCastInLoopCheck::registerMatchers(MatchFinder *Finder) {
   // We look for const ref loop variables that (optionally inside an
   // ExprWithCleanup) materialize a temporary, and contain a implicit cast. The

clang-tools-extra/trunk/clang-tidy/performance/UnnecessaryCopyInitialization.cpp

void recordFixes(const VarDecl &Var, ASTContext &Context,
                  DiagnosticBuilder &Diagnostic) {
   Diagnostic << utils::fixit::changeVarDeclToReference(Var, Context);
   if (!Var.getType().isLocalConstQualified())
     Diagnostic << utils::fixit::changeVarDeclToConst(Var);
 }
 
 } // namespace
 
-
 using namespace ::clang::ast_matchers;
 using utils::decl_ref_expr::isOnlyUsedAsConst;
 
 void UnnecessaryCopyInitialization::registerMatchers(MatchFinder *Finder) {
   auto ConstReference = referenceType(pointee(qualType(isConstQualified())));
   auto ConstOrConstReference =
       allOf(anyOf(ConstReference, isConstQualified()),
             unless(allOf(pointerType(), unless(pointerType(pointee(
                                             qualType(isConstQualified())))))));
 
   // Match method call expressions where the `this` argument is only used as
   // const, this will be checked in `check()` part. This returned const
   // reference is highly likely to outlive the local const reference of the
   // variable being declared. The assumption is that the const reference being
   // returned either points to a global static variable or to a member of the
   // called object.
-  auto ConstRefReturningMethodCall = cxxMemberCallExpr(
-      callee(cxxMethodDecl(returns(ConstReference))),
+  auto ConstRefReturningMethodCall =
+      cxxMemberCallExpr(callee(cxxMethodDecl(returns(ConstReference))),
                         on(declRefExpr(to(varDecl().bind("objectArg")))));
   auto ConstRefReturningFunctionCall =
       callExpr(callee(functionDecl(returns(ConstReference))),
                unless(callee(cxxMethodDecl())));
 
   auto localVarCopiedFrom = [](const internal::Matcher<Expr> &CopyCtorArg) {
     return compoundStmt(
                forEachDescendant(
                    declStmt(
                        has(varDecl(hasLocalStorage(),
                                    hasType(matchers::isExpensiveToCopy()),
                                    unless(isImplicit()),
                                    hasInitializer(
                                        cxxConstructExpr(
                                            hasDeclaration(cxxConstructorDecl(
                                                isCopyConstructor())),
                                            hasArgument(0, CopyCtorArg))
                                            .bind("ctorCall")))
-                               .bind("newVarDecl"))).bind("declStmt")))
+                               .bind("newVarDecl")))
+                       .bind("declStmt")))
         .bind("blockStmt");
   };
 
-  Finder->addMatcher(
-      localVarCopiedFrom(anyOf(ConstRefReturningFunctionCall,
+  Finder->addMatcher(localVarCopiedFrom(anyOf(ConstRefReturningFunctionCall,
                                               ConstRefReturningMethodCall)),
                      this);
 
   Finder->addMatcher(localVarCopiedFrom(declRefExpr(
                          to(varDecl(hasLocalStorage()).bind("oldVarDecl")))),
                      this);
 }
 
 void UnnecessaryCopyInitialization::check(
     const MatchFinder::MatchResult &Result) {

clang-tools-extra/trunk/clang-tidy/performance/UnnecessaryValueParamCheck.cpp

void UnnecessaryValueParamCheck::check(const MatchFinder::MatchResult &Result) {
   // function is virtual as it might break overrides.
   const auto *Method = llvm::dyn_cast<CXXMethodDecl>(Function);
   if (Param->getLocStart().isMacroID() || (Method && Method->isVirtual()))
     return;
   for (const auto *FunctionDecl = Function; FunctionDecl != nullptr;
        FunctionDecl = FunctionDecl->getPreviousDecl()) {
     const auto &CurrentParam = *FunctionDecl->getParamDecl(Index);
     Diag << utils::fixit::changeVarDeclToReference(CurrentParam,
-                                                           *Result.Context);
     // The parameter of each declaration needs to be checked individually as to
     // whether it is const or not as constness can differ between definition and
     // declaration.
     if (!CurrentParam.getType().getCanonicalType().isConstQualified())
       Diag << utils::fixit::changeVarDeclToConst(CurrentParam);
   }
 }
 

clang-tools-extra/trunk/clang-tidy/readability/AvoidConstParamsInDecls.cpp

 //===--- AvoidConstParamsInDecls.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 "AvoidConstParamsInDecls.h"
-#include "llvm/ADT/Optional.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Lex/Lexer.h"
+#include "llvm/ADT/Optional.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 namespace {
 

clang-tools-extra/trunk/clang-tidy/readability/BracesAroundStatementsCheck.h

private:
   bool checkStmt(const ast_matchers::MatchFinder::MatchResult &Result,
                  const Stmt *S, SourceLocation StartLoc,
                  SourceLocation EndLocHint = SourceLocation());
   template <typename IfOrWhileStmt>
   SourceLocation findRParenLoc(const IfOrWhileStmt *S, const SourceManager &SM,
                                const ASTContext *Context);
 
 private:
-  std::set<const Stmt*> ForceBracesStmts;
+  std::set<const Stmt *> ForceBracesStmts;
   const unsigned ShortStatementLines;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_BRACESAROUNDSTATEMENTSCHECK_H

clang-tools-extra/trunk/clang-tidy/readability/BracesAroundStatementsCheck.cpp

 } // namespace
 
 BracesAroundStatementsCheck::BracesAroundStatementsCheck(
     StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       // Always add braces by default.
       ShortStatementLines(Options.get("ShortStatementLines", 0U)) {}
 
-void
-BracesAroundStatementsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+void BracesAroundStatementsCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "ShortStatementLines", ShortStatementLines);
 }
 
 void BracesAroundStatementsCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(ifStmt().bind("if"), this);
   Finder->addMatcher(whileStmt().bind("while"), this);
   Finder->addMatcher(doStmt().bind("do"), this);
   Finder->addMatcher(forStmt().bind("for"), this);
   Finder->addMatcher(cxxForRangeStmt().bind("for-range"), this);
 }
 
-void
-BracesAroundStatementsCheck::check(const MatchFinder::MatchResult &Result) {
+void BracesAroundStatementsCheck::check(
+    const MatchFinder::MatchResult &Result) {
   const SourceManager &SM = *Result.SourceManager;
   const ASTContext *Context = Result.Context;
 
   // Get location of closing parenthesis or 'do' to insert opening brace.
   if (auto S = Result.Nodes.getNodeAs<ForStmt>("for")) {
     checkStmt(Result, S->getBody(), S->getRParenLoc());
   } else if (auto S = Result.Nodes.getNodeAs<CXXForRangeStmt>("for-range")) {
     checkStmt(Result, S->getBody(), S->getRParenLoc());

clang-tools-extra/trunk/clang-tidy/readability/IdentifierNamingCheck.cpp

 //===--- IdentifierNamingCheck.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 "IdentifierNamingCheck.h"
 
-#include "llvm/ADT/DenseMapInfo.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/Format.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
+#include "llvm/ADT/DenseMapInfo.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Format.h"
 
 #define DEBUG_TYPE "clang-tidy"
 
 using namespace clang::ast_matchers;
 
 namespace llvm {
 /// Specialisation of DenseMapInfo to allow NamingCheckId objects in DenseMaps
 template <>
static void addUsage(IdentifierNamingCheck::NamingCheckFailureMap &Failures,
 
   bool RangeCanBeFixed =
       RangeIsEntirelyWithinMacroArgument || !RangeContainsMacroExpansion;
   Failure.ShouldFix = RangeCanBeFixed;
 }
 
 /// Convenience method when the usage to be added is a NamedDecl
 static void addUsage(IdentifierNamingCheck::NamingCheckFailureMap &Failures,
-                     const NamedDecl *Decl, SourceRange Range, SourceManager *SourceMgr = nullptr) {
+                     const NamedDecl *Decl, SourceRange Range,
+                     SourceManager *SourceMgr = nullptr) {
   return addUsage(Failures, IdentifierNamingCheck::NamingCheckId(
                                 Decl->getLocation(), Decl->getNameAsString()),
                   Range, SourceMgr);
 }
 
 void IdentifierNamingCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Decl =
           Result.Nodes.getNodeAs<CXXConstructorDecl>("classRef")) {
for (const auto &Shadow : Decl->shadows()) {
       addUsage(NamingCheckFailures, Shadow->getTargetDecl(),
                Decl->getNameInfo().getSourceRange());
     }
     return;
   }
 
   if (const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declRef")) {
     SourceRange Range = DeclRef->getNameInfo().getSourceRange();
-    addUsage(NamingCheckFailures, DeclRef->getDecl(), Range, Result.SourceManager);
+    addUsage(NamingCheckFailures, DeclRef->getDecl(), Range,
+             Result.SourceManager);
     return;
   }
 
   if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
     if (!Decl->getIdentifier() || Decl->getName().empty() || Decl->isImplicit())
       return;
 
     // Fix type aliases in value declarations

clang-tools-extra/trunk/clang-tidy/readability/ImplicitBoolCastCheck.cpp

 ImplicitBoolCastCheck::ImplicitBoolCastCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       AllowConditionalIntegerCasts(
           Options.get("AllowConditionalIntegerCasts", false)),
       AllowConditionalPointerCasts(
           Options.get("AllowConditionalPointerCasts", false)) {}
 
-void ImplicitBoolCastCheck::storeOptions(
-    ClangTidyOptions::OptionMap &Opts) {
+void ImplicitBoolCastCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "AllowConditionalIntegerCasts",
                 AllowConditionalIntegerCasts);
   Options.store(Opts, "AllowConditionalPointerCasts",
                 AllowConditionalPointerCasts);
 }
 
 void ImplicitBoolCastCheck::registerMatchers(MatchFinder *Finder) {
   // This check doesn't make much sense if we run it on language without

clang-tools-extra/trunk/clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp

while (SourceParamIt != ParameterSourceDeclaration->param_end() &&
     auto OtherParamName = (*OtherParamIt)->getName();
 
     // FIXME: Provide a way to extract commented out parameter name from comment
     // next to it.
     if (!SourceParamName.empty() && !OtherParamName.empty() &&
         SourceParamName != OtherParamName) {
       SourceRange OtherParamNameRange =
           DeclarationNameInfo((*OtherParamIt)->getDeclName(),
-                              (*OtherParamIt)->getLocation()).getSourceRange();
+                              (*OtherParamIt)->getLocation())
+              .getSourceRange();
 
       bool GenerateFixItHint = checkIfFixItHintIsApplicable(
           ParameterSourceDeclaration, *SourceParamIt, OriginalDeclaration);
 
       DifferingParams.emplace_back(SourceParamName, OtherParamName,
                                    OtherParamNameRange, GenerateFixItHint);
     }
 
else
       Str << ", ";
 
     Str << "'" << ChooseParamName(ParamInfo).str() << "'";
   }
   return Str.str().str();
 }
 
 void formatDifferingParamsDiagnostic(
-    InconsistentDeclarationParameterNameCheck *Check,
-    SourceLocation Location, StringRef OtherDeclarationDescription,
+    InconsistentDeclarationParameterNameCheck *Check, SourceLocation Location,
+    StringRef OtherDeclarationDescription,
     const DifferingParamsContainer &DifferingParams) {
-  auto ChooseOtherName =
-      [](const DifferingParamInfo &ParamInfo) { return ParamInfo.OtherName; };
-  auto ChooseSourceName =
-      [](const DifferingParamInfo &ParamInfo) { return ParamInfo.SourceName; };
+  auto ChooseOtherName = [](const DifferingParamInfo &ParamInfo) {
+    return ParamInfo.OtherName;
+  };
+  auto ChooseSourceName = [](const DifferingParamInfo &ParamInfo) {
+    return ParamInfo.SourceName;
+  };
 
   auto ParamDiag =
       Check->diag(Location,
                   "differing parameters are named here: (%0), in %1: (%2)",
                   DiagnosticIDs::Level::Note)
       << joinParameterNames(DifferingParams, ChooseOtherName)
       << OtherDeclarationDescription
       << joinParameterNames(DifferingParams, ChooseSourceName);

clang-tools-extra/trunk/clang-tidy/readability/NamespaceCommentCheck.cpp

if (NamespaceCommentPattern.match(Comment, &Groups)) {
 
       // Otherwise we need to fix the comment.
       NeedLineBreak = Comment.startswith("/*");
       OldCommentRange =
           SourceRange(AfterRBrace, Loc.getLocWithOffset(Tok.getLength()));
       Message =
           (llvm::Twine(
                "%0 ends with a comment that refers to a wrong namespace '") +
-           NamespaceNameInComment + "'").str();
+           NamespaceNameInComment + "'")
+              .str();
     } else if (Comment.startswith("//")) {
       // Assume that this is an unrecognized form of a namespace closing line
       // comment. Replace it.
       NeedLineBreak = false;
       OldCommentRange =
           SourceRange(AfterRBrace, Loc.getLocWithOffset(Tok.getLength()));
       Message = "%0 ends with an unrecognized comment";
     }

clang-tools-extra/trunk/clang-tidy/readability/RedundantControlFlowCheck.cpp

 bool isLocationInMacroExpansion(const SourceManager &SM, SourceLocation Loc) {
   return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc);
 }
 
 } // namespace
 
 void RedundantControlFlowCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
-      functionDecl(isDefinition(), returns(voidType()),
-                   has(compoundStmt(hasAnySubstatement(returnStmt(
-                                        unless(has(expr()))))).bind("return"))),
+      functionDecl(
+          isDefinition(), returns(voidType()),
+          has(compoundStmt(hasAnySubstatement(returnStmt(unless(has(expr())))))
+                  .bind("return"))),
       this);
   auto CompoundContinue =
       has(compoundStmt(hasAnySubstatement(continueStmt())).bind("continue"));
   Finder->addMatcher(
       stmt(anyOf(forStmt(), cxxForRangeStmt(), whileStmt(), doStmt()),
            CompoundContinue),
       this);
 }

clang-tools-extra/trunk/clang-tidy/readability/RedundantDeclarationCheck.cpp

 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {
 
 void RedundantDeclarationCheck::registerMatchers(MatchFinder *Finder) {
-  Finder->addMatcher(namedDecl(anyOf(varDecl(), functionDecl())).bind("Decl"), this);
+  Finder->addMatcher(namedDecl(anyOf(varDecl(), functionDecl())).bind("Decl"),
+                     this);
 }
 
 void RedundantDeclarationCheck::check(const MatchFinder::MatchResult &Result) {
   const NamedDecl *D = Result.Nodes.getNodeAs<NamedDecl>("Decl");
   const auto *Prev = D->getPreviousDecl();
   if (!Prev)
     return;
   if (Prev->getLocation() == D->getLocation())
     return;
 
   const SourceManager &SM = *Result.SourceManager;
 
   const bool DifferentHeaders =
-       !SM.isInMainFile(D->getLocation()) &&
-       !SM.isWrittenInSameFile(Prev->getLocation(), D->getLocation());
 
   bool MultiVar = false;
   if (const auto *VD = dyn_cast<VarDecl>(D)) {
     if (VD->getPreviousDecl()->getStorageClass() == SC_Extern &&
         VD->getStorageClass() != SC_Extern)
       return;
     // Is this a multivariable declaration?
     for (const auto Other : VD->getDeclContext()->decls()) {
       if (Other != D && Other->getLocStart() == VD->getLocStart()) {
         MultiVar = true;
         break;
       }
     }
   } else {
     const auto *FD = cast<FunctionDecl>(D);
     if (FD->isThisDeclarationADefinition())
       return;
   }
 
   SourceLocation EndLoc = Lexer::getLocForEndOfToken(
       D->getSourceRange().getEnd(), 0, SM, Result.Context->getLangOpts());
   {
-    auto Diag = diag(D->getLocation(), "redundant %0 declaration")
-                << D;
+    auto Diag = diag(D->getLocation(), "redundant %0 declaration") << D;
     if (!MultiVar && !DifferentHeaders)
       Diag << FixItHint::CreateRemoval(
           SourceRange(D->getSourceRange().getBegin(), EndLoc));
   }
   diag(Prev->getLocation(), "previously declared here", DiagnosticIDs::Note);
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/clang-tidy/readability/RedundantMemberInitCheck.cpp

 //===--- RedundantMemberInitCheck.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 "RedundantMemberInitCheck.h"
+#include "../utils/Matchers.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/Lexer.h"
-#include "../utils/Matchers.h"
 #include <algorithm>
 
 using namespace clang::ast_matchers;
 using namespace clang::tidy::matchers;
 
 namespace clang {
 namespace tidy {
 namespace readability {

clang-tools-extra/trunk/clang-tidy/readability/RedundantStringCStrCheck.cpp

 void RedundantStringCStrCheck::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;
 
   // Match expressions of type 'string' or 'string*'.
-  const auto StringDecl =
-      cxxRecordDecl(hasName("::std::basic_string"));
+  const auto StringDecl = cxxRecordDecl(hasName("::std::basic_string"));
   const auto StringExpr =
-      expr(anyOf(hasType(StringDecl),
-                 hasType(qualType(pointsTo(StringDecl)))));
+      expr(anyOf(hasType(StringDecl), hasType(qualType(pointsTo(StringDecl)))));
 
   // Match string constructor.
   const auto StringConstructorExpr = expr(anyOf(
-      cxxConstructExpr(
-          argumentCountIs(1),
+      cxxConstructExpr(argumentCountIs(1),
                        hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
       cxxConstructExpr(
           argumentCountIs(2),
           hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
           // If present, the second argument is the alloc object which must not
           // be present explicitly.
           hasArgument(1, cxxDefaultArgExpr()))));
 
   // Match a call to the string 'c_str()' method.
   const auto StringCStrCallExpr =
       cxxMemberCallExpr(on(StringExpr.bind("arg")),
                         callee(memberExpr().bind("member")),
                         callee(cxxMethodDecl(hasAnyName("c_str", "data"))))
           .bind("call");
 
   // Detect redundant 'c_str()' calls through a string constructor.
-  Finder->addMatcher(
-      cxxConstructExpr(StringConstructorExpr,
+  Finder->addMatcher(cxxConstructExpr(StringConstructorExpr,
                                       hasArgument(0, StringCStrCallExpr)),
                      this);
 
   // Detect: 's == str.c_str()'  ->  's == str'
   Finder->addMatcher(
       cxxOperatorCallExpr(
-          anyOf(hasOverloadedOperatorName("<"),
-                hasOverloadedOperatorName(">"),
-                hasOverloadedOperatorName(">="),
-                hasOverloadedOperatorName("<="),
-                hasOverloadedOperatorName("!="),
-                hasOverloadedOperatorName("=="),
-                hasOverloadedOperatorName("+")),
+          anyOf(
+              hasOverloadedOperatorName("<"), hasOverloadedOperatorName(">"),
+              hasOverloadedOperatorName(">="), hasOverloadedOperatorName("<="),
+              hasOverloadedOperatorName("!="), hasOverloadedOperatorName("=="),
           anyOf(allOf(hasArgument(0, StringExpr),
                       hasArgument(1, StringCStrCallExpr)),
                 allOf(hasArgument(0, StringCStrCallExpr),
                       hasArgument(1, StringExpr)))),
       this);
 
   // Detect: 'dst += str.c_str()'  ->  'dst += str'
   // Detect: 's = str.c_str()'  ->  's = str'
-  Finder->addMatcher(
-      cxxOperatorCallExpr(
-          anyOf(hasOverloadedOperatorName("="),
+  Finder->addMatcher(cxxOperatorCallExpr(anyOf(hasOverloadedOperatorName("="),
                                                hasOverloadedOperatorName("+=")),
                                          hasArgument(0, StringExpr),
                                          hasArgument(1, StringCStrCallExpr)),
                      this);
 
   // Detect: 'dst.append(str.c_str())'  ->  'dst.append(str)'
   Finder->addMatcher(
-      cxxMemberCallExpr(on(StringExpr),
-          callee(decl(cxxMethodDecl(
-              hasAnyName("append", "assign", "compare")))),
-          argumentCountIs(1),
-          hasArgument(0, StringCStrCallExpr)),
+      cxxMemberCallExpr(on(StringExpr), callee(decl(cxxMethodDecl(hasAnyName(
+                                            "append", "assign", "compare")))),
+                        argumentCountIs(1), hasArgument(0, StringCStrCallExpr)),
       this);
 
   // Detect: 'dst.compare(p, n, str.c_str())'  ->  'dst.compare(p, n, str)'
   Finder->addMatcher(
       cxxMemberCallExpr(on(StringExpr),
                         callee(decl(cxxMethodDecl(hasName("compare")))),
-          argumentCountIs(3),
-          hasArgument(2, StringCStrCallExpr)),
+                        argumentCountIs(3), hasArgument(2, StringCStrCallExpr)),
       this);
 
   // Detect: 'dst.find(str.c_str())'  ->  'dst.find(str)'
   Finder->addMatcher(
       cxxMemberCallExpr(on(StringExpr),
-          callee(decl(cxxMethodDecl(
-              hasAnyName("find", "find_first_not_of", "find_first_of",
+                        callee(decl(cxxMethodDecl(hasAnyName(
+                            "find", "find_first_not_of", "find_first_of",
                             "find_last_not_of", "find_last_of", "rfind")))),
                         anyOf(argumentCountIs(1), argumentCountIs(2)),
                         hasArgument(0, StringCStrCallExpr)),
       this);
 
   // Detect: 'dst.insert(pos, str.c_str())'  ->  'dst.insert(pos, str)'
   Finder->addMatcher(
       cxxMemberCallExpr(on(StringExpr),
                         callee(decl(cxxMethodDecl(hasName("insert")))),
-          argumentCountIs(2),
-          hasArgument(1, StringCStrCallExpr)),
+                        argumentCountIs(2), hasArgument(1, StringCStrCallExpr)),
       this);
 
   // Detect redundant 'c_str()' calls through a StringRef constructor.
   Finder->addMatcher(
       cxxConstructExpr(
           // Implicit constructors of these classes are overloaded
           // wrt. string types and they internally make a StringRef
           // referring to the argument.  Passing a string directly to
           // them is preferred to passing a char pointer.
-          hasDeclaration(
-              cxxMethodDecl(hasAnyName("::llvm::StringRef::StringRef",
-                                       "::llvm::Twine::Twine"))),
+          hasDeclaration(cxxMethodDecl(hasAnyName(
+              "::llvm::StringRef::StringRef", "::llvm::Twine::Twine"))),
           argumentCountIs(1),
           // The only argument must have the form x.c_str() or p->c_str()
           // where the method is string::c_str().  StringRef also has
           // a constructor from string which is more efficient (avoids
           // strlen), so we can construct StringRef from the string
           // directly.
           hasArgument(0, StringCStrCallExpr)),
       this);

clang-tools-extra/trunk/clang-tidy/readability/RedundantStringInitCheck.cpp

const auto StringConstructorExpr = expr(anyOf(
                        hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
       // If present, the second argument is the alloc object which must not
       // be present explicitly.
       cxxConstructExpr(argumentCountIs(2),
                        hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
                        hasArgument(1, cxxDefaultArgExpr()))));
 
   // Match a string constructor expression with an empty string literal.
-  const auto EmptyStringCtorExpr =
-      cxxConstructExpr(StringConstructorExpr,
-          hasArgument(0, ignoringParenImpCasts(
-                             stringLiteral(hasSize(0)))));
+  const auto EmptyStringCtorExpr = cxxConstructExpr(
+      StringConstructorExpr,
+      hasArgument(0, ignoringParenImpCasts(stringLiteral(hasSize(0)))));
 
   const auto EmptyStringCtorExprWithTemporaries =
       cxxConstructExpr(StringConstructorExpr,
                        hasArgument(0, ignoringImplicit(EmptyStringCtorExpr)));
 
   // Match a variable declaration with an empty string literal as initializer.
   // Examples:
   //     string foo = "";

clang-tools-extra/trunk/clang-tidy/readability/StaticDefinitionInAnonymousNamespaceCheck.h

 namespace readability {
 
 /// Finds static function and variable definitions in anonymous namespace.
 ///
 /// For the user-facing documentation see:
 /// http://clang.llvm.org/extra/clang-tidy/checks/readability-static-definition-in-anonymous-namespace.html
 class StaticDefinitionInAnonymousNamespaceCheck : public ClangTidyCheck {
 public:
-  StaticDefinitionInAnonymousNamespaceCheck(StringRef Name, ClangTidyContext *Context)
+  StaticDefinitionInAnonymousNamespaceCheck(StringRef Name,
+                                            ClangTidyContext *Context)
       : ClangTidyCheck(Name, Context) {}
   void registerMatchers(ast_matchers::MatchFinder *Finder) override;
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STATIC_DEFINITION_IN_ANONYMOUS_NAMESPACE_H

clang-tools-extra/trunk/clang-tidy/readability/UniqueptrDeleteReleaseCheck.h

public:
   void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UNIQUEPTR_DELETE_RELEASE_H
-

clang-tools-extra/trunk/clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp

diag(DeleteExpr->getLocStart(),
       << FixItHint::CreateReplacement(
              CharSourceRange::getTokenRange(AfterPtr, DeleteExpr->getLocEnd()),
              " = nullptr");
 }
 
 } // namespace readability
 } // namespace tidy
 } // namespace clang
-

clang-tools-extra/trunk/clang-tidy/tool/ClangTidyMain.cpp

 )"),
                                          cl::init(""),
                                          cl::cat(ClangTidyCategory));
 
 static cl::opt<bool>
     SystemHeaders("system-headers",
                   cl::desc("Display the errors from system headers."),
                   cl::init(false), cl::cat(ClangTidyCategory));
-static cl::opt<std::string>
-    LineFilter("line-filter",
-               cl::desc(R"(
+static cl::opt<std::string> LineFilter("line-filter", cl::desc(R"(
 List of files with line ranges to filter the
 warnings. Can be used together with
 -header-filter. The format of the list is a
 JSON array of objects:
   [
     {"name":"file1.cpp","lines":[[1,3],[5,7]]},
     {"name":"file2.h"}
   ]
 )"),
-               cl::init(""), cl::cat(ClangTidyCategory));
+                                       cl::init(""),
+                                       cl::cat(ClangTidyCategory));
 
 static cl::opt<bool> Fix("fix", cl::desc(R"(
 Apply suggested fixes. Without -fix-errors
 clang-tidy will bail out if any compilation
 errors were found.
 )"),
                          cl::init(false), cl::cat(ClangTidyCategory));
 

 }
 
 static void printProfileData(const ProfileData &Profile,
                              llvm::raw_ostream &OS) {
   // Time is first to allow for sorting by it.
   std::vector<std::pair<llvm::TimeRecord, StringRef>> Timers;
   TimeRecord Total;
 
-  for (const auto& P : Profile.Records) {
+  for (const auto &P : Profile.Records) {
     Timers.emplace_back(P.getValue(), P.getKey());
     Total += P.getValue();
   }
 
   std::sort(Timers.begin(), Timers.end());
 
   std::string Line = "===" + std::string(73, '-') + "===\n";
   OS << Line;
static int clangTidyMain(int argc, const char **argv) {
   if (std::error_code EC = llvm::sys::fs::make_absolute(FilePath)) {
     llvm::errs() << "Can't make absolute path from " << FileName << ": "
                  << EC.message() << "\n";
   }
   ClangTidyOptions EffectiveOptions = OptionsProvider->getOptions(FilePath);
   std::vector<std::string> EnabledChecks = getCheckNames(EffectiveOptions);
 
   if (ExplainConfig) {
-    //FIXME: Show other ClangTidyOptions' fields, like ExtraArg.
+    // FIXME: Show other ClangTidyOptions' fields, like ExtraArg.
     std::vector<clang::tidy::ClangTidyOptionsProvider::OptionsSource>
         RawOptions = OptionsProvider->getRawOptions(FilePath);
     for (const std::string &Check : EnabledChecks) {
       for (auto It = RawOptions.rbegin(); It != RawOptions.rend(); ++It) {
         if (It->first.Checks && GlobList(*It->first.Checks).contains(Check)) {
           llvm::outs() << "'" << Check << "' is enabled in the " << It->second
                        << ".\n";
           break;
if (PathList.empty()) {
     return 1;
   }
 
   ProfileData Profile;
 
   std::vector<ClangTidyError> Errors;
   ClangTidyStats Stats =
       runClangTidy(std::move(OptionsProvider), OptionsParser.getCompilations(),
-                   PathList, &Errors,
-                   EnableCheckProfile ? &Profile : nullptr);
+                   PathList, &Errors, EnableCheckProfile ? &Profile : nullptr);
   bool FoundErrors =
       std::find_if(Errors.begin(), Errors.end(), [](const ClangTidyError &E) {
         return E.DiagLevel == ClangTidyError::Error;
       }) != Errors.end();
 
   const bool DisableFixes = Fix && FoundErrors && !FixErrors;
 
   unsigned WErrorCount = 0;

 // This anchor is used to force the linker to link the ModernizeModule.
 extern volatile int ModernizeModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED ModernizeModuleAnchorDestination =
     ModernizeModuleAnchorSource;
 
 // This anchor is used to force the linker to link the MPIModule.
 extern volatile int MPIModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED MPIModuleAnchorDestination =
-          MPIModuleAnchorSource;
 
 // This anchor is used to force the linker to link the PerformanceModule.
 extern volatile int PerformanceModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED PerformanceModuleAnchorDestination =
     PerformanceModuleAnchorSource;
 
 // This anchor is used to force the linker to link the ReadabilityModule.
 extern volatile int ReadabilityModuleAnchorSource;

clang-tools-extra/trunk/clang-tidy/utils/IncludeInserter.cpp

 
 class IncludeInserterCallback : public PPCallbacks {
 public:
   explicit IncludeInserterCallback(IncludeInserter *Inserter)
       : Inserter(Inserter) {}
   // Implements PPCallbacks::InclusionDerective(). Records the names and source
   // locations of the inclusions in the main source file being processed.
   void InclusionDirective(SourceLocation HashLocation,
-                          const Token & IncludeToken,
-                          StringRef FileNameRef, bool IsAngled,
-                          CharSourceRange FileNameRange,
+                          const Token &IncludeToken, StringRef FileNameRef,
+                          bool IsAngled, CharSourceRange FileNameRange,
                           const FileEntry * /*IncludedFile*/,
                           StringRef /*SearchPath*/, StringRef /*RelativePath*/,
                           const Module * /*ImportedModule*/) override {
     Inserter->AddInclude(FileNameRef, IsAngled, HashLocation,
                          IncludeToken.getEndLoc());
   }
 
 private:

clang-tools-extra/trunk/clang-tidy/utils/Matchers.h

 //===--- Matchers.h - clang-tidy-------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_MATCHERS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_MATCHERS_H
 
-#include "clang/ASTMatchers/ASTMatchers.h"
 #include "TypeTraits.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
 
 namespace clang {
 namespace tidy {
 namespace matchers {
 
 AST_MATCHER(BinaryOperator, isRelationalOperator) {
   return Node.isRelationalOp();
 }
 
-AST_MATCHER(BinaryOperator, isEqualityOperator) {
-  return Node.isEqualityOp();
-}
+AST_MATCHER(BinaryOperator, isEqualityOperator) { return Node.isEqualityOp(); }
 
 AST_MATCHER(BinaryOperator, isComparisonOperator) {
   return Node.isComparisonOp();
 }
 
 AST_MATCHER(QualType, isExpensiveToCopy) {
   llvm::Optional<bool> IsExpensive =
       utils::type_traits::isExpensiveToCopy(Node, Finder->getASTContext());

clang-tools-extra/trunk/clang-tidy/utils/NamespaceAliaser.cpp

 Optional<FixItHint>
 NamespaceAliaser::createAlias(ASTContext &Context, const Stmt &Statement,
                               StringRef Namespace,
                               const std::vector<std::string> &Abbreviations) {
   const FunctionDecl *Function = getSurroundingFunction(Context, Statement);
   if (!Function || !Function->hasBody())
     return None;
 
-
   if (AddedAliases[Function].count(Namespace.str()) != 0)
     return None;
 
-
   // FIXME: Doesn't consider the order of declarations.
   // If we accidentially pick an alias defined later in the function,
   // the output won't compile.
   // FIXME: Also doesn't consider file or class-scope aliases.
 
   const auto *ExistingAlias = selectFirst<NamedDecl>(
       "alias",
       match(functionDecl(hasBody(compoundStmt(has(declStmt(

clang-tools-extra/trunk/clang-tidy/utils/TypeTraits.cpp

if (ClassDecl->hasUserProvidedDefaultConstructor())
     return false;
   // A polymorphic class is not trivially constructible
   if (ClassDecl->isPolymorphic())
     return false;
   // A class is trivially constructible if it has a trivial default constructor.
   if (ClassDecl->hasTrivialDefaultConstructor())
     return true;
 
-  // If all its fields are trivially constructible and have no default initializers.
+  // If all its fields are trivially constructible and have no default
+  // initializers.
   for (const FieldDecl *Field : ClassDecl->fields()) {
     if (Field->hasInClassInitializer())
       return false;
     if (!isTriviallyDefaultConstructible(Field->getType(), Context))
       return false;
   }
   // If all its direct bases are trivially constructible.
   for (const CXXBaseSpecifier &Base : ClassDecl->bases()) {
     if (!isTriviallyDefaultConstructible(Base.getType(), Context))
       return false;
     if (Base.isVirtual())
       return false;
   }
 
   return true;
 }
 
 // Based on QualType::isTrivial.
-bool isTriviallyDefaultConstructible(QualType Type,
-                                     const ASTContext &Context) {
+bool isTriviallyDefaultConstructible(QualType Type, const ASTContext &Context) {
   if (Type.isNull())
     return false;
 
   if (Type->isArrayType())
     return isTriviallyDefaultConstructible(Context.getBaseElementType(Type),
                                            Context);
 
   // Return false for incomplete types after skipping any incomplete array

clang-tools-extra/trunk/clang-tidy/utils/UsingInserter.cpp

Optional<FixItHint> UsingInserter::createUsingDeclaration(
   bool HasConflictingDeclaration =
       !match(findAll(ConflictingDecl), *Function, Context).empty();
   bool HasConflictingDeclRef =
       !match(findAll(declRefExpr(to(ConflictingDecl))), *Function, Context)
            .empty();
   if (HasConflictingDeclaration || HasConflictingDeclRef)
     return None;
 
-  std::string Declaration = (llvm::Twine("\nusing ") + QualifiedName + ";").str();
+  std::string Declaration =
+      (llvm::Twine("\nusing ") + QualifiedName + ";").str();
 
   AddedUsing.emplace(std::make_pair(Function, QualifiedName.str()));
   return FixItHint::CreateInsertion(InsertLoc, Declaration);
 }
 
 StringRef UsingInserter::getShortName(ASTContext &Context,
                                       const Stmt &Statement,
                                       StringRef QualifiedName) {

clang-tools-extra/trunk/tool-template/ToolTemplate.cpp

 //  For example, to use tool-template on all files in a subtree of the
 //  source tree, use:
 //
 //    /path/in/subtree $ find . -name '*.cpp'|
 //        xargs tool-template /path/to/build
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/MemoryBuffer.h"