Index: change-namespace/ChangeNamespace.cpp =================================================================== --- change-namespace/ChangeNamespace.cpp +++ change-namespace/ChangeNamespace.cpp @@ -345,7 +345,8 @@ } else if (const auto *TLoc = Result.Nodes.getNodeAs("type")) { fixTypeLoc(Result, startLocationForType(*TLoc), EndLocationForType(*TLoc), *TLoc); - } else if (const auto *VarRef = Result.Nodes.getNodeAs("var_ref")){ + } else if (const auto *VarRef = + Result.Nodes.getNodeAs("var_ref")) { const auto *Var = Result.Nodes.getNodeAs("var_decl"); assert(Var); if (Var->getCanonicalDecl()->isStaticDataMember()) @@ -358,8 +359,8 @@ VarRefRange.getEnd(), Name); } else { const auto *Call = Result.Nodes.getNodeAs("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. @@ -548,7 +549,8 @@ 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. Index: clang-apply-replacements/include/clang-apply-replacements/Tooling/ApplyReplacements.h =================================================================== --- clang-apply-replacements/include/clang-apply-replacements/Tooling/ApplyReplacements.h +++ clang-apply-replacements/include/clang-apply-replacements/Tooling/ApplyReplacements.h @@ -38,8 +38,7 @@ typedef std::vector RangeVector; /// \brief Collection of TranslationUnitReplacements. -typedef std::vector -TUReplacements; +typedef std::vector TUReplacements; /// \brief Collection of TranslationUnitReplacement files. typedef std::vector TUReplacementFiles; @@ -66,11 +65,9 @@ /// /// \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. @@ -115,7 +112,7 @@ /// \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( Index: clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp =================================================================== --- clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp +++ clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp @@ -30,17 +30,14 @@ 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; @@ -128,7 +125,7 @@ Rewriter &Rewrite) { bool Result = true; for (std::vector::const_iterator I = Replaces.begin(), - E = Replaces.end(); + E = Replaces.end(); I != E; ++I) { if (I->isApplicable()) { Result = I->apply(Rewrite) && Result; @@ -139,11 +136,10 @@ return Result; } - // FIXME: moved from libToolingCore. remove this when std::vector // is replaced with tooling::Replacements class. static void deduplicate(std::vector &Replaces, - std::vector &Conflicts) { + std::vector &Conflicts) { if (Replaces.empty()) return; Index: clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp =================================================================== --- clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp +++ clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp @@ -43,7 +43,6 @@ "merging/replacing."), cl::init(false), cl::cat(ReplacementCategory)); - static cl::opt DoFormat( "format", cl::desc("Enable formatting of code changed by applying replacements.\n" @@ -63,8 +62,8 @@ cl::init(""), cl::cat(FormattingCategory)); static cl::opt -FormatStyleOpt("style", cl::desc(format::StyleOptionHelpDescription), - cl::init("LLVM"), cl::cat(FormattingCategory)); + FormatStyleOpt("style", cl::desc(format::StyleOptionHelpDescription), + cl::init("LLVM"), cl::cat(FormattingCategory)); namespace { // Helper object to remove the TUReplacement files (triggered by @@ -75,9 +74,7 @@ clang::DiagnosticsEngine &Diagnostics) : TURFiles(Files), Diag(Diagnostics) {} - ~ScopedFileRemover() { - deleteReplacementFiles(TURFiles, Diag); - } + ~ScopedFileRemover() { deleteReplacementFiles(TURFiles, Diag); } private: const TUReplacementFiles &TURFiles; @@ -106,7 +103,8 @@ static bool getRewrittenData(const std::vector &Replacements, Rewriter &Rewrites, std::string &Result) { - if (Replacements.empty()) return true; + if (Replacements.empty()) + return true; if (!applyAllReplacements(Replacements, Rewrites)) return false; @@ -206,8 +204,7 @@ IntrusiveRefCntPtr DiagOpts(new DiagnosticOptions()); DiagnosticsEngine Diagnostics( - IntrusiveRefCntPtr(new DiagnosticIDs()), - DiagOpts.get()); + IntrusiveRefCntPtr(new DiagnosticIDs()), DiagOpts.get()); // Determine a formatting style from options. format::FormatStyle FormatStyle; Index: clang-move/ClangMove.h =================================================================== --- clang-move/ClangMove.h +++ clang-move/ClangMove.h @@ -69,11 +69,9 @@ /// 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(); Index: clang-move/ClangMove.cpp =================================================================== --- clang-move/ClangMove.cpp +++ clang-move/ClangMove.cpp @@ -25,14 +25,13 @@ 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, 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(NextContext) || isa(NextContext)) @@ -46,7 +45,8 @@ AST_MATCHER_P(CXXMethodDecl, ofOutermostEnclosingClass, ast_matchers::internal::Matcher, InnerMatcher) { const CXXRecordDecl *Parent = Node.getParent(); - if (!Parent) return false; + if (!Parent) + return false; while (const auto *NextParent = dyn_cast(Parent->getParent())) { Parent = NextParent; @@ -64,7 +64,7 @@ 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); @@ -76,16 +76,17 @@ // // 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())); + llvm::sys::path::parent_path(AbsolutePath.str())); if (Dir) { StringRef DirName = SM.getFileManager().getCanonicalName(Dir); SmallVector AbsoluteFilename; @@ -156,7 +157,7 @@ // 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'. @@ -172,14 +173,12 @@ 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()); } @@ -228,8 +227,7 @@ clang::tooling::Replacements createInsertedReplacements(const std::vector &Includes, const std::vector &Decls, - llvm::StringRef FileName, - bool IsHeader = false) { + llvm::StringRef FileName, bool IsHeader = false) { std::string NewCode; std::string GuardName(FileName); if (IsHeader) { @@ -325,8 +323,8 @@ 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)); @@ -346,10 +344,10 @@ 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()) + .bind("class_static_var_decl"), + this); auto InOldCCNamedNamespace = allOf(hasParent(namespaceDecl(unless(isAnonymous()))), InOldCC); @@ -357,10 +355,9 @@ // in classes, functions and anonymous namespaces are covered in other // matchers. Finder->addMatcher( - namedDecl( - anyOf(usingDecl(InOldCCNamedNamespace), - usingDirectiveDecl(InOldCC, InOldCCNamedNamespace), - typeAliasDecl(InOldCC, InOldCCNamedNamespace))) + namedDecl(anyOf(usingDecl(InOldCCNamedNamespace), + usingDirectiveDecl(InOldCC, InOldCCNamedNamespace), + typeAliasDecl(InOldCC, InOldCCNamedNamespace))) .bind("using_decl"), this); @@ -373,11 +370,10 @@ auto IsOldCCStaticDefinition = allOf(isDefinition(), unless(InMovedClass), InOldCCNamedNamespace, isStaticStorageClass()); - Finder->addMatcher( - namedDecl(anyOf(functionDecl(IsOldCCStaticDefinition), - varDecl(IsOldCCStaticDefinition))) - .bind("static_decls"), - this); + Finder->addMatcher(namedDecl(anyOf(functionDecl(IsOldCCStaticDefinition), + varDecl(IsOldCCStaticDefinition))) + .bind("static_decls"), + this); // Match forward declarations in old header. Finder->addMatcher( @@ -413,8 +409,8 @@ MovedDecls.emplace_back(FWD, &Result.Context->getSourceManager()); } } - } else if (const auto *ANS = Result.Nodes.getNodeAs( - "anonymous_ns")) { + } else if (const auto *ANS = + Result.Nodes.getNodeAs("anonymous_ns")) { MovedDecls.emplace_back(ANS, &Result.Context->getSourceManager()); } else if (const auto *ND = Result.Nodes.getNodeAs("static_decls")) { @@ -425,11 +421,10 @@ } } -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 HeaderWithSearchPath; llvm::sys::path::append(HeaderWithSearchPath, SearchPath, IncludeHeader); std::string AbsoluteOldHeader = @@ -460,8 +455,8 @@ 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); Index: clang-move/tool/ClangMoveMain.cpp =================================================================== --- clang-move/tool/ClangMoveMain.cpp +++ clang-move/tool/ClangMoveMain.cpp @@ -77,8 +77,8 @@ // 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 ExtraArgs( argv, argv + argc ); - ExtraArgs.insert(ExtraArgs.begin()+1, "-extra-arg=-fparse-all-comments"); + std::vector ExtraArgs(argv, argv + argc); + ExtraArgs.insert(ExtraArgs.begin() + 1, "-extra-arg=-fparse-all-comments"); std::unique_ptr RawExtraArgs( new const char *[ExtraArgs.size()]); for (size_t i = 0; i < ExtraArgs.size(); ++i) @@ -90,7 +90,7 @@ 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; Index: clang-query/Query.h =================================================================== --- clang-query/Query.h +++ clang-query/Query.h @@ -18,11 +18,7 @@ namespace clang { namespace query { -enum OutputKind { - OK_Diag, - OK_Print, - OK_Dump -}; +enum OutputKind { OK_Diag, OK_Print, OK_Dump }; enum QueryKind { QK_Invalid, Index: clang-query/Query.cpp =================================================================== --- clang-query/Query.cpp +++ clang-query/Query.cpp @@ -65,7 +65,7 @@ } }; -} // namespace +} // namespace bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const { unsigned MatchCount = 0; @@ -100,11 +100,10 @@ if (R.isValid()) { TextDiagnostic TD(OS, AST->getASTContext().getLangOpts(), &AST->getDiagnostics().getDiagnosticOptions()); - TD.emitDiagnostic( - R.getBegin(), DiagnosticsEngine::Note, - "\"" + BI->first + "\" binds here", - CharSourceRange::getTokenRange(R), - None, &AST->getSourceManager()); + TD.emitDiagnostic(R.getBegin(), DiagnosticsEngine::Note, + "\"" + BI->first + "\" binds here", + CharSourceRange::getTokenRange(R), None, + &AST->getSourceManager()); } break; } Index: clang-query/QueryParser.h =================================================================== --- clang-query/QueryParser.h +++ clang-query/QueryParser.h @@ -37,8 +37,7 @@ 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(); Index: clang-query/QueryParser.cpp =================================================================== --- clang-query/QueryParser.cpp +++ clang-query/QueryParser.cpp @@ -76,9 +76,7 @@ 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 object @@ -101,9 +99,9 @@ QueryRef QueryParser::parseSetBool(bool QuerySession::*Var) { StringRef ValStr; unsigned Value = lexOrCompleteWord(ValStr) - .Case("false", 0) - .Case("true", 1) - .Default(~0u); + .Case("false", 0) + .Case("true", 1) + .Default(~0u); if (Value == ~0u) { return new InvalidQuery("expected 'true' or 'false', got '" + ValStr + "'"); } @@ -145,11 +143,7 @@ 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; @@ -158,7 +152,7 @@ return new InvalidQuery(OS.str()); } -} // namespace +} // namespace QueryRef QueryParser::completeMatcherExpression() { std::vector Comps = Parser::completeExpression( Index: clang-reorder-fields/ReorderFieldsAction.cpp =================================================================== --- clang-reorder-fields/ReorderFieldsAction.cpp +++ clang-reorder-fields/ReorderFieldsAction.cpp @@ -1,4 +1,5 @@ -//===-- tools/extra/clang-reorder-fields/ReorderFieldsAction.cpp -*- C++ -*-===// +//===-- tools/extra/clang-reorder-fields/ReorderFieldsAction.cpp -*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // @@ -129,8 +130,10 @@ /// \brief Reorders initializers in a C++ struct/class constructor. /// -/// A constructor can have initializers for an arbitrary subset of the class's fields. -/// Thus, we need to ensure that we reorder just the initializers that are present. +/// A constructor can have initializers for an arbitrary subset of the class's +/// fields. +/// Thus, we need to ensure that we reorder just the initializers that are +/// present. static void reorderFieldsInConstructor( const CXXConstructorDecl *CtorDecl, ArrayRef NewFieldsOrder, const ASTContext &Context, @@ -182,11 +185,12 @@ const ASTContext &Context, std::map &Replacements) { assert(InitListEx && "Init list expression is null"); - // We care only about InitListExprs which originate from source code. + // We care only about InitListExprs which originate from source code. // Implicit InitListExprs are created by the semantic analyzer. if (!InitListEx->isExplicit()) return true; - // The method InitListExpr::getSyntacticForm may return nullptr indicating that + // The method InitListExpr::getSyntacticForm may return nullptr indicating + // that // the current initializer list also serves as its syntactic form. if (const auto *SyntacticForm = InitListEx->getSyntacticForm()) InitListEx = SyntacticForm; @@ -199,10 +203,9 @@ } for (unsigned i = 0, e = InitListEx->getNumInits(); i < e; ++i) if (i != NewFieldsOrder[i]) - addReplacement( - InitListEx->getInit(i)->getSourceRange(), - InitListEx->getInit(NewFieldsOrder[i])->getSourceRange(), Context, - Replacements); + addReplacement(InitListEx->getInit(i)->getSourceRange(), + InitListEx->getInit(NewFieldsOrder[i])->getSourceRange(), + Context, Replacements); return true; } Index: clang-reorder-fields/tool/ClangReorderFields.cpp =================================================================== --- clang-reorder-fields/tool/ClangReorderFields.cpp +++ clang-reorder-fields/tool/ClangReorderFields.cpp @@ -1,4 +1,5 @@ -//===-- tools/extra/clang-reorder-fields/tool/ClangReorderFields.cpp -*- C++ -*-===// +//===-- tools/extra/clang-reorder-fields/tool/ClangReorderFields.cpp -*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // Index: clang-tidy/ClangTidyDiagnosticConsumer.cpp =================================================================== --- clang-tidy/ClangTidyDiagnosticConsumer.cpp +++ clang-tidy/ClangTidyDiagnosticConsumer.cpp @@ -83,7 +83,7 @@ // applied). if (Err) { llvm::errs() << "Fix conflicts with existing fix! " - << llvm::toString(std::move(Err)) << "\n"; + << llvm::toString(std::move(Err)) << "\n"; assert(false && "Fix conflicts with existing fix!"); } } @@ -124,10 +124,9 @@ 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. @@ -279,7 +278,7 @@ 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) { @@ -312,10 +311,10 @@ 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; Index: clang-tidy/ClangTidyModule.h =================================================================== --- clang-tidy/ClangTidyModule.h +++ clang-tidy/ClangTidyModule.h @@ -26,8 +26,9 @@ /// this object. class ClangTidyCheckFactories { public: - typedef std::function CheckFactory; + typedef std::function + CheckFactory; /// \brief Registers check \p Factory with name \p Name. /// @@ -58,8 +59,8 @@ template void registerCheck(StringRef CheckName) { registerCheckFactory(CheckName, [](StringRef Name, ClangTidyContext *Context) { - return new CheckType(Name, Context); - }); + return new CheckType(Name, Context); + }); } /// \brief Create instances of all checks matching \p CheckRegexString and Index: clang-tidy/ClangTidyOptions.h =================================================================== --- clang-tidy/ClangTidyOptions.h +++ clang-tidy/ClangTidyOptions.h @@ -173,7 +173,8 @@ // \brief A pair of configuration file base name and a function parsing // configuration from text in the corresponding format. typedef std::pair( - llvm::StringRef)>> ConfigFileHandler; + llvm::StringRef)>> + ConfigFileHandler; /// \brief Configuration file handlers listed in the order of priority. /// Index: clang-tidy/ClangTidyOptions.cpp =================================================================== --- clang-tidy/ClangTidyOptions.cpp +++ clang-tidy/ClangTidyOptions.cpp @@ -215,8 +215,7 @@ 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 Index: clang-tidy/cert/CERTTidyModule.cpp =================================================================== --- clang-tidy/cert/CERTTidyModule.cpp +++ clang-tidy/cert/CERTTidyModule.cpp @@ -34,8 +34,7 @@ void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { // C++ checkers // DCL - CheckFactories.registerCheck( - "cert-dcl50-cpp"); + CheckFactories.registerCheck("cert-dcl50-cpp"); CheckFactories.registerCheck( "cert-dcl54-cpp"); CheckFactories.registerCheck( @@ -46,37 +45,27 @@ // ERR CheckFactories.registerCheck( "cert-err09-cpp"); - CheckFactories.registerCheck( - "cert-err52-cpp"); - CheckFactories.registerCheck( - "cert-err58-cpp"); - CheckFactories.registerCheck( - "cert-err60-cpp"); + CheckFactories.registerCheck("cert-err52-cpp"); + CheckFactories.registerCheck("cert-err58-cpp"); + CheckFactories.registerCheck("cert-err60-cpp"); CheckFactories.registerCheck( "cert-err61-cpp"); // MSC - CheckFactories.registerCheck( - "cert-msc50-cpp"); + CheckFactories.registerCheck("cert-msc50-cpp"); // C checkers // DCL - CheckFactories.registerCheck( - "cert-dcl03-c"); + CheckFactories.registerCheck("cert-dcl03-c"); // ENV - CheckFactories.registerCheck( - "cert-env33-c"); + CheckFactories.registerCheck("cert-env33-c"); // FLP - CheckFactories.registerCheck( - "cert-flp30-c"); + CheckFactories.registerCheck("cert-flp30-c"); // FIO - CheckFactories.registerCheck( - "cert-fio38-c"); + CheckFactories.registerCheck("cert-fio38-c"); // ERR - CheckFactories.registerCheck( - "cert-err34-c"); + CheckFactories.registerCheck("cert-err34-c"); // MSC - CheckFactories.registerCheck( - "cert-msc30-c"); + CheckFactories.registerCheck("cert-msc30-c"); } ClangTidyOptions getModuleOptions() override { ClangTidyOptions Options; @@ -89,8 +78,8 @@ // Register the MiscTidyModule using this statically initialized variable. static ClangTidyModuleRegistry::Add -X("cert-module", - "Adds lint checks corresponding to CERT secure coding guidelines."); + 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. Index: clang-tidy/cert/LimitedRandomnessCheck.cpp =================================================================== --- clang-tidy/cert/LimitedRandomnessCheck.cpp +++ clang-tidy/cert/LimitedRandomnessCheck.cpp @@ -30,11 +30,9 @@ msg = "; use C++11 random library instead"; const auto *MatchedDecl = Result.Nodes.getNodeAs("randomGenerator"); - diag(MatchedDecl->getLocStart(), - "rand() has limited randomness" + msg); + diag(MatchedDecl->getLocStart(), "rand() has limited randomness" + msg); } } // namespace cert } // namespace tidy } // namespace clang - Index: clang-tidy/cert/StaticObjectExceptionCheck.cpp =================================================================== --- clang-tidy/cert/StaticObjectExceptionCheck.cpp +++ clang-tidy/cert/StaticObjectExceptionCheck.cpp @@ -47,7 +47,7 @@ << 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) Index: clang-tidy/cert/StrToNumCheck.cpp =================================================================== --- clang-tidy/cert/StrToNumCheck.cpp +++ clang-tidy/cert/StrToNumCheck.cpp @@ -8,9 +8,9 @@ //===----------------------------------------------------------------------===// #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 Index: clang-tidy/cert/ThrownExceptionTypeCheck.h =================================================================== --- clang-tidy/cert/ThrownExceptionTypeCheck.h +++ clang-tidy/cert/ThrownExceptionTypeCheck.h @@ -23,7 +23,7 @@ class ThrownExceptionTypeCheck : public ClangTidyCheck { public: ThrownExceptionTypeCheck(StringRef Name, ClangTidyContext *Context) - : ClangTidyCheck(Name, Context) {} + : ClangTidyCheck(Name, Context) {} void registerMatchers(ast_matchers::MatchFinder *Finder) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override; }; Index: clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp =================================================================== --- clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp +++ clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp @@ -22,8 +22,8 @@ #include "ProTypeStaticCastDowncastCheck.h" #include "ProTypeUnionAccessCheck.h" #include "ProTypeVarargCheck.h" -#include "SpecialMemberFunctionsCheck.h" #include "SlicingCheck.h" +#include "SpecialMemberFunctionsCheck.h" namespace clang { namespace tidy { @@ -57,8 +57,7 @@ "cppcoreguidelines-pro-type-vararg"); CheckFactories.registerCheck( "cppcoreguidelines-special-member-functions"); - CheckFactories.registerCheck( - "cppcoreguidelines-slicing"); + CheckFactories.registerCheck("cppcoreguidelines-slicing"); CheckFactories.registerCheck( "cppcoreguidelines-c-copy-assignment-signature"); } Index: clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp =================================================================== --- clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp +++ clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp @@ -47,12 +47,12 @@ // 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()))) + .bind("expr"), + this); Finder->addMatcher( cxxOperatorCallExpr( @@ -112,8 +112,7 @@ 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; } @@ -130,8 +129,9 @@ // 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 " + "(which contains %1 elements)") << Index.toString(10) << ArraySize.toString(10, false); } } Index: clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.h =================================================================== --- clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.h +++ clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.h @@ -17,7 +17,8 @@ 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 Index: clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp =================================================================== --- clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp +++ clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp @@ -47,8 +47,8 @@ this); } -void -ProBoundsPointerArithmeticCheck::check(const MatchFinder::MatchResult &Result) { +void ProBoundsPointerArithmeticCheck::check( + const MatchFinder::MatchResult &Result) { const auto *MatchedExpr = Result.Nodes.getNodeAs("expr"); diag(MatchedExpr->getExprLoc(), "do not use pointer arithmetic"); Index: clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp =================================================================== --- clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp +++ clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp @@ -278,8 +278,7 @@ // AST. Finder->addMatcher( cxxRecordDecl( - isDefinition(), unless(isInstantiated()), - hasDefaultConstructor(), + isDefinition(), unless(isInstantiated()), hasDefaultConstructor(), anyOf(has(cxxConstructorDecl(isDefaultConstructor(), isDefaulted(), unless(isImplicit()))), unless(has(cxxConstructorDecl()))), @@ -465,7 +464,7 @@ << toCommaSeparatedString(AllBases, BasesToInit); if (Ctor) - fixInitializerList(Context, Diag, Ctor, BasesToInit); + fixInitializerList(Context, Diag, Ctor, BasesToInit); } void ProTypeMemberInitCheck::checkUninitializedTrivialType( Index: clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.h =================================================================== --- clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.h +++ clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.h @@ -16,7 +16,8 @@ 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 Index: clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.cpp =================================================================== --- clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.cpp +++ clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.cpp @@ -26,7 +26,8 @@ this); } -void ProTypeStaticCastDowncastCheck::check(const MatchFinder::MatchResult &Result) { +void ProTypeStaticCastDowncastCheck::check( + const MatchFinder::MatchResult &Result) { const auto *MatchedCast = Result.Nodes.getNodeAs("cast"); if (MatchedCast->getCastKind() != CK_BaseToDerived) return; Index: clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.h =================================================================== --- clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.h +++ clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.h @@ -34,4 +34,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_UNION_ACCESS_H - Index: clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.cpp =================================================================== --- clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.cpp +++ clang-tidy/cppcoreguidelines/ProTypeUnionAccessCheck.cpp @@ -21,15 +21,18 @@ 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("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 - Index: clang-tidy/cppcoreguidelines/ProTypeVarargCheck.cpp =================================================================== --- clang-tidy/cppcoreguidelines/ProTypeVarargCheck.cpp +++ clang-tidy/cppcoreguidelines/ProTypeVarargCheck.cpp @@ -26,9 +26,7 @@ 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) { Index: clang-tidy/cppcoreguidelines/SlicingCheck.h =================================================================== --- clang-tidy/cppcoreguidelines/SlicingCheck.h +++ clang-tidy/cppcoreguidelines/SlicingCheck.h @@ -18,9 +18,11 @@ /// Flags slicing (incomplete copying of an object's state) of member variables /// or vtable. See: -/// - https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es63-dont-slice +/// - +/// https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es63-dont-slice /// for the former, and -/// - https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c145-access-polymorphic-objects-through-pointers-and-references +/// - +/// https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c145-access-polymorphic-objects-through-pointers-and-references /// for the latter /// /// For the user-facing documentation see: Index: clang-tidy/google/AvoidCStyleCastsCheck.cpp =================================================================== --- clang-tidy/google/AvoidCStyleCastsCheck.cpp +++ clang-tidy/google/AvoidCStyleCastsCheck.cpp @@ -20,8 +20,8 @@ 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 @@ -29,7 +29,8 @@ // 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); } @@ -143,7 +144,7 @@ ReplaceWithCast("const_cast"); return; } - // FALLTHROUGH + // 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 Index: clang-tidy/google/ExplicitMakePairCheck.cpp =================================================================== --- clang-tidy/google/ExplicitMakePairCheck.cpp +++ clang-tidy/google/ExplicitMakePairCheck.cpp @@ -25,8 +25,8 @@ 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) @@ -39,7 +39,8 @@ callee(expr(ignoringParenImpCasts( declRefExpr(hasExplicitTemplateArgs(), to(functionDecl(hasName("::std::make_pair")))) - .bind("declref"))))).bind("call"), + .bind("declref"))))) + .bind("call"), this); } @@ -61,13 +62,13 @@ 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<"); + 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())); + SourceRange(DeclRef->getLAngleLoc(), DeclRef->getRAngleLoc())); } } Index: clang-tidy/google/GlobalNamesInHeadersCheck.cpp =================================================================== --- clang-tidy/google/GlobalNamesInHeadersCheck.cpp +++ clang-tidy/google/GlobalNamesInHeadersCheck.cpp @@ -1,4 +1,5 @@ -//===--- GlobalNamesInHeadersCheck.cpp - clang-tidy -----------------*- C++ -*-===// +//===--- GlobalNamesInHeadersCheck.cpp - clang-tidy -----------------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // @@ -26,8 +27,7 @@ RawStringHeaderFileExtensions( Options.getLocalOrGlobal("HeaderFileExtensions", "h")) { if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions, - HeaderFileExtensions, - ',')) { + HeaderFileExtensions, ',')) { llvm::errs() << "Invalid header file extension: " << RawStringHeaderFileExtensions << "\n"; } @@ -38,12 +38,12 @@ Options.store(Opts, "HeaderFileExtensions", RawStringHeaderFileExtensions); } -void -GlobalNamesInHeadersCheck::registerMatchers(ast_matchers::MatchFinder *Finder) { - Finder->addMatcher( - decl(anyOf(usingDecl(), usingDirectiveDecl()), - hasDeclContext(translationUnitDecl())).bind("using_decl"), - this); +void GlobalNamesInHeadersCheck::registerMatchers( + ast_matchers::MatchFinder *Finder) { + Finder->addMatcher(decl(anyOf(usingDecl(), usingDirectiveDecl()), + hasDeclContext(translationUnitDecl())) + .bind("using_decl"), + this); } void GlobalNamesInHeadersCheck::check(const MatchFinder::MatchResult &Result) { @@ -61,7 +61,7 @@ return; } - if (const auto* UsingDirective = dyn_cast(D)) { + if (const auto *UsingDirective = dyn_cast(D)) { if (UsingDirective->getNominatedNamespace()->isAnonymousNamespace()) { // Anynoumous namespaces inject a using directive into the AST to import // the names into the containing namespace. Index: clang-tidy/google/GoogleTidyModule.cpp =================================================================== --- clang-tidy/google/GoogleTidyModule.cpp +++ clang-tidy/google/GoogleTidyModule.cpp @@ -21,8 +21,8 @@ #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" Index: clang-tidy/google/IntegerTypesCheck.cpp =================================================================== --- clang-tidy/google/IntegerTypesCheck.cpp +++ clang-tidy/google/IntegerTypesCheck.cpp @@ -40,7 +40,6 @@ namespace google { namespace runtime { - IntegerTypesCheck::IntegerTypesCheck(StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), UnsignedTypePrefix(Options.get("UnsignedTypePrefix", "uint")), Index: clang-tidy/google/MemsetZeroLengthCheck.h =================================================================== --- clang-tidy/google/MemsetZeroLengthCheck.h +++ clang-tidy/google/MemsetZeroLengthCheck.h @@ -1,4 +1,5 @@ -//===--- MemsetZeroLengthCheck.h - clang-tidy ---------------------*- C++ -*-===// +//===--- MemsetZeroLengthCheck.h - clang-tidy ---------------------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // Index: clang-tidy/google/MemsetZeroLengthCheck.cpp =================================================================== --- clang-tidy/google/MemsetZeroLengthCheck.cpp +++ clang-tidy/google/MemsetZeroLengthCheck.cpp @@ -1,4 +1,5 @@ -//===--- MemsetZeroLengthCheck.cpp - clang-tidy -------------------*- C++ -*-===// +//===--- MemsetZeroLengthCheck.cpp - clang-tidy -------------------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // @@ -20,15 +21,16 @@ 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"), - this); + Finder->addMatcher(callExpr(callee(functionDecl(hasName("::memset"))), + argumentCountIs(3), + unless(isInTemplateInstantiation())) + .bind("decl"), + this); } /// \brief Get a StringRef representing a SourceRange. Index: clang-tidy/google/NonConstReferences.cpp =================================================================== --- clang-tidy/google/NonConstReferences.cpp +++ clang-tidy/google/NonConstReferences.cpp @@ -27,8 +27,8 @@ utils::options::parseStringList(Options.get("WhiteListTypes", ""))) {} void NonConstReferences::storeOptions(ClangTidyOptions::OptionMap &Opts) { - Options.store(Opts, "WhiteListTypes", - utils::options::serializeStringList(WhiteListTypes)); + Options.store(Opts, "WhiteListTypes", + utils::options::serializeStringList(WhiteListTypes)); } void NonConstReferences::registerMatchers(MatchFinder *Finder) { @@ -86,41 +86,41 @@ if (Function->isOverloadedOperator()) { switch (Function->getOverloadedOperator()) { - case clang::OO_LessLess: - case clang::OO_PlusPlus: - case clang::OO_MinusMinus: - case clang::OO_PlusEqual: - case clang::OO_MinusEqual: - case clang::OO_StarEqual: - case clang::OO_SlashEqual: - case clang::OO_PercentEqual: - case clang::OO_LessLessEqual: - case clang::OO_GreaterGreaterEqual: - case clang::OO_PipeEqual: - case clang::OO_CaretEqual: - case clang::OO_AmpEqual: - // Don't warn on the first parameter of operator<<(Stream&, ...), - // operator++, operator-- and operation+assignment operators. - if (Function->getParamDecl(0) == Parameter) - return; - break; - case clang::OO_GreaterGreater: { - auto isNonConstRef = [](clang::QualType T) { - return T->isReferenceType() && - !T.getNonReferenceType().isConstQualified(); - }; - // Don't warn on parameters of stream extractors: - // Stream& operator>>(Stream&, Value&); - // Both parameters should be non-const references by convention. - if (isNonConstRef(Function->getParamDecl(0)->getType()) && - (Function->getNumParams() < 2 || // E.g. member operator>>. - isNonConstRef(Function->getParamDecl(1)->getType())) && - isNonConstRef(Function->getReturnType())) - return; - break; - } - default: - break; + case clang::OO_LessLess: + case clang::OO_PlusPlus: + case clang::OO_MinusMinus: + case clang::OO_PlusEqual: + case clang::OO_MinusEqual: + case clang::OO_StarEqual: + case clang::OO_SlashEqual: + case clang::OO_PercentEqual: + case clang::OO_LessLessEqual: + case clang::OO_GreaterGreaterEqual: + case clang::OO_PipeEqual: + case clang::OO_CaretEqual: + case clang::OO_AmpEqual: + // Don't warn on the first parameter of operator<<(Stream&, ...), + // operator++, operator-- and operation+assignment operators. + if (Function->getParamDecl(0) == Parameter) + return; + break; + case clang::OO_GreaterGreater: { + auto isNonConstRef = [](clang::QualType T) { + return T->isReferenceType() && + !T.getNonReferenceType().isConstQualified(); + }; + // Don't warn on parameters of stream extractors: + // Stream& operator>>(Stream&, Value&); + // Both parameters should be non-const references by convention. + if (isNonConstRef(Function->getParamDecl(0)->getType()) && + (Function->getNumParams() < 2 || // E.g. member operator>>. + isNonConstRef(Function->getParamDecl(1)->getType())) && + isNonConstRef(Function->getReturnType())) + return; + break; + } + default: + break; } } @@ -133,9 +133,8 @@ return; if (Parameter->getName().empty()) { - diag(Parameter->getLocation(), - "non-const reference parameter at index %0, " - "make it const or use a pointer") + diag(Parameter->getLocation(), "non-const reference parameter at index %0, " + "make it const or use a pointer") << Parameter->getFunctionScopeIndex(); } else { diag(Parameter->getLocation(), Index: clang-tidy/google/OverloadedUnaryAndCheck.cpp =================================================================== --- clang-tidy/google/OverloadedUnaryAndCheck.cpp +++ clang-tidy/google/OverloadedUnaryAndCheck.cpp @@ -19,8 +19,8 @@ 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) @@ -34,10 +34,10 @@ // 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); } Index: clang-tidy/google/StringReferenceMemberCheck.h =================================================================== --- clang-tidy/google/StringReferenceMemberCheck.h +++ clang-tidy/google/StringReferenceMemberCheck.h @@ -1,4 +1,5 @@ -//===--- StringReferenceMemberCheck.h - clang-tidy ----------------*- C++ -*-===// +//===--- StringReferenceMemberCheck.h - clang-tidy ----------------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // Index: clang-tidy/google/StringReferenceMemberCheck.cpp =================================================================== --- clang-tidy/google/StringReferenceMemberCheck.cpp +++ clang-tidy/google/StringReferenceMemberCheck.cpp @@ -32,13 +32,13 @@ 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"), + this); } -void -StringReferenceMemberCheck::check(const MatchFinder::MatchResult &Result) { +void StringReferenceMemberCheck::check(const MatchFinder::MatchResult &Result) { const auto *Member = Result.Nodes.getNodeAs("member"); diag(Member->getLocStart(), "const string& members are dangerous; it is much " "better to use alternatives, such as pointers or " Index: clang-tidy/google/UnnamedNamespaceInHeaderCheck.cpp =================================================================== --- clang-tidy/google/UnnamedNamespaceInHeaderCheck.cpp +++ clang-tidy/google/UnnamedNamespaceInHeaderCheck.cpp @@ -25,8 +25,7 @@ RawStringHeaderFileExtensions( Options.getLocalOrGlobal("HeaderFileExtensions", "h,hh,hpp,hxx")) { if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions, - HeaderFileExtensions, - ',')) { + HeaderFileExtensions, ',')) { llvm::errs() << "Invalid header file extension: " << RawStringHeaderFileExtensions << "\n"; } @@ -46,8 +45,8 @@ this); } -void -UnnamedNamespaceInHeaderCheck::check(const MatchFinder::MatchResult &Result) { +void UnnamedNamespaceInHeaderCheck::check( + const MatchFinder::MatchResult &Result) { const auto *N = Result.Nodes.getNodeAs("anonymousNamespace"); SourceLocation Loc = N->getLocStart(); if (!Loc.isValid()) Index: clang-tidy/google/UsingNamespaceDirectiveCheck.cpp =================================================================== --- clang-tidy/google/UsingNamespaceDirectiveCheck.cpp +++ clang-tidy/google/UsingNamespaceDirectiveCheck.cpp @@ -27,8 +27,8 @@ 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("usingNamespace"); SourceLocation Loc = U->getLocStart(); if (U->isImplicit() || !Loc.isValid()) Index: clang-tidy/llvm/HeaderGuardCheck.cpp =================================================================== --- clang-tidy/llvm/HeaderGuardCheck.cpp +++ clang-tidy/llvm/HeaderGuardCheck.cpp @@ -14,7 +14,7 @@ namespace llvm { LLVMHeaderGuardCheck::LLVMHeaderGuardCheck(StringRef Name, - ClangTidyContext* Context) + ClangTidyContext *Context) : HeaderGuardCheck(Name, Context), RawStringHeaderFileExtensions( Options.getLocalOrGlobal("HeaderFileExtensions", ",h,hh,hpp,hxx")) { Index: clang-tidy/misc/ArgumentCommentCheck.h =================================================================== --- clang-tidy/misc/ArgumentCommentCheck.h +++ clang-tidy/misc/ArgumentCommentCheck.h @@ -27,7 +27,8 @@ /// /// ... /// f(/*bar=*/true); -/// // warning: argument name 'bar' in comment does not match parameter name 'foo' +/// // warning: argument name 'bar' in comment does not match parameter name +/// 'foo' /// \endcode /// /// The check tries to detect typos and suggest automated fixes for them. @@ -37,7 +38,7 @@ 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; Index: clang-tidy/misc/ArgumentCommentCheck.cpp =================================================================== --- clang-tidy/misc/ArgumentCommentCheck.cpp +++ clang-tidy/misc/ArgumentCommentCheck.cpp @@ -164,8 +164,8 @@ << Matches[2] << II; if (isLikelyTypo(Callee->parameters(), Matches[2], I)) { Diag << FixItHint::CreateReplacement( - Comment.first, - (Matches[1] + II->getName() + Matches[3]).str()); + Comment.first, + (Matches[1] + II->getName() + Matches[3]).str()); } } diag(PVD->getLocation(), "%0 declared here", DiagnosticIDs::Note) Index: clang-tidy/misc/BoolPointerImplicitConversionCheck.h =================================================================== --- clang-tidy/misc/BoolPointerImplicitConversionCheck.h +++ clang-tidy/misc/BoolPointerImplicitConversionCheck.h @@ -40,4 +40,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BOOLPOINTERIMPLICITCONVERSIONCHECK_H - Index: clang-tidy/misc/BoolPointerImplicitConversionCheck.cpp =================================================================== --- clang-tidy/misc/BoolPointerImplicitConversionCheck.cpp +++ clang-tidy/misc/BoolPointerImplicitConversionCheck.cpp @@ -25,7 +25,8 @@ hasType(pointerType(pointee(booleanType()))), ignoringParenImpCasts(declRefExpr().bind("expr")))), hasCastKind(CK_PointerToBoolean))))), - unless(isInTemplateInstantiation())).bind("if"), + unless(isInTemplateInstantiation())) + .bind("if"), this); } Index: clang-tidy/misc/DefinitionsInHeadersCheck.cpp =================================================================== --- clang-tidy/misc/DefinitionsInHeadersCheck.cpp +++ clang-tidy/misc/DefinitionsInHeadersCheck.cpp @@ -35,8 +35,7 @@ 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: " Index: clang-tidy/misc/ForwardDeclarationNamespaceCheck.h =================================================================== --- clang-tidy/misc/ForwardDeclarationNamespaceCheck.h +++ clang-tidy/misc/ForwardDeclarationNamespaceCheck.h @@ -10,10 +10,10 @@ #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 #include -#include "llvm/ADT/SmallPtrSet.h" -#include "../ClangTidy.h" namespace clang { namespace tidy { Index: clang-tidy/misc/ForwardDeclarationNamespaceCheck.cpp =================================================================== --- clang-tidy/misc/ForwardDeclarationNamespaceCheck.cpp +++ clang-tidy/misc/ForwardDeclarationNamespaceCheck.cpp @@ -8,12 +8,12 @@ //===----------------------------------------------------------------------===// #include "ForwardDeclarationNamespaceCheck.h" -#include -#include #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchers.h" +#include +#include using namespace clang::ast_matchers; Index: clang-tidy/misc/IncorrectRoundings.h =================================================================== --- clang-tidy/misc/IncorrectRoundings.h +++ clang-tidy/misc/IncorrectRoundings.h @@ -36,4 +36,4 @@ } // namespace tidy } // namespace clang -#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCORRECTROUNDINGS_H_ +#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCORRECTROUNDINGS_H_ Index: clang-tidy/misc/IncorrectRoundings.cpp =================================================================== --- clang-tidy/misc/IncorrectRoundings.cpp +++ clang-tidy/misc/IncorrectRoundings.cpp @@ -31,7 +31,6 @@ } } // namespace - void IncorrectRoundings::registerMatchers(MatchFinder *MatchFinder) { // Match a floating literal with value 0.5. auto FloatHalf = floatLiteral(floatHalf()); Index: clang-tidy/misc/MacroParenthesesCheck.cpp =================================================================== --- clang-tidy/misc/MacroParenthesesCheck.cpp +++ clang-tidy/misc/MacroParenthesesCheck.cpp @@ -79,7 +79,8 @@ 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; @@ -88,10 +89,10 @@ return false; // Skip possible types, etc - while ( - Tok != MI->tokens_end() && - Tok->isOneOf(tok::identifier, tok::raw_identifier, tok::coloncolon, - tok::star, tok::amp, tok::ampamp, tok::less, tok::greater)) + 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++; // Return true for possible variable declarations. Index: clang-tidy/misc/MacroRepeatedSideEffectsCheck.cpp =================================================================== --- clang-tidy/misc/MacroRepeatedSideEffectsCheck.cpp +++ clang-tidy/misc/MacroRepeatedSideEffectsCheck.cpp @@ -9,9 +9,9 @@ #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 { Index: clang-tidy/misc/MiscTidyModule.cpp =================================================================== --- clang-tidy/misc/MiscTidyModule.cpp +++ clang-tidy/misc/MiscTidyModule.cpp @@ -12,8 +12,6 @@ #include "../ClangTidyModuleRegistry.h" #include "ArgumentCommentCheck.h" #include "AssertSideEffectCheck.h" -#include "MisplacedConstCheck.h" -#include "UnconventionalAssignOperatorCheck.h" #include "BoolPointerImplicitConversionCheck.h" #include "DanglingHandleCheck.h" #include "DefinitionsInHeadersCheck.h" @@ -24,6 +22,7 @@ #include "InefficientAlgorithmCheck.h" #include "MacroParenthesesCheck.h" #include "MacroRepeatedSideEffectsCheck.h" +#include "MisplacedConstCheck.h" #include "MisplacedWideningCastCheck.h" #include "MoveConstantArgumentCheck.h" #include "MoveConstructorInitCheck.h" @@ -44,6 +43,7 @@ #include "SuspiciousStringCompareCheck.h" #include "SwappedArgumentsCheck.h" #include "ThrowByValueCatchByReferenceCheck.h" +#include "UnconventionalAssignOperatorCheck.h" #include "UndelegatedConstructor.h" #include "UniqueptrResetReleaseCheck.h" #include "UnusedAliasDeclsCheck.h" @@ -63,22 +63,18 @@ CheckFactories.registerCheck("misc-argument-comment"); CheckFactories.registerCheck( "misc-assert-side-effect"); - CheckFactories.registerCheck( - "misc-misplaced-const"); + CheckFactories.registerCheck("misc-misplaced-const"); CheckFactories.registerCheck( "misc-unconventional-assign-operator"); CheckFactories.registerCheck( "misc-bool-pointer-implicit-conversion"); - CheckFactories.registerCheck( - "misc-dangling-handle"); + CheckFactories.registerCheck("misc-dangling-handle"); CheckFactories.registerCheck( "misc-definitions-in-headers"); - CheckFactories.registerCheck( - "misc-fold-init-type"); + CheckFactories.registerCheck("misc-fold-init-type"); CheckFactories.registerCheck( "misc-forward-declaration-namespace"); - CheckFactories.registerCheck( - "misc-inaccurate-erase"); + CheckFactories.registerCheck("misc-inaccurate-erase"); CheckFactories.registerCheck( "misc-incorrect-roundings"); CheckFactories.registerCheck( @@ -108,8 +104,7 @@ CheckFactories.registerCheck("misc-sizeof-container"); CheckFactories.registerCheck( "misc-sizeof-expression"); - CheckFactories.registerCheck( - "misc-static-assert"); + CheckFactories.registerCheck("misc-static-assert"); CheckFactories.registerCheck( "misc-string-constructor"); CheckFactories.registerCheck( @@ -147,7 +142,7 @@ // Register the MiscTidyModule using this statically initialized variable. static ClangTidyModuleRegistry::Add -X("misc-module", "Adds miscellaneous lint checks."); + 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. Index: clang-tidy/misc/MisplacedWideningCastCheck.cpp =================================================================== --- clang-tidy/misc/MisplacedWideningCastCheck.cpp +++ clang-tidy/misc/MisplacedWideningCastCheck.cpp @@ -8,9 +8,9 @@ //===----------------------------------------------------------------------===// #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; @@ -49,8 +49,7 @@ 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); } Index: clang-tidy/misc/MoveConstantArgumentCheck.cpp =================================================================== --- clang-tidy/misc/MoveConstantArgumentCheck.cpp +++ clang-tidy/misc/MoveConstantArgumentCheck.cpp @@ -83,8 +83,8 @@ "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) { Index: clang-tidy/misc/MoveConstructorInitCheck.cpp =================================================================== --- clang-tidy/misc/MoveConstructorInitCheck.cpp +++ clang-tidy/misc/MoveConstructorInitCheck.cpp @@ -126,7 +126,8 @@ void MoveConstructorInitCheck::handleMoveConstructor( const MatchFinder::MatchResult &Result) { const auto *CopyCtor = Result.Nodes.getNodeAs("ctor"); - const auto *Initializer = Result.Nodes.getNodeAs("move-init"); + const auto *Initializer = + Result.Nodes.getNodeAs("move-init"); // Do not diagnose if the expression used to perform the initialization is a // trivially-copyable type. Index: clang-tidy/misc/MultipleStatementMacroCheck.cpp =================================================================== --- clang-tidy/misc/MultipleStatementMacroCheck.cpp +++ clang-tidy/misc/MultipleStatementMacroCheck.cpp @@ -29,7 +29,7 @@ const Stmt *Parent = Parents[0].get(); if (!Parent) return nullptr; - const Stmt* Prev = nullptr; + const Stmt *Prev = nullptr; for (const Stmt *Child : Parent->children()) { if (Prev == S) return Child; @@ -53,7 +53,7 @@ return Locs; } -} // namespace +} // namespace void MultipleStatementMacroCheck::registerMatchers(MatchFinder *Finder) { const auto Inner = expr(isInMacro(), unless(compoundStmt())).bind("inner"); Index: clang-tidy/misc/NewDeleteOverloadsCheck.h =================================================================== --- clang-tidy/misc/NewDeleteOverloadsCheck.h +++ clang-tidy/misc/NewDeleteOverloadsCheck.h @@ -20,11 +20,12 @@ class NewDeleteOverloadsCheck : public ClangTidyCheck { std::map> Overloads; + llvm::SmallVector> + Overloads; public: NewDeleteOverloadsCheck(StringRef Name, ClangTidyContext *Context) - : ClangTidyCheck(Name, Context) {} + : ClangTidyCheck(Name, Context) {} void registerMatchers(ast_matchers::MatchFinder *Finder) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void onEndOfTranslationUnit() override; Index: clang-tidy/misc/NewDeleteOverloadsCheck.cpp =================================================================== --- clang-tidy/misc/NewDeleteOverloadsCheck.cpp +++ clang-tidy/misc/NewDeleteOverloadsCheck.cpp @@ -64,7 +64,8 @@ OverloadedOperatorKind getCorrespondingOverload(const FunctionDecl *FD) { switch (FD->getOverloadedOperator()) { - default: break; + default: + break; case OO_New: return OO_Delete; case OO_Delete: @@ -79,7 +80,8 @@ const char *getOperatorName(OverloadedOperatorKind K) { switch (K) { - default: break; + default: + break; case OO_New: return "operator new"; case OO_Delete: @@ -140,13 +142,12 @@ // 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()))), - anyOf(hasOverloadedOperatorName("new"), - hasOverloadedOperatorName("new[]"), - hasOverloadedOperatorName("delete"), - hasOverloadedOperatorName("delete[]"))) + functionDecl(unless(anyOf(isImplicit(), isPlacementOverload(), + isDeleted(), cxxMethodDecl(isPrivate()))), + anyOf(hasOverloadedOperatorName("new"), + hasOverloadedOperatorName("new[]"), + hasOverloadedOperatorName("delete"), + hasOverloadedOperatorName("delete[]"))) .bind("func"), this); } Index: clang-tidy/misc/NoexceptMoveConstructorCheck.h =================================================================== --- clang-tidy/misc/NoexceptMoveConstructorCheck.h +++ clang-tidy/misc/NoexceptMoveConstructorCheck.h @@ -36,4 +36,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NOEXCEPTMOVECONSTRUCTORCHECK_H - Index: clang-tidy/misc/NoexceptMoveConstructorCheck.cpp =================================================================== --- clang-tidy/misc/NoexceptMoveConstructorCheck.cpp +++ clang-tidy/misc/NoexceptMoveConstructorCheck.cpp @@ -43,27 +43,27 @@ } const auto *ProtoType = Decl->getType()->getAs(); - switch(ProtoType->getNoexceptSpec(*Result.Context)) { - case FunctionProtoType::NR_NoNoexcept: - diag(Decl->getLocation(), "move %0s should be marked noexcept") + 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()) { + if (isa(E)) + break; + diag(E->getExprLoc(), + "noexcept specifier on the move %0 evaluates to 'false'") << 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()) { - if (isa(E)) - break; - diag(E->getExprLoc(), - "noexcept specifier on the move %0 evaluates to 'false'") - << MethodType; - } - break; - case FunctionProtoType::NR_Nothrow: - case FunctionProtoType::NR_Dependent: - case FunctionProtoType::NR_BadNoexcept: - break; + } + break; + case FunctionProtoType::NR_Nothrow: + case FunctionProtoType::NR_Dependent: + case FunctionProtoType::NR_BadNoexcept: + break; } } } @@ -71,4 +71,3 @@ } // namespace misc } // namespace tidy } // namespace clang - Index: clang-tidy/misc/NonCopyableObjects.h =================================================================== --- clang-tidy/misc/NonCopyableObjects.h +++ clang-tidy/misc/NonCopyableObjects.h @@ -21,7 +21,7 @@ class NonCopyableObjectsCheck : public ClangTidyCheck { public: NonCopyableObjectsCheck(StringRef Name, ClangTidyContext *Context) - : ClangTidyCheck(Name, Context) {} + : ClangTidyCheck(Name, Context) {} void registerMatchers(ast_matchers::MatchFinder *Finder) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override; }; Index: clang-tidy/misc/NonCopyableObjects.cpp =================================================================== --- clang-tidy/misc/NonCopyableObjects.cpp +++ clang-tidy/misc/NonCopyableObjects.cpp @@ -23,22 +23,15 @@ // users can add their own elements to the list. However, it may require some // extra thought since POSIX types and FILE types are usable in different ways. bool isPOSIXTypeName(StringRef ClassName) { - static const char *const TypeNames[] = { - "::pthread_cond_t", - "::pthread_mutex_t", - "pthread_cond_t", - "pthread_mutex_t" - }; + static const char *const TypeNames[] = {"::pthread_cond_t", + "::pthread_mutex_t", "pthread_cond_t", + "pthread_mutex_t"}; return std::binary_search(std::begin(TypeNames), std::end(TypeNames), ClassName); } bool isFILETypeName(StringRef ClassName) { - static const char *const TypeNames[] = { - "::FILE", - "FILE", - "std::FILE" - }; + static const char *const TypeNames[] = {"::FILE", "FILE", "std::FILE"}; return std::binary_search(std::begin(TypeNames), std::end(TypeNames), ClassName); } @@ -96,4 +89,3 @@ } // namespace misc } // namespace tidy } // namespace clang - Index: clang-tidy/misc/SizeofContainerCheck.h =================================================================== --- clang-tidy/misc/SizeofContainerCheck.h +++ clang-tidy/misc/SizeofContainerCheck.h @@ -34,4 +34,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SIZEOF_CONTAINER_H - Index: clang-tidy/misc/SizeofContainerCheck.cpp =================================================================== --- clang-tidy/misc/SizeofContainerCheck.cpp +++ clang-tidy/misc/SizeofContainerCheck.cpp @@ -47,4 +47,3 @@ } // namespace misc } // namespace tidy } // namespace clang - Index: clang-tidy/misc/SizeofExpressionCheck.cpp =================================================================== --- clang-tidy/misc/SizeofExpressionCheck.cpp +++ clang-tidy/misc/SizeofExpressionCheck.cpp @@ -8,9 +8,9 @@ //===----------------------------------------------------------------------===// #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; Index: clang-tidy/misc/StringIntegerAssignmentCheck.h =================================================================== --- clang-tidy/misc/StringIntegerAssignmentCheck.h +++ clang-tidy/misc/StringIntegerAssignmentCheck.h @@ -33,4 +33,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_INTEGER_ASSIGNMENT_H - Index: clang-tidy/misc/SuspiciousMissingCommaCheck.h =================================================================== --- clang-tidy/misc/SuspiciousMissingCommaCheck.h +++ clang-tidy/misc/SuspiciousMissingCommaCheck.h @@ -16,7 +16,8 @@ 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 Index: clang-tidy/misc/SuspiciousMissingCommaCheck.cpp =================================================================== --- clang-tidy/misc/SuspiciousMissingCommaCheck.cpp +++ clang-tidy/misc/SuspiciousMissingCommaCheck.cpp @@ -19,8 +19,8 @@ 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); @@ -36,13 +36,13 @@ // "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); @@ -59,14 +59,14 @@ 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) @@ -102,25 +102,28 @@ // 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(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 Index: clang-tidy/misc/SuspiciousStringCompareCheck.cpp =================================================================== --- clang-tidy/misc/SuspiciousStringCompareCheck.cpp +++ clang-tidy/misc/SuspiciousStringCompareCheck.cpp @@ -20,7 +20,6 @@ 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;" @@ -104,13 +103,12 @@ .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)), + hasFalseExpression(ignoringParenImpCasts(DirectStringCompareCallExpr)))); // The implicit cast is not present in C. const auto StringCompareCallExpr = ignoringParenImpCasts( - anyOf(DirectStringCompareCallExpr, MacroStringCompareCallExpr)); + anyOf(DirectStringCompareCallExpr, MacroStringCompareCallExpr)); if (WarnOnImplicitComparison) { // Detect suspicious calls to string compare: @@ -203,7 +201,8 @@ << Decl; } - if (const auto* BinOp = Result.Nodes.getNodeAs("suspicious-operator")) { + if (const auto *BinOp = + Result.Nodes.getNodeAs("suspicious-operator")) { diag(Call->getLocStart(), "results of function %0 used by operator '%1'") << Decl << BinOp->getOpcodeStr(); } Index: clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp =================================================================== --- clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp +++ clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp @@ -9,8 +9,8 @@ #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; Index: clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp =================================================================== --- clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp +++ clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp @@ -17,7 +17,8 @@ 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) @@ -65,7 +66,8 @@ this); } -void UnconventionalAssignOperatorCheck::check(const MatchFinder::MatchResult &Result) { +void UnconventionalAssignOperatorCheck::check( + const MatchFinder::MatchResult &Result) { if (const auto *RetStmt = Result.Nodes.getNodeAs("returnStmt")) { diag(RetStmt->getLocStart(), "operator=() should always return '*this'"); } else { Index: clang-tidy/misc/UndelegatedConstructor.cpp =================================================================== --- clang-tidy/misc/UndelegatedConstructor.cpp +++ clang-tidy/misc/UndelegatedConstructor.cpp @@ -72,7 +72,8 @@ this); } -void UndelegatedConstructorCheck::check(const MatchFinder::MatchResult &Result) { +void UndelegatedConstructorCheck::check( + const MatchFinder::MatchResult &Result) { const auto *E = Result.Nodes.getStmtAs("construct"); diag(E->getLocStart(), "did you intend to call a delegated constructor? " "A temporary object is created here instead"); Index: clang-tidy/misc/UniqueptrResetReleaseCheck.cpp =================================================================== --- clang-tidy/misc/UniqueptrResetReleaseCheck.cpp +++ clang-tidy/misc/UniqueptrResetReleaseCheck.cpp @@ -91,7 +91,7 @@ return false; } -} // namespace +} // namespace void UniqueptrResetReleaseCheck::check(const MatchFinder::MatchResult &Result) { if (!areDeletersCompatible(Result)) @@ -127,9 +127,8 @@ } std::string NewText = LeftText + " = " + RightText; - diag(ResetMember->getExprLoc(), DiagText) - << FixItHint::CreateReplacement( - CharSourceRange::getTokenRange(ResetCall->getSourceRange()), NewText); + diag(ResetMember->getExprLoc(), DiagText) << FixItHint::CreateReplacement( + CharSourceRange::getTokenRange(ResetCall->getSourceRange()), NewText); } } // namespace misc Index: clang-tidy/misc/UnusedAliasDeclsCheck.h =================================================================== --- clang-tidy/misc/UnusedAliasDeclsCheck.h +++ clang-tidy/misc/UnusedAliasDeclsCheck.h @@ -35,4 +35,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H - Index: clang-tidy/misc/UnusedParametersCheck.h =================================================================== --- clang-tidy/misc/UnusedParametersCheck.h +++ clang-tidy/misc/UnusedParametersCheck.h @@ -36,4 +36,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H - Index: clang-tidy/misc/UnusedParametersCheck.cpp =================================================================== --- clang-tidy/misc/UnusedParametersCheck.cpp +++ clang-tidy/misc/UnusedParametersCheck.cpp @@ -107,8 +107,7 @@ void UnusedParametersCheck::check(const MatchFinder::MatchResult &Result) { const auto *Function = Result.Nodes.getNodeAs("function"); if (!Function->doesThisDeclarationHaveABody() || - !Function->hasWrittenPrototype() || - Function->isTemplateInstantiation()) + !Function->hasWrittenPrototype() || Function->isTemplateInstantiation()) return; if (const auto *Method = dyn_cast(Function)) if (Method->isLambdaStaticInvoker()) Index: clang-tidy/misc/UnusedUsingDeclsCheck.cpp =================================================================== --- clang-tidy/misc/UnusedUsingDeclsCheck.cpp +++ clang-tidy/misc/UnusedUsingDeclsCheck.cpp @@ -42,8 +42,9 @@ 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) { @@ -126,7 +127,7 @@ } // Check the uninstantiated template function usage. if (const auto *ULE = Result.Nodes.getNodeAs("used")) { - for (const NamedDecl* ND : ULE->decls()) { + for (const NamedDecl *ND : ULE->decls()) { if (const auto *USD = dyn_cast(ND)) removeFromFoundDecls(USD->getTargetDecl()->getCanonicalDecl()); } Index: clang-tidy/misc/UseAfterMoveCheck.cpp =================================================================== --- clang-tidy/misc/UseAfterMoveCheck.cpp +++ clang-tidy/misc/UseAfterMoveCheck.cpp @@ -604,8 +604,7 @@ } } -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(); @@ -631,12 +630,11 @@ return; auto CallMoveMatcher = - 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())) + 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( Index: clang-tidy/modernize/AvoidBindCheck.cpp =================================================================== --- clang-tidy/modernize/AvoidBindCheck.cpp +++ clang-tidy/modernize/AvoidBindCheck.cpp @@ -154,7 +154,7 @@ addPlaceholderArgs(Args, Stream); Stream << " { return "; Ref->printPretty(Stream, nullptr, Result.Context->getPrintingPolicy()); - Stream<< "("; + Stream << "("; addFunctionCallArgs(Args, Stream); Stream << "); };"; Index: clang-tidy/modernize/MakeUniqueCheck.h =================================================================== --- clang-tidy/modernize/MakeUniqueCheck.h +++ clang-tidy/modernize/MakeUniqueCheck.h @@ -38,4 +38,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_UNIQUE_H - Index: clang-tidy/modernize/ModernizeTidyModule.cpp =================================================================== --- clang-tidy/modernize/ModernizeTidyModule.cpp +++ clang-tidy/modernize/ModernizeTidyModule.cpp @@ -37,8 +37,7 @@ class ModernizeModule : public ClangTidyModule { public: void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { - CheckFactories.registerCheck( - "modernize-avoid-bind"); + CheckFactories.registerCheck("modernize-avoid-bind"); CheckFactories.registerCheck( "modernize-deprecated-headers"); CheckFactories.registerCheck("modernize-loop-convert"); Index: clang-tidy/modernize/RawStringLiteralCheck.cpp =================================================================== --- clang-tidy/modernize/RawStringLiteralCheck.cpp +++ clang-tidy/modernize/RawStringLiteralCheck.cpp @@ -133,7 +133,7 @@ diag(Literal->getLocStart(), "escaped string literal can be written as a raw string literal") << FixItHint::CreateReplacement( - CharRange, asRawStringLiteral(Literal, DelimiterStem)); + CharRange, asRawStringLiteral(Literal, DelimiterStem)); } } // namespace modernize Index: clang-tidy/modernize/UseAutoCheck.cpp =================================================================== --- clang-tidy/modernize/UseAutoCheck.cpp +++ clang-tidy/modernize/UseAutoCheck.cpp @@ -9,8 +9,8 @@ #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; @@ -114,20 +114,19 @@ /// 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", + "forward_list", "list", + "vector", - "map", "multimap", - "set", "multiset", + "map", "multimap", + "set", "multiset", - "unordered_map", - "unordered_multimap", - "unordered_set", - "unordered_multiset", + "unordered_map", "unordered_multimap", + "unordered_set", "unordered_multiset", - "queue", "priority_queue", - "stack"}; + "queue", "priority_queue", + "stack"}; for (const char *Name : ContainerNames) { if (hasName(Name).matches(Node, Finder, Builder)) Index: clang-tidy/modernize/UseDefaultCheck.h =================================================================== --- clang-tidy/modernize/UseDefaultCheck.h +++ clang-tidy/modernize/UseDefaultCheck.h @@ -48,4 +48,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_DEFAULT_H - Index: clang-tidy/modernize/UseNullptrCheck.cpp =================================================================== --- clang-tidy/modernize/UseNullptrCheck.cpp +++ clang-tidy/modernize/UseNullptrCheck.cpp @@ -38,8 +38,7 @@ /// 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, Index: clang-tidy/mpi/TypeMismatchCheck.h =================================================================== --- clang-tidy/mpi/TypeMismatchCheck.h +++ clang-tidy/mpi/TypeMismatchCheck.h @@ -41,8 +41,7 @@ /// \param LO language options void checkArguments(ArrayRef BufferTypes, ArrayRef BufferExprs, - ArrayRef MPIDatatypes, - const LangOptions &LO); + ArrayRef MPIDatatypes, const LangOptions &LO); }; } // namespace mpi Index: clang-tidy/performance/FasterStringFindCheck.cpp =================================================================== --- clang-tidy/performance/FasterStringFindCheck.cpp +++ clang-tidy/performance/FasterStringFindCheck.cpp @@ -30,10 +30,12 @@ } // 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; } @@ -50,8 +52,7 @@ 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", Index: clang-tidy/performance/ImplicitCastInLoopCheck.h =================================================================== --- clang-tidy/performance/ImplicitCastInLoopCheck.h +++ clang-tidy/performance/ImplicitCastInLoopCheck.h @@ -20,13 +20,13 @@ // 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; +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: +private: void ReportAndFix(const ASTContext *Context, const VarDecl *VD, const CXXOperatorCallExpr *OperatorCall); }; @@ -35,4 +35,4 @@ } // 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_ Index: clang-tidy/performance/ImplicitCastInLoopCheck.cpp =================================================================== --- clang-tidy/performance/ImplicitCastInLoopCheck.cpp +++ clang-tidy/performance/ImplicitCastInLoopCheck.cpp @@ -29,7 +29,7 @@ bool IsNonTrivialImplicitCast(const Stmt *ST) { if (const auto *ICE = dyn_cast(ST)) { return (ICE->getCastKind() != CK_NoOp) || - IsNonTrivialImplicitCast(ICE->getSubExpr()); + IsNonTrivialImplicitCast(ICE->getSubExpr()); } return false; } Index: clang-tidy/performance/UnnecessaryCopyInitialization.cpp =================================================================== --- clang-tidy/performance/UnnecessaryCopyInitialization.cpp +++ clang-tidy/performance/UnnecessaryCopyInitialization.cpp @@ -27,7 +27,6 @@ } // namespace - using namespace ::clang::ast_matchers; using utils::decl_ref_expr::isOnlyUsedAsConst; @@ -44,9 +43,9 @@ // 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))), - on(declRefExpr(to(varDecl().bind("objectArg"))))); + auto ConstRefReturningMethodCall = + cxxMemberCallExpr(callee(cxxMethodDecl(returns(ConstReference))), + on(declRefExpr(to(varDecl().bind("objectArg"))))); auto ConstRefReturningFunctionCall = callExpr(callee(functionDecl(returns(ConstReference))), unless(callee(cxxMethodDecl()))); @@ -63,14 +62,14 @@ isCopyConstructor())), hasArgument(0, CopyCtorArg)) .bind("ctorCall"))) - .bind("newVarDecl"))).bind("declStmt"))) + .bind("newVarDecl"))) + .bind("declStmt"))) .bind("blockStmt"); }; - Finder->addMatcher( - localVarCopiedFrom(anyOf(ConstRefReturningFunctionCall, - ConstRefReturningMethodCall)), - this); + Finder->addMatcher(localVarCopiedFrom(anyOf(ConstRefReturningFunctionCall, + ConstRefReturningMethodCall)), + this); Finder->addMatcher(localVarCopiedFrom(declRefExpr( to(varDecl(hasLocalStorage()).bind("oldVarDecl")))), Index: clang-tidy/performance/UnnecessaryValueParamCheck.cpp =================================================================== --- clang-tidy/performance/UnnecessaryValueParamCheck.cpp +++ clang-tidy/performance/UnnecessaryValueParamCheck.cpp @@ -127,7 +127,7 @@ FunctionDecl = FunctionDecl->getPreviousDecl()) { const auto &CurrentParam = *FunctionDecl->getParamDecl(Index); Diag << utils::fixit::changeVarDeclToReference(CurrentParam, - *Result.Context); + *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. Index: clang-tidy/readability/AvoidConstParamsInDecls.cpp =================================================================== --- clang-tidy/readability/AvoidConstParamsInDecls.cpp +++ clang-tidy/readability/AvoidConstParamsInDecls.cpp @@ -8,10 +8,10 @@ //===----------------------------------------------------------------------===// #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; Index: clang-tidy/readability/BracesAroundStatementsCheck.h =================================================================== --- clang-tidy/readability/BracesAroundStatementsCheck.h +++ clang-tidy/readability/BracesAroundStatementsCheck.h @@ -58,7 +58,7 @@ const ASTContext *Context); private: - std::set ForceBracesStmts; + std::set ForceBracesStmts; const unsigned ShortStatementLines; }; Index: clang-tidy/readability/BracesAroundStatementsCheck.cpp =================================================================== --- clang-tidy/readability/BracesAroundStatementsCheck.cpp +++ clang-tidy/readability/BracesAroundStatementsCheck.cpp @@ -117,8 +117,8 @@ // 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); } @@ -130,8 +130,8 @@ 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; Index: clang-tidy/readability/IdentifierNamingCheck.cpp =================================================================== --- clang-tidy/readability/IdentifierNamingCheck.cpp +++ clang-tidy/readability/IdentifierNamingCheck.cpp @@ -9,13 +9,13 @@ #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" @@ -662,7 +662,8 @@ /// 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); @@ -752,7 +753,8 @@ if (const auto *DeclRef = Result.Nodes.getNodeAs("declRef")) { SourceRange Range = DeclRef->getNameInfo().getSourceRange(); - addUsage(NamingCheckFailures, DeclRef->getDecl(), Range, Result.SourceManager); + addUsage(NamingCheckFailures, DeclRef->getDecl(), Range, + Result.SourceManager); return; } Index: clang-tidy/readability/ImplicitBoolCastCheck.cpp =================================================================== --- clang-tidy/readability/ImplicitBoolCastCheck.cpp +++ clang-tidy/readability/ImplicitBoolCastCheck.cpp @@ -307,8 +307,7 @@ 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", Index: clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp =================================================================== --- clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp +++ clang-tidy/readability/InconsistentDeclarationParameterNameCheck.cpp @@ -110,7 +110,8 @@ SourceParamName != OtherParamName) { SourceRange OtherParamNameRange = DeclarationNameInfo((*OtherParamIt)->getDeclName(), - (*OtherParamIt)->getLocation()).getSourceRange(); + (*OtherParamIt)->getLocation()) + .getSourceRange(); bool GenerateFixItHint = checkIfFixItHintIsApplicable( ParameterSourceDeclaration, *SourceParamIt, OriginalDeclaration); @@ -202,13 +203,15 @@ } 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, Index: clang-tidy/readability/NamespaceCommentCheck.cpp =================================================================== --- clang-tidy/readability/NamespaceCommentCheck.cpp +++ clang-tidy/readability/NamespaceCommentCheck.cpp @@ -114,7 +114,8 @@ 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. Index: clang-tidy/readability/RedundantControlFlowCheck.cpp =================================================================== --- clang-tidy/readability/RedundantControlFlowCheck.cpp +++ clang-tidy/readability/RedundantControlFlowCheck.cpp @@ -33,9 +33,10 @@ 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")); Index: clang-tidy/readability/RedundantDeclarationCheck.cpp =================================================================== --- clang-tidy/readability/RedundantDeclarationCheck.cpp +++ clang-tidy/readability/RedundantDeclarationCheck.cpp @@ -19,7 +19,8 @@ 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) { @@ -33,8 +34,8 @@ const SourceManager &SM = *Result.SourceManager; const bool DifferentHeaders = - !SM.isInMainFile(D->getLocation()) && - !SM.isWrittenInSameFile(Prev->getLocation(), D->getLocation()); + !SM.isInMainFile(D->getLocation()) && + !SM.isWrittenInSameFile(Prev->getLocation(), D->getLocation()); bool MultiVar = false; if (const auto *VD = dyn_cast(D)) { @@ -57,8 +58,7 @@ 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)); Index: clang-tidy/readability/RedundantMemberInitCheck.cpp =================================================================== --- clang-tidy/readability/RedundantMemberInitCheck.cpp +++ clang-tidy/readability/RedundantMemberInitCheck.cpp @@ -8,10 +8,10 @@ //===----------------------------------------------------------------------===// #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 using namespace clang::ast_matchers; Index: clang-tidy/readability/RedundantStringCStrCheck.cpp =================================================================== --- clang-tidy/readability/RedundantStringCStrCheck.cpp +++ clang-tidy/readability/RedundantStringCStrCheck.cpp @@ -77,17 +77,14 @@ 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), - hasDeclaration(cxxMethodDecl(hasName("basic_string")))), + cxxConstructExpr(argumentCountIs(1), + hasDeclaration(cxxMethodDecl(hasName("basic_string")))), cxxConstructExpr( argumentCountIs(2), hasDeclaration(cxxMethodDecl(hasName("basic_string"))), @@ -103,21 +100,18 @@ .bind("call"); // Detect redundant 'c_str()' calls through a string constructor. - Finder->addMatcher( - cxxConstructExpr(StringConstructorExpr, - hasArgument(0, StringCStrCallExpr)), - this); + 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("=="), + hasOverloadedOperatorName("+")), anyOf(allOf(hasArgument(0, StringExpr), hasArgument(1, StringCStrCallExpr)), allOf(hasArgument(0, StringCStrCallExpr), @@ -126,47 +120,41 @@ // Detect: 'dst += str.c_str()' -> 'dst += str' // Detect: 's = str.c_str()' -> 's = str' - Finder->addMatcher( - cxxOperatorCallExpr( - anyOf(hasOverloadedOperatorName("="), - hasOverloadedOperatorName("+=")), - hasArgument(0, StringExpr), - hasArgument(1, StringCStrCallExpr)), - this); + 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)), + callee(decl(cxxMethodDecl(hasName("compare")))), + 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", - "find_last_not_of", "find_last_of", "rfind")))), - anyOf(argumentCountIs(1), argumentCountIs(2)), - hasArgument(0, StringCStrCallExpr)), + 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)), + callee(decl(cxxMethodDecl(hasName("insert")))), + argumentCountIs(2), hasArgument(1, StringCStrCallExpr)), this); // Detect redundant 'c_str()' calls through a StringRef constructor. @@ -176,9 +164,8 @@ // 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 Index: clang-tidy/readability/RedundantStringInitCheck.cpp =================================================================== --- clang-tidy/readability/RedundantStringInitCheck.cpp +++ clang-tidy/readability/RedundantStringInitCheck.cpp @@ -33,10 +33,9 @@ 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, Index: clang-tidy/readability/StaticDefinitionInAnonymousNamespaceCheck.h =================================================================== --- clang-tidy/readability/StaticDefinitionInAnonymousNamespaceCheck.h +++ clang-tidy/readability/StaticDefinitionInAnonymousNamespaceCheck.h @@ -22,7 +22,8 @@ /// 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; Index: clang-tidy/readability/UniqueptrDeleteReleaseCheck.h =================================================================== --- clang-tidy/readability/UniqueptrDeleteReleaseCheck.h +++ clang-tidy/readability/UniqueptrDeleteReleaseCheck.h @@ -34,4 +34,3 @@ } // namespace clang #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UNIQUEPTR_DELETE_RELEASE_H - Index: clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp =================================================================== --- clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp +++ clang-tidy/readability/UniqueptrDeleteReleaseCheck.cpp @@ -67,4 +67,3 @@ } // namespace readability } // namespace tidy } // namespace clang - Index: clang-tidy/tool/ClangTidyMain.cpp =================================================================== --- clang-tidy/tool/ClangTidyMain.cpp +++ clang-tidy/tool/ClangTidyMain.cpp @@ -93,9 +93,7 @@ SystemHeaders("system-headers", cl::desc("Display the errors from system headers."), cl::init(false), cl::cat(ClangTidyCategory)); -static cl::opt - LineFilter("line-filter", - cl::desc(R"( +static cl::opt 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 @@ -105,7 +103,8 @@ {"name":"file2.h"} ] )"), - cl::init(""), cl::cat(ClangTidyCategory)); + cl::init(""), + cl::cat(ClangTidyCategory)); static cl::opt Fix("fix", cl::desc(R"( Apply suggested fixes. Without -fix-errors @@ -220,7 +219,7 @@ std::vector> 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(); } @@ -324,7 +323,7 @@ std::vector EnabledChecks = getCheckNames(EffectiveOptions); if (ExplainConfig) { - //FIXME: Show other ClangTidyOptions' fields, like ExtraArg. + // FIXME: Show other ClangTidyOptions' fields, like ExtraArg. std::vector RawOptions = OptionsProvider->getRawOptions(FilePath); for (const std::string &Check : EnabledChecks) { @@ -377,8 +376,7 @@ std::vector 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; @@ -458,7 +456,7 @@ // This anchor is used to force the linker to link the MPIModule. extern volatile int MPIModuleAnchorSource; static int LLVM_ATTRIBUTE_UNUSED MPIModuleAnchorDestination = - MPIModuleAnchorSource; + MPIModuleAnchorSource; // This anchor is used to force the linker to link the PerformanceModule. extern volatile int PerformanceModuleAnchorSource; Index: clang-tidy/utils/IncludeInserter.cpp =================================================================== --- clang-tidy/utils/IncludeInserter.cpp +++ clang-tidy/utils/IncludeInserter.cpp @@ -21,9 +21,8 @@ // 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 { Index: clang-tidy/utils/Matchers.h =================================================================== --- clang-tidy/utils/Matchers.h +++ clang-tidy/utils/Matchers.h @@ -10,8 +10,8 @@ #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 { @@ -21,9 +21,7 @@ return Node.isRelationalOp(); } -AST_MATCHER(BinaryOperator, isEqualityOperator) { - return Node.isEqualityOp(); -} +AST_MATCHER(BinaryOperator, isEqualityOperator) { return Node.isEqualityOp(); } AST_MATCHER(BinaryOperator, isComparisonOperator) { return Node.isComparisonOp(); Index: clang-tidy/utils/NamespaceAliaser.cpp =================================================================== --- clang-tidy/utils/NamespaceAliaser.cpp +++ clang-tidy/utils/NamespaceAliaser.cpp @@ -35,11 +35,9 @@ 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. Index: clang-tidy/utils/TypeTraits.cpp =================================================================== --- clang-tidy/utils/TypeTraits.cpp +++ clang-tidy/utils/TypeTraits.cpp @@ -65,7 +65,8 @@ 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; @@ -84,8 +85,7 @@ } // Based on QualType::isTrivial. -bool isTriviallyDefaultConstructible(QualType Type, - const ASTContext &Context) { +bool isTriviallyDefaultConstructible(QualType Type, const ASTContext &Context) { if (Type.isNull()) return false; Index: clang-tidy/utils/UsingInserter.cpp =================================================================== --- clang-tidy/utils/UsingInserter.cpp +++ clang-tidy/utils/UsingInserter.cpp @@ -68,7 +68,8 @@ 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); Index: include-fixer/IncludeFixer.cpp =================================================================== --- include-fixer/IncludeFixer.cpp +++ include-fixer/IncludeFixer.cpp @@ -279,7 +279,8 @@ // It's unsafe to do nested search for the identifier with scoped namespace // context, it might treat the identifier as a nested class of the scoped // namespace. - MatchedSymbols = SymbolIndexMgr.search(QueryString, /*IsNestedSearch=*/false); + MatchedSymbols = + SymbolIndexMgr.search(QueryString, /*IsNestedSearch=*/false); if (MatchedSymbols.empty()) MatchedSymbols = SymbolIndexMgr.search(Query); DEBUG(llvm::dbgs() << "Having found " << MatchedSymbols.size() Index: include-fixer/IncludeFixerContext.cpp =================================================================== --- include-fixer/IncludeFixerContext.cpp +++ include-fixer/IncludeFixerContext.cpp @@ -24,8 +24,7 @@ } std::string createQualifiedNameForReplacement( - llvm::StringRef RawSymbolName, - llvm::StringRef SymbolScopedQualifiersName, + llvm::StringRef RawSymbolName, llvm::StringRef SymbolScopedQualifiersName, const find_all_symbols::SymbolInfo &MatchedSymbol) { // No need to add missing qualifiers if SymbolIndentifer has a global scope // operator "::". Index: include-fixer/find-all-symbols/FindAllMacros.cpp =================================================================== --- include-fixer/find-all-symbols/FindAllMacros.cpp +++ include-fixer/find-all-symbols/FindAllMacros.cpp @@ -23,7 +23,8 @@ const MacroDirective *MD) { SourceLocation Loc = SM->getExpansionLoc(MacroNameTok.getLocation()); std::string FilePath = getIncludePath(*SM, Loc, Collector); - if (FilePath.empty()) return; + if (FilePath.empty()) + return; SymbolInfo Symbol(MacroNameTok.getIdentifierInfo()->getName(), SymbolInfo::SymbolKind::Macro, FilePath, Index: include-fixer/find-all-symbols/FindAllSymbols.cpp =================================================================== --- include-fixer/find-all-symbols/FindAllSymbols.cpp +++ include-fixer/find-all-symbols/FindAllSymbols.cpp @@ -40,8 +40,7 @@ llvm::isa(Context)) break; - assert(llvm::isa(Context) && - "Expect Context to be a NamedDecl"); + assert(llvm::isa(Context) && "Expect Context to be a NamedDecl"); if (const auto *NSD = dyn_cast(Context)) { if (!NSD->isInlineNamespace()) Contexts.emplace_back(SymbolInfo::ContextType::Namespace, @@ -95,7 +94,8 @@ } std::string FilePath = getIncludePath(SM, Loc, Collector); - if (FilePath.empty()) return llvm::None; + if (FilePath.empty()) + return llvm::None; return SymbolInfo(ND->getNameAsString(), Type, FilePath, SM.getExpansionLineNumber(Loc), GetContexts(ND)); @@ -198,8 +198,7 @@ // inside toplevel translation unit or a namespace. MatchFinder->addMatcher( enumConstantDecl( - CommonFilter, - unless(isInScopedEnum()), + CommonFilter, unless(isInScopedEnum()), anyOf(hasDeclContext(enumDecl(HasNSOrTUCtxMatcher)), ExternCMatcher)) .bind("decl"), this); @@ -215,8 +214,7 @@ assert(ND && "Matched declaration must be a NamedDecl!"); const SourceManager *SM = Result.SourceManager; - llvm::Optional Symbol = - CreateSymbolInfo(ND, *SM, Collector); + llvm::Optional Symbol = CreateSymbolInfo(ND, *SM, Collector); if (Symbol) Reporter->reportSymbol( SM->getFileEntryForID(SM->getMainFileID())->getName(), *Symbol); Index: include-fixer/find-all-symbols/FindAllSymbolsAction.cpp =================================================================== --- include-fixer/find-all-symbols/FindAllSymbolsAction.cpp +++ include-fixer/find-all-symbols/FindAllSymbolsAction.cpp @@ -1,4 +1,5 @@ -//===-- FindAllSymbolsAction.cpp - find all symbols action --------*- C++ -*-===// +//===-- FindAllSymbolsAction.cpp - find all symbols action --------*- C++ +//-*-===// // // The LLVM Compiler Infrastructure // Index: include-fixer/tool/ClangIncludeFixer.cpp =================================================================== --- include-fixer/tool/ClangIncludeFixer.cpp +++ include-fixer/tool/ClangIncludeFixer.cpp @@ -99,9 +99,9 @@ cl::opt QuerySymbol("query-symbol", - cl::desc("Query a given symbol (e.g. \"a::b::foo\") in\n" - "database directly without parsing the file."), - cl::cat(IncludeFixerCategory)); + cl::desc("Query a given symbol (e.g. \"a::b::foo\") in\n" + "database directly without parsing the file."), + cl::cat(IncludeFixerCategory)); cl::opt MinimizeIncludePaths("minimize-paths", @@ -209,10 +209,10 @@ return SymbolIndexMgr; } -void writeToJson(llvm::raw_ostream &OS, const IncludeFixerContext& Context) { +void writeToJson(llvm::raw_ostream &OS, const IncludeFixerContext &Context) { OS << "{\n" - << " \"FilePath\": \"" - << llvm::yaml::escape(Context.getFilePath()) << "\",\n" + << " \"FilePath\": \"" << llvm::yaml::escape(Context.getFilePath()) + << "\",\n" << " \"QuerySymbolInfos\": [\n"; for (const auto &Info : Context.getQuerySymbolInfos()) { OS << " {\"RawIdentifier\": \"" << Info.RawIdentifier << "\",\n"; @@ -257,7 +257,7 @@ } Code = std::move(CodeOrErr.get()); if (Code->getBufferSize() == 0) - return 0; // Skip empty files. + return 0; // Skip empty files. tool.mapVirtualFile(SourceFilePath, Code->getBuffer()); } @@ -277,7 +277,7 @@ // We only accept one unique header. // Check all elements in HeaderInfos have the same header. bool IsUniqueHeader = std::equal( - HeaderInfos.begin()+1, HeaderInfos.end(), HeaderInfos.begin(), + HeaderInfos.begin() + 1, HeaderInfos.end(), HeaderInfos.begin(), [](const IncludeFixerContext::HeaderInfo &LHS, const IncludeFixerContext::HeaderInfo &RHS) { return LHS.Header == RHS.Header; @@ -431,6 +431,4 @@ } // namespace -int main(int argc, const char **argv) { - return includeFixerMain(argc, argv); -} +int main(int argc, const char **argv) { return includeFixerMain(argc, argv); } Index: modularize/CoverageChecker.h =================================================================== --- modularize/CoverageChecker.h +++ modularize/CoverageChecker.h @@ -77,9 +77,9 @@ /// \param CommandLine Compile command line arguments. /// \param ModuleMap The module map to check. CoverageChecker(llvm::StringRef ModuleMapPath, - std::vector &IncludePaths, - llvm::ArrayRef CommandLine, - clang::ModuleMap *ModuleMap); + std::vector &IncludePaths, + llvm::ArrayRef CommandLine, + clang::ModuleMap *ModuleMap); /// Create instance of CoverageChecker. /// \param ModuleMapPath The module.modulemap file path. @@ -92,9 +92,8 @@ /// \param ModuleMap The module map to check. /// \returns Initialized CoverageChecker object. static CoverageChecker *createCoverageChecker( - llvm::StringRef ModuleMapPath, std::vector &IncludePaths, - llvm::ArrayRef CommandLine, - clang::ModuleMap *ModuleMap); + llvm::StringRef ModuleMapPath, std::vector &IncludePaths, + llvm::ArrayRef CommandLine, clang::ModuleMap *ModuleMap); /// Do checks. /// Starting from the directory of the module.modulemap file, Index: modularize/CoverageChecker.cpp =================================================================== --- modularize/CoverageChecker.cpp +++ modularize/CoverageChecker.cpp @@ -51,9 +51,9 @@ // //===----------------------------------------------------------------------===// +#include "CoverageChecker.h" #include "ModularizeUtilities.h" #include "clang/AST/ASTConsumer.h" -#include "CoverageChecker.h" #include "clang/AST/ASTContext.h" #include "clang/AST/RecursiveASTVisitor.h" #include "clang/Basic/SourceManager.h" @@ -115,9 +115,9 @@ protected: std::unique_ptr CreateASTConsumer(CompilerInstance &CI, - StringRef InFile) override { + StringRef InFile) override { return llvm::make_unique(Checker, - CI.getPreprocessor()); + CI.getPreprocessor()); } private: @@ -127,7 +127,7 @@ class CoverageCheckerFrontendActionFactory : public FrontendActionFactory { public: CoverageCheckerFrontendActionFactory(CoverageChecker &Checker) - : Checker(Checker) {} + : Checker(Checker) {} CoverageCheckerAction *create() override { return new CoverageCheckerAction(Checker); @@ -141,21 +141,20 @@ // Constructor. CoverageChecker::CoverageChecker(StringRef ModuleMapPath, - std::vector &IncludePaths, - ArrayRef CommandLine, - clang::ModuleMap *ModuleMap) - : ModuleMapPath(ModuleMapPath), IncludePaths(IncludePaths), - CommandLine(CommandLine), - ModMap(ModuleMap) {} + std::vector &IncludePaths, + ArrayRef CommandLine, + clang::ModuleMap *ModuleMap) + : ModuleMapPath(ModuleMapPath), IncludePaths(IncludePaths), + CommandLine(CommandLine), ModMap(ModuleMap) {} // Create instance of CoverageChecker, to simplify setting up // subordinate objects. CoverageChecker *CoverageChecker::createCoverageChecker( - StringRef ModuleMapPath, std::vector &IncludePaths, - ArrayRef CommandLine, clang::ModuleMap *ModuleMap) { + StringRef ModuleMapPath, std::vector &IncludePaths, + ArrayRef CommandLine, clang::ModuleMap *ModuleMap) { return new CoverageChecker(ModuleMapPath, IncludePaths, CommandLine, - ModuleMap); + ModuleMap); } // Do checks. @@ -194,8 +193,8 @@ // ModuleMapHeadersSet. void CoverageChecker::collectModuleHeaders() { for (ModuleMap::module_iterator I = ModMap->module_begin(), - E = ModMap->module_end(); - I != E; ++I) { + E = ModMap->module_end(); + I != E; ++I) { collectModuleHeaders(*I->second); } } @@ -208,13 +207,12 @@ if (const FileEntry *UmbrellaHeader = Mod.getUmbrellaHeader().Entry) { // Collect umbrella header. - ModuleMapHeadersSet.insert(ModularizeUtilities::getCanonicalPath( - UmbrellaHeader->getName())); + ModuleMapHeadersSet.insert( + ModularizeUtilities::getCanonicalPath(UmbrellaHeader->getName())); // Preprocess umbrella header and collect the headers it references. if (!collectUmbrellaHeaderHeaders(UmbrellaHeader->getName())) return false; - } - else if (const DirectoryEntry *UmbrellaDir = Mod.getUmbrellaDir().Entry) { + } else if (const DirectoryEntry *UmbrellaDir = Mod.getUmbrellaDir().Entry) { // Collect headers in umbrella directory. if (!collectUmbrellaHeaders(UmbrellaDir->getName())) return false; @@ -222,12 +220,12 @@ for (auto &HeaderKind : Mod.Headers) for (auto &Header : HeaderKind) - ModuleMapHeadersSet.insert(ModularizeUtilities::getCanonicalPath( - Header.Entry->getName())); + ModuleMapHeadersSet.insert( + ModularizeUtilities::getCanonicalPath(Header.Entry->getName())); for (Module::submodule_const_iterator MI = Mod.submodule_begin(), - MIEnd = Mod.submodule_end(); - MI != MIEnd; ++MI) + MIEnd = Mod.submodule_end(); + MI != MIEnd; ++MI) collectModuleHeaders(**MI); return true; @@ -245,7 +243,7 @@ std::error_code EC; sys::fs::file_status Status; for (sys::fs::directory_iterator I(Directory.str(), EC), E; I != E; - I.increment(EC)) { + I.increment(EC)) { if (EC) return false; std::string File(I->path()); @@ -267,8 +265,8 @@ } // Collect headers rferenced from an umbrella file. -bool -CoverageChecker::collectUmbrellaHeaderHeaders(StringRef UmbrellaHeaderName) { +bool CoverageChecker::collectUmbrellaHeaderHeaders( + StringRef UmbrellaHeaderName) { SmallString<256> PathBuf(ModuleMapDirectory); @@ -324,13 +322,12 @@ if (IncludePaths.size() == 0) { if (!collectFileSystemHeaders(StringRef(""))) return false; - } - else { + } else { // Otherwise we only look at the sub-trees specified by the // include paths. for (std::vector::const_iterator I = IncludePaths.begin(), - E = IncludePaths.end(); - I != E; ++I) { + E = IncludePaths.end(); + I != E; ++I) { if (!collectFileSystemHeaders(*I)) return false; } @@ -356,9 +353,9 @@ if (Directory.size() == 0) Directory = "."; if (IncludePath.startswith("/") || IncludePath.startswith("\\") || - ((IncludePath.size() >= 2) && (IncludePath[1] == ':'))) { + ((IncludePath.size() >= 2) && (IncludePath[1] == ':'))) { llvm::errs() << "error: Include path \"" << IncludePath - << "\" is not relative to the module map file.\n"; + << "\" is not relative to the module map file.\n"; return false; } @@ -367,10 +364,10 @@ sys::fs::file_status Status; int Count = 0; for (sys::fs::recursive_directory_iterator I(Directory.str(), EC), E; I != E; - I.increment(EC)) { + I.increment(EC)) { if (EC) return false; - //std::string file(I->path()); + // std::string file(I->path()); StringRef file(I->path()); I->status(Status); sys::fs::file_type type = Status.type(); @@ -391,7 +388,7 @@ } if (Count == 0) { llvm::errs() << "warning: No headers found in include path: \"" - << IncludePath << "\"\n"; + << IncludePath << "\"\n"; } return true; } @@ -409,13 +406,13 @@ void CoverageChecker::findUnaccountedForHeaders() { // Walk over file system headers. for (std::vector::const_iterator I = FileSystemHeaders.begin(), - E = FileSystemHeaders.end(); - I != E; ++I) { + E = FileSystemHeaders.end(); + I != E; ++I) { // Look for header in module map. if (ModuleMapHeadersSet.insert(*I).second) { UnaccountedForHeaders.push_back(*I); llvm::errs() << "warning: " << ModuleMapPath - << " does not account for file: " << *I << "\n"; + << " does not account for file: " << *I << "\n"; } } } Index: modularize/Modularize.cpp =================================================================== --- modularize/Modularize.cpp +++ modularize/Modularize.cpp @@ -290,45 +290,42 @@ // Option to specify list of problem files for assistant. // This will cause assistant to exclude these files. static cl::opt ProblemFilesList( - "problem-files-list", cl::init(""), - cl::desc( - "List of files with compilation or modularization problems for" - " assistant mode. This will be excluded.")); + "problem-files-list", cl::init(""), + cl::desc("List of files with compilation or modularization problems for" + " assistant mode. This will be excluded.")); // Option for assistant mode, telling modularize the name of the root module. static cl::opt -RootModule("root-module", cl::init(""), - cl::desc("Specify the name of the root module.")); + RootModule("root-module", cl::init(""), + cl::desc("Specify the name of the root module.")); // Option for limiting the #include-inside-extern-or-namespace-block // check to only those headers explicitly listed in the header list. // This is a work-around for private includes that purposefully get // included inside blocks. -static cl::opt -BlockCheckHeaderListOnly("block-check-header-list-only", cl::init(false), -cl::desc("Only warn if #include directives are inside extern or namespace" - " blocks if the included header is in the header list.")); +static cl::opt BlockCheckHeaderListOnly( + "block-check-header-list-only", cl::init(false), + cl::desc("Only warn if #include directives are inside extern or namespace" + " blocks if the included header is in the header list.")); // Option for include paths for coverage check. static cl::list -IncludePaths("I", cl::desc("Include path for coverage check."), -cl::ZeroOrMore, cl::value_desc("path")); + IncludePaths("I", cl::desc("Include path for coverage check."), + cl::ZeroOrMore, cl::value_desc("path")); // Option for disabling the coverage check. -static cl::opt -NoCoverageCheck("no-coverage-check", cl::init(false), -cl::desc("Don't do the coverage check.")); +static cl::opt NoCoverageCheck("no-coverage-check", cl::init(false), + cl::desc("Don't do the coverage check.")); // Option for just doing the coverage check. -static cl::opt -CoverageCheckOnly("coverage-check-only", cl::init(false), -cl::desc("Only do the coverage check.")); +static cl::opt CoverageCheckOnly("coverage-check-only", cl::init(false), + cl::desc("Only do the coverage check.")); // Option for displaying lists of good, bad, and mixed files. -static cl::opt -DisplayFileLists("display-file-lists", cl::init(false), -cl::desc("Display lists of good files (no compile errors), problem files," - " and a combined list with problem files preceded by a '#'.")); +static cl::opt DisplayFileLists( + "display-file-lists", cl::init(false), + cl::desc("Display lists of good files (no compile errors), problem files," + " and a combined list with problem files preceded by a '#'.")); // Save the program name for error messages. const char *Argv0; @@ -356,28 +353,28 @@ // if no other "-x" option is present. static ArgumentsAdjuster getModularizeArgumentsAdjuster(DependencyMap &Dependencies) { - return [&Dependencies](const CommandLineArguments &Args, - StringRef /*unused*/) { - std::string InputFile = findInputFile(Args); - DependentsVector &FileDependents = Dependencies[InputFile]; - CommandLineArguments NewArgs(Args); - if (int Count = FileDependents.size()) { - for (int Index = 0; Index < Count; ++Index) { - NewArgs.push_back("-include"); - std::string File(std::string("\"") + FileDependents[Index] + - std::string("\"")); - NewArgs.push_back(FileDependents[Index]); - } - } - // Ignore warnings. (Insert after "clang_tool" at beginning.) - NewArgs.insert(NewArgs.begin() + 1, "-w"); - // Since we are compiling .h files, assume C++ unless given a -x option. - if (std::find(NewArgs.begin(), NewArgs.end(), "-x") == NewArgs.end()) { - NewArgs.insert(NewArgs.begin() + 2, "-x"); - NewArgs.insert(NewArgs.begin() + 3, "c++"); - } - return NewArgs; - }; + return + [&Dependencies](const CommandLineArguments &Args, StringRef /*unused*/) { + std::string InputFile = findInputFile(Args); + DependentsVector &FileDependents = Dependencies[InputFile]; + CommandLineArguments NewArgs(Args); + if (int Count = FileDependents.size()) { + for (int Index = 0; Index < Count; ++Index) { + NewArgs.push_back("-include"); + std::string File(std::string("\"") + FileDependents[Index] + + std::string("\"")); + NewArgs.push_back(FileDependents[Index]); + } + } + // Ignore warnings. (Insert after "clang_tool" at beginning.) + NewArgs.insert(NewArgs.begin() + 1, "-w"); + // Since we are compiling .h files, assume C++ unless given a -x option. + if (std::find(NewArgs.begin(), NewArgs.end(), "-x") == NewArgs.end()) { + NewArgs.insert(NewArgs.begin() + 2, "-x"); + NewArgs.insert(NewArgs.begin() + 3, "c++"); + } + return NewArgs; + }; } // FIXME: The Location class seems to be something that we might @@ -485,13 +482,13 @@ typedef std::vector HeaderContents; -class EntityMap : public StringMap > { +class EntityMap : public StringMap> { public: DenseMap HeaderContentMismatches; void add(const std::string &Name, enum Entry::EntryKind Kind, Location Loc) { // Record this entity in its header. - HeaderEntry HE = { Name, Loc }; + HeaderEntry HE = {Name, Loc}; CurHeaderContents[Loc.File].push_back(HE); // Check whether we've seen this entry before. @@ -502,7 +499,7 @@ } // We have not seen this entry before; record it. - Entry E = { Kind, Loc }; + Entry E = {Kind, Loc}; Entries.push_back(E); } @@ -734,8 +731,7 @@ int &HadErrors; }; -class CompileCheckVisitor - : public RecursiveASTVisitor { +class CompileCheckVisitor : public RecursiveASTVisitor { public: CompileCheckVisitor() {} @@ -755,7 +751,7 @@ return true; } bool TraverseTemplateArguments(const TemplateArgument *Args, - unsigned NumArgs) { + unsigned NumArgs) { return true; } bool TraverseConstructorInitializer(CXXCtorInitializer *Init) { return true; } @@ -765,19 +761,13 @@ } // Check 'extern "*" {}' block for #include directives. - bool VisitLinkageSpecDecl(LinkageSpecDecl *D) { - return true; - } + bool VisitLinkageSpecDecl(LinkageSpecDecl *D) { return true; } // Check 'namespace (name) {}' block for #include directives. - bool VisitNamespaceDecl(const NamespaceDecl *D) { - return true; - } + bool VisitNamespaceDecl(const NamespaceDecl *D) { return true; } // Collect definition entities. - bool VisitNamedDecl(NamedDecl *ND) { - return true; - } + bool VisitNamedDecl(NamedDecl *ND) { return true; } }; class CompileCheckConsumer : public ASTConsumer { @@ -795,7 +785,7 @@ protected: std::unique_ptr - CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override { + CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override { return llvm::make_unique(); } }; @@ -804,9 +794,7 @@ public: CompileCheckFrontendActionFactory() {} - CompileCheckAction *create() override { - return new CompileCheckAction(); - } + CompileCheckAction *create() override { return new CompileCheckAction(); } }; int main(int Argc, const char **Argv) { @@ -833,8 +821,7 @@ std::unique_ptr ModUtil; int HadErrors = 0; - ModUtil.reset( - ModularizeUtilities::createModularizeUtilities( + ModUtil.reset(ModularizeUtilities::createModularizeUtilities( ListFileNames, HeaderPrefix, ProblemFilesList)); // Get header file names and dependencies. @@ -844,8 +831,8 @@ // If we are in assistant mode, output the module map and quit. if (ModuleMapPath.length() != 0) { if (!createModuleMap(ModuleMapPath, ModUtil->HeaderFileNames, - ModUtil->ProblemFileNames, - ModUtil->Dependencies, HeaderPrefix, RootModule)) + ModUtil->ProblemFileNames, ModUtil->Dependencies, + HeaderPrefix, RootModule)) return 1; // Failed. return 0; // Success - Skip checks in assistant mode. } @@ -869,9 +856,8 @@ new FixedCompilationDatabase(Twine(PathBuf), CC1Arguments)); // Create preprocessor tracker, to watch for macro and conditional problems. - std::unique_ptr PPTracker( - PreprocessorTracker::create(ModUtil->HeaderFileNames, - BlockCheckHeaderListOnly)); + std::unique_ptr PPTracker(PreprocessorTracker::create( + ModUtil->HeaderFileNames, BlockCheckHeaderListOnly)); // Coolect entities here. EntityMap Entities; @@ -887,24 +873,23 @@ CompileCheckFileArray.push_back(CompileCheckFile); ClangTool CompileCheckTool(*Compilations, CompileCheckFileArray); CompileCheckTool.appendArgumentsAdjuster( - getModularizeArgumentsAdjuster(ModUtil->Dependencies)); + getModularizeArgumentsAdjuster(ModUtil->Dependencies)); int CompileCheckFileErrors = 0; CompileCheckFrontendActionFactory CompileCheckFactory; CompileCheckFileErrors |= CompileCheckTool.run(&CompileCheckFactory); if (CompileCheckFileErrors != 0) { - ModUtil->addUniqueProblemFile(CompileCheckFile); // Save problem file. + ModUtil->addUniqueProblemFile(CompileCheckFile); // Save problem file. HadErrors |= 1; - } - else + } else ModUtil->addNoCompileErrorsFile(CompileCheckFile); // Save good file. } } // Then we make another pass on the good files to do the rest of the work. - ClangTool Tool(*Compilations, - (DisplayFileLists ? ModUtil->GoodFileNames : ModUtil->HeaderFileNames)); + ClangTool Tool(*Compilations, (DisplayFileLists ? ModUtil->GoodFileNames + : ModUtil->HeaderFileNames)); Tool.appendArgumentsAdjuster( - getModularizeArgumentsAdjuster(ModUtil->Dependencies)); + getModularizeArgumentsAdjuster(ModUtil->Dependencies)); ModularizeFrontendActionFactory Factory(Entities, *PPTracker, HadErrors); HadErrors |= Tool.run(&Factory); @@ -939,7 +924,8 @@ for (EntryBinArray::iterator DI = EntryBins.begin(), DE = EntryBins.end(); DI != DE; ++DI, ++KindIndex) { int ECount = DI->size(); - // If only 1 occurrence of this entity, skip it, we only report duplicates. + // If only 1 occurrence of this entity, skip it, we only report + // duplicates. if (ECount <= 1) continue; LocationArray::iterator FI = DI->begin(); Index: modularize/ModularizeUtilities.h =================================================================== --- modularize/ModularizeUtilities.h +++ modularize/ModularizeUtilities.h @@ -79,10 +79,10 @@ /// \param Prefix The headear path prefix. /// \param ProblemFilesListPath The problem header list path. /// \returns Initialized ModularizeUtilities object. - static ModularizeUtilities *createModularizeUtilities( - std::vector &InputPaths, - llvm::StringRef Prefix, - llvm::StringRef ProblemFilesListPath); + static ModularizeUtilities * + createModularizeUtilities(std::vector &InputPaths, + llvm::StringRef Prefix, + llvm::StringRef ProblemFilesListPath); /// Load header list and dependencies. /// \returns std::error_code. @@ -128,24 +128,21 @@ // Internal. protected: - /// Load single header list and dependencies. /// \param InputPath The input file path. /// \returns std::error_code. - std::error_code loadSingleHeaderListsAndDependencies( - llvm::StringRef InputPath); + std::error_code + loadSingleHeaderListsAndDependencies(llvm::StringRef InputPath); /// Load problem header list. /// \param InputPath The input file path. /// \returns std::error_code. - std::error_code loadProblemHeaderList( - llvm::StringRef InputPath); + std::error_code loadProblemHeaderList(llvm::StringRef InputPath); /// Load single module map and extract header file list. /// \param InputPath The input file path. /// \returns std::error_code. - std::error_code loadModuleMap( - llvm::StringRef InputPath); + std::error_code loadModuleMap(llvm::StringRef InputPath); /// Collect module Map headers. /// Walks the modules and collects referenced headers into @@ -165,10 +162,9 @@ /// \param UmbrellaDirName The umbrella directory name. /// \return True if no errors. bool collectUmbrellaHeaders(llvm::StringRef UmbrellaDirName, - DependentsVector &Dependents); + DependentsVector &Dependents); public: - // Utility functions. /// Convert header path to canonical form. Index: modularize/ModularizeUtilities.cpp =================================================================== --- modularize/ModularizeUtilities.cpp +++ modularize/ModularizeUtilities.cpp @@ -13,17 +13,17 @@ // //===----------------------------------------------------------------------===// +#include "ModularizeUtilities.h" +#include "CoverageChecker.h" #include "clang/Basic/SourceManager.h" #include "clang/Driver/Options.h" #include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/FrontendActions.h" -#include "CoverageChecker.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/FileUtilities.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Path.h" #include "llvm/Support/raw_ostream.h" -#include "ModularizeUtilities.h" using namespace clang; using namespace llvm; @@ -44,25 +44,22 @@ ModularizeUtilities::ModularizeUtilities(std::vector &InputPaths, llvm::StringRef Prefix, llvm::StringRef ProblemFilesListPath) - : InputFilePaths(InputPaths), - HeaderPrefix(Prefix), - ProblemFilesPath(ProblemFilesListPath), - HasModuleMap(false), - MissingHeaderCount(0), - // Init clang stuff needed for loading the module map and preprocessing. - LangOpts(new LangOptions()), DiagIDs(new DiagnosticIDs()), - DiagnosticOpts(new DiagnosticOptions()), - DC(llvm::errs(), DiagnosticOpts.get()), - Diagnostics( - new DiagnosticsEngine(DiagIDs, DiagnosticOpts.get(), &DC, false)), - TargetOpts(new ModuleMapTargetOptions()), - Target(TargetInfo::CreateTargetInfo(*Diagnostics, TargetOpts)), - FileMgr(new FileManager(FileSystemOpts)), - SourceMgr(new SourceManager(*Diagnostics, *FileMgr, false)), - HeaderSearchOpts(new HeaderSearchOptions()), - HeaderInfo(new HeaderSearch(HeaderSearchOpts, *SourceMgr, *Diagnostics, - *LangOpts, Target.get())) { -} + : InputFilePaths(InputPaths), HeaderPrefix(Prefix), + ProblemFilesPath(ProblemFilesListPath), HasModuleMap(false), + MissingHeaderCount(0), + // Init clang stuff needed for loading the module map and preprocessing. + LangOpts(new LangOptions()), DiagIDs(new DiagnosticIDs()), + DiagnosticOpts(new DiagnosticOptions()), + DC(llvm::errs(), DiagnosticOpts.get()), + Diagnostics( + new DiagnosticsEngine(DiagIDs, DiagnosticOpts.get(), &DC, false)), + TargetOpts(new ModuleMapTargetOptions()), + Target(TargetInfo::CreateTargetInfo(*Diagnostics, TargetOpts)), + FileMgr(new FileManager(FileSystemOpts)), + SourceMgr(new SourceManager(*Diagnostics, *FileMgr, false)), + HeaderSearchOpts(new HeaderSearchOptions()), + HeaderInfo(new HeaderSearch(HeaderSearchOpts, *SourceMgr, *Diagnostics, + *LangOpts, Target.get())) {} // Create instance of ModularizeUtilities, to simplify setting up // subordinate objects. @@ -84,12 +81,12 @@ // Load the module map. if (std::error_code EC = loadModuleMap(InputPath)) return EC; - } - else { + } else { // Else we assume it's a header list and load it. - if (std::error_code EC = loadSingleHeaderListsAndDependencies(InputPath)) { + if (std::error_code EC = + loadSingleHeaderListsAndDependencies(InputPath)) { errs() << "modularize: error: Unable to get header list '" << InputPath - << "': " << EC.message() << '\n'; + << "': " << EC.message() << '\n'; return EC; } } @@ -98,8 +95,8 @@ if (ProblemFilesPath.size() != 0) { // Load problem files list. if (std::error_code EC = loadProblemHeaderList(ProblemFilesPath)) { - errs() << "modularize: error: Unable to get problem header list '" << ProblemFilesPath - << "': " << EC.message() << '\n'; + errs() << "modularize: error: Unable to get problem header list '" + << ProblemFilesPath << "': " << EC.message() << '\n'; return EC; } } @@ -116,16 +113,17 @@ // Returns 0 if there were no errors or warnings, 1 if there // were warnings, 2 if any other problem, such as a bad // module map path argument was specified. -std::error_code ModularizeUtilities::doCoverageCheck( - std::vector &IncludePaths, - llvm::ArrayRef CommandLine) { +std::error_code +ModularizeUtilities::doCoverageCheck(std::vector &IncludePaths, + llvm::ArrayRef CommandLine) { int ModuleMapCount = ModuleMaps.size(); int ModuleMapIndex; std::error_code EC; for (ModuleMapIndex = 0; ModuleMapIndex < ModuleMapCount; ++ModuleMapIndex) { std::unique_ptr &ModMap = ModuleMaps[ModuleMapIndex]; CoverageChecker *Checker = CoverageChecker::createCoverageChecker( - InputFilePaths[ModuleMapIndex], IncludePaths, CommandLine, ModMap.get()); + InputFilePaths[ModuleMapIndex], IncludePaths, CommandLine, + ModMap.get()); std::error_code LocalEC = Checker->doChecks(); if (LocalEC.value() > 0) EC = LocalEC; @@ -149,7 +147,7 @@ // Read the header list file into a buffer. ErrorOr> listBuffer = - MemoryBuffer::getFile(InputPath); + MemoryBuffer::getFile(InputPath); if (std::error_code EC = listBuffer.getError()) return EC; @@ -159,8 +157,8 @@ // Collect the header file names from the string list. for (SmallVectorImpl::iterator I = Strings.begin(), - E = Strings.end(); - I != E; ++I) { + E = Strings.end(); + I != E; ++I) { StringRef Line = I->trim(); // Ignore comments and empty lines. if (Line.empty() || (Line[0] == '#')) @@ -207,8 +205,8 @@ } // Load problem header list. -std::error_code ModularizeUtilities::loadProblemHeaderList( - llvm::StringRef InputPath) { +std::error_code +ModularizeUtilities::loadProblemHeaderList(llvm::StringRef InputPath) { // By default, use the path component of the list file name. SmallString<256> HeaderDirectory(InputPath); @@ -222,7 +220,7 @@ // Read the header list file into a buffer. ErrorOr> listBuffer = - MemoryBuffer::getFile(InputPath); + MemoryBuffer::getFile(InputPath); if (std::error_code EC = listBuffer.getError()) return EC; @@ -232,8 +230,8 @@ // Collect the header file names from the string list. for (SmallVectorImpl::iterator I = Strings.begin(), - E = Strings.end(); - I != E; ++I) { + E = Strings.end(); + I != E; ++I) { StringRef Line = I->trim(); // Ignore comments and empty lines. if (Line.empty() || (Line[0] == '#')) @@ -259,11 +257,10 @@ } // Load single module map and extract header file list. -std::error_code ModularizeUtilities::loadModuleMap( - llvm::StringRef InputPath) { +std::error_code ModularizeUtilities::loadModuleMap(llvm::StringRef InputPath) { // Get file entry for module.modulemap file. const FileEntry *ModuleMapEntry = - SourceMgr->getFileManager().getFile(InputPath); + SourceMgr->getFileManager().getFile(InputPath); // return error if not found. if (!ModuleMapEntry) { @@ -288,8 +285,8 @@ } std::unique_ptr ModMap; - ModMap.reset(new ModuleMap(*SourceMgr, *Diagnostics, *LangOpts, - Target.get(), *HeaderInfo)); + ModMap.reset(new ModuleMap(*SourceMgr, *Diagnostics, *LangOpts, Target.get(), + *HeaderInfo)); // Parse module.modulemap file into module map. if (ModMap->parseModuleMapFile(ModuleMapEntry, false, Dir)) { @@ -323,8 +320,8 @@ // HeaderFileNames. bool ModularizeUtilities::collectModuleMapHeaders(clang::ModuleMap *ModMap) { for (ModuleMap::module_iterator I = ModMap->module_begin(), - E = ModMap->module_end(); - I != E; ++I) { + E = ModMap->module_end(); + I != E; ++I) { if (!collectModuleHeaders(*I->second)) return false; } @@ -346,8 +343,8 @@ // Recursively do submodules. for (clang::Module::submodule_const_iterator MI = Mod.submodule_begin(), - MIEnd = Mod.submodule_end(); - MI != MIEnd; ++MI) + MIEnd = Mod.submodule_end(); + MI != MIEnd; ++MI) collectModuleHeaders(**MI); if (const FileEntry *UmbrellaHeader = Mod.getUmbrellaHeader().Entry) { @@ -356,8 +353,7 @@ HeaderFileNames.push_back(HeaderPath); // FUTURE: When needed, umbrella header header collection goes here. - } - else if (const DirectoryEntry *UmbrellaDir = Mod.getUmbrellaDir().Entry) { + } else if (const DirectoryEntry *UmbrellaDir = Mod.getUmbrellaDir().Entry) { // If there normal headers, assume these are umbrellas and skip collection. if (Mod.Headers->size() == 0) { // Collect headers in umbrella directory. @@ -377,7 +373,7 @@ DependentsVector NormalDependents; // Collect normal header. const clang::Module::Header &Header( - Mod.Headers[clang::Module::HK_Normal][Index]); + Mod.Headers[clang::Module::HK_Normal][Index]); std::string HeaderPath = getCanonicalPath(Header.Entry->getName()); HeaderFileNames.push_back(HeaderPath); } @@ -388,7 +384,7 @@ std::string MissingFile = Mod.MissingHeaders[Index].FileName; SourceLocation Loc = Mod.MissingHeaders[Index].FileNameLoc; errs() << Loc.printToString(*SourceMgr) - << ": error : Header not found: " << MissingFile << "\n"; + << ": error : Header not found: " << MissingFile << "\n"; } MissingHeaderCount += MissingCountThisModule; @@ -398,14 +394,14 @@ // Collect headers from an umbrella directory. bool ModularizeUtilities::collectUmbrellaHeaders(StringRef UmbrellaDirName, - DependentsVector &Dependents) { + DependentsVector &Dependents) { // Initialize directory name. SmallString<256> Directory(UmbrellaDirName); // Walk the directory. std::error_code EC; llvm::sys::fs::file_status Status; for (llvm::sys::fs::directory_iterator I(Directory.str(), EC), E; I != E; - I.increment(EC)) { + I.increment(EC)) { if (EC) return false; std::string File(I->path()); @@ -432,11 +428,10 @@ static std::string replaceDotDot(StringRef Path) { SmallString<128> Buffer; llvm::sys::path::const_iterator B = llvm::sys::path::begin(Path), - E = llvm::sys::path::end(Path); + E = llvm::sys::path::end(Path); while (B != E) { if (B->compare(".") == 0) { - } - else if (B->compare("..") == 0) + } else if (B->compare("..") == 0) llvm::sys::path::remove_filename(Buffer); else llvm::sys::path::append(Buffer, *B); @@ -494,7 +489,7 @@ void ModularizeUtilities::addUniqueProblemFile(std::string FilePath) { FilePath = getCanonicalPath(FilePath); // Don't add if already present. - for(auto &TestFilePath : ProblemFileNames) { + for (auto &TestFilePath : ProblemFileNames) { if (TestFilePath == FilePath) return; } @@ -534,8 +529,8 @@ // List files with problem files commented out. void ModularizeUtilities::displayCombinedFiles() { - errs() << - "\nThese are the combined files, with problem files preceded by #:\n\n"; + errs() << "\nThese are the combined files, with problem files preceded by " + "#:\n\n"; for (auto &File : HeaderFileNames) { bool Good = true; for (auto &ProblemFile : ProblemFileNames) { Index: modularize/ModuleAssistant.cpp =================================================================== --- modularize/ModuleAssistant.cpp +++ modularize/ModuleAssistant.cpp @@ -64,7 +64,7 @@ // Constructors. Module::Module(llvm::StringRef Name, bool Problem) - : Name(Name), IsProblem(Problem) {} + : Name(Name), IsProblem(Problem) {} Module::Module() : IsProblem(false) {} // Destructor. @@ -138,9 +138,9 @@ // Keep in sync with keywords in module map parser in Lex/ModuleMap.cpp, // such as in ModuleMapParser::consumeToken(). static const char *const ReservedNames[] = { - "config_macros", "export", "module", "conflict", "framework", - "requires", "exclude", "header", "private", "explicit", - "link", "umbrella", "extern", "use", nullptr // Flag end. + "config_macros", "export", "module", "conflict", "framework", + "requires", "exclude", "header", "private", "explicit", + "link", "umbrella", "extern", "use", nullptr // Flag end. }; // Convert module name to a non-keyword. @@ -159,8 +159,7 @@ // Convert module name to a non-keyword. // Prepends a '_' to the name if and only if the name is a keyword. -static std::string -ensureVaidModuleName(llvm::StringRef MightBeInvalidName) { +static std::string ensureVaidModuleName(llvm::StringRef MightBeInvalidName) { std::string SafeName = MightBeInvalidName; std::replace(SafeName.begin(), SafeName.end(), '-', '_'); std::replace(SafeName.begin(), SafeName.end(), '.', '_'); @@ -223,8 +222,8 @@ // Create the internal module tree representation. static Module *loadModuleDescriptions( llvm::StringRef RootModuleName, llvm::ArrayRef HeaderFileNames, - llvm::ArrayRef ProblemFileNames, - DependencyMap &Dependencies, llvm::StringRef HeaderPrefix) { + llvm::ArrayRef ProblemFileNames, DependencyMap &Dependencies, + llvm::StringRef HeaderPrefix) { // Create root module. Module *RootModule = new Module(RootModuleName, false); @@ -249,7 +248,8 @@ } } // Add as a module. - if (!addModuleDescription(RootModule, Header, HeaderPrefix, Dependencies, IsProblemFile)) + if (!addModuleDescription(RootModule, Header, HeaderPrefix, Dependencies, + IsProblemFile)) return nullptr; } @@ -310,9 +310,8 @@ llvm::StringRef RootModuleName) { // Load internal representation of modules. std::unique_ptr RootModule( - loadModuleDescriptions( - RootModuleName, HeaderFileNames, ProblemFileNames, Dependencies, - HeaderPrefix)); + loadModuleDescriptions(RootModuleName, HeaderFileNames, ProblemFileNames, + Dependencies, HeaderPrefix)); if (!RootModule.get()) return false; Index: modularize/PreprocessorTracker.h =================================================================== --- modularize/PreprocessorTracker.h +++ modularize/PreprocessorTracker.h @@ -77,9 +77,9 @@ virtual bool reportInconsistentConditionals(llvm::raw_ostream &OS) = 0; // Create instance of PreprocessorTracker. - static PreprocessorTracker *create( - llvm::SmallVector &Headers, - bool DoBlockCheckHeaderListOnly); + static PreprocessorTracker * + create(llvm::SmallVector &Headers, + bool DoBlockCheckHeaderListOnly); }; } // end namespace Modularize Index: modularize/PreprocessorTracker.cpp =================================================================== --- modularize/PreprocessorTracker.cpp +++ modularize/PreprocessorTracker.cpp @@ -244,14 +244,14 @@ // //===--------------------------------------------------------------------===// -#include "clang/Lex/LexDiagnostic.h" #include "PreprocessorTracker.h" +#include "ModularizeUtilities.h" +#include "clang/Lex/LexDiagnostic.h" #include "clang/Lex/MacroArgs.h" #include "clang/Lex/PPCallbacks.h" #include "llvm/ADT/SmallSet.h" #include "llvm/Support/StringPool.h" #include "llvm/Support/raw_ostream.h" -#include "ModularizeUtilities.h" namespace Modularize { @@ -429,7 +429,7 @@ const clang::Token *ArgTok = Args->getUnexpArgument(ArgNo); if (Args->ArgNeedsPreexpansion(ArgTok, PP)) ResultArgToks = &(const_cast(Args)) - ->getPreExpArgument(ArgNo, MI, PP)[0]; + ->getPreExpArgument(ArgNo, MI, PP)[0]; else ResultArgToks = ArgTok; // Use non-preexpanded Tokens. // If the arg token didn't expand into anything, ignore it. @@ -459,10 +459,7 @@ namespace { // ConditionValueKind strings. -const char * -ConditionValueKindStrings[] = { - "(not evaluated)", "false", "true" -}; +const char *ConditionValueKindStrings[] = {"(not evaluated)", "false", "true"}; bool operator<(const StringHandle &H1, const StringHandle &H2) { const char *S1 = (H1 ? *H1 : ""); @@ -650,7 +647,9 @@ // for use in telling the user the nested include path to the header. class ConditionalExpansionInstance { public: - ConditionalExpansionInstance(clang::PPCallbacks::ConditionValueKind ConditionValue, InclusionPathHandle H) + ConditionalExpansionInstance( + clang::PPCallbacks::ConditionValueKind ConditionValue, + InclusionPathHandle H) : ConditionValue(ConditionValue) { InclusionPathHandles.push_back(H); } @@ -699,8 +698,8 @@ ConditionalTracker() {} // Find a matching condition expansion instance. - ConditionalExpansionInstance * - findConditionalExpansionInstance(clang::PPCallbacks::ConditionValueKind ConditionValue) { + ConditionalExpansionInstance *findConditionalExpansionInstance( + clang::PPCallbacks::ConditionValueKind ConditionValue) { for (std::vector::iterator I = ConditionalExpansionInstances.begin(), E = ConditionalExpansionInstances.end(); @@ -713,9 +712,9 @@ } // Add a conditional expansion instance. - void - addConditionalExpansionInstance(clang::PPCallbacks::ConditionValueKind ConditionValue, - InclusionPathHandle InclusionPathHandle) { + void addConditionalExpansionInstance( + clang::PPCallbacks::ConditionValueKind ConditionValue, + InclusionPathHandle InclusionPathHandle) { ConditionalExpansionInstances.push_back( ConditionalExpansionInstance(ConditionValue, InclusionPathHandle)); } @@ -786,12 +785,12 @@ // Preprocessor macro expansion item map types. typedef std::map MacroExpansionMap; typedef std::map::iterator -MacroExpansionMapIter; + MacroExpansionMapIter; // Preprocessor conditional expansion item map types. typedef std::map ConditionalExpansionMap; typedef std::map::iterator -ConditionalExpansionMapIter; + ConditionalExpansionMapIter; // Preprocessor tracker for modularize. // @@ -800,14 +799,14 @@ class PreprocessorTrackerImpl : public PreprocessorTracker { public: PreprocessorTrackerImpl(llvm::SmallVector &Headers, - bool DoBlockCheckHeaderListOnly) + bool DoBlockCheckHeaderListOnly) : BlockCheckHeaderListOnly(DoBlockCheckHeaderListOnly), CurrentInclusionPathHandle(InclusionPathHandleInvalid), InNestedHeader(false) { // Use canonical header path representation. for (llvm::ArrayRef::iterator I = Headers.begin(), - E = Headers.end(); - I != E; ++I) { + E = Headers.end(); + I != E; ++I) { HeaderList.push_back(getCanonicalPath(*I)); } } @@ -820,8 +819,8 @@ HeadersInThisCompile.clear(); assert((HeaderStack.size() == 0) && "Header stack should be empty."); pushHeaderHandle(addHeader(rootHeaderFile)); - PP.addPPCallbacks(llvm::make_unique(*this, PP, - rootHeaderFile)); + PP.addPPCallbacks( + llvm::make_unique(*this, PP, rootHeaderFile)); } // Handle exiting a preprocessing session. void handlePreprocessorExit() override { HeaderStack.clear(); } @@ -941,8 +940,8 @@ bool isHeaderListHeader(llvm::StringRef HeaderPath) const { std::string CanonicalPath = getCanonicalPath(HeaderPath); for (llvm::ArrayRef::iterator I = HeaderList.begin(), - E = HeaderList.end(); - I != E; ++I) { + E = HeaderList.end(); + I != E; ++I) { if (*I == CanonicalPath) return true; } @@ -1101,13 +1100,13 @@ } // Add a conditional expansion instance. - void - addConditionalExpansionInstance(clang::Preprocessor &PP, HeaderHandle H, - clang::SourceLocation InstanceLoc, - clang::tok::PPKeywordKind DirectiveKind, - clang::PPCallbacks::ConditionValueKind ConditionValue, - llvm::StringRef ConditionUnexpanded, - InclusionPathHandle InclusionPathHandle) { + void addConditionalExpansionInstance( + clang::Preprocessor &PP, HeaderHandle H, + clang::SourceLocation InstanceLoc, + clang::tok::PPKeywordKind DirectiveKind, + clang::PPCallbacks::ConditionValueKind ConditionValue, + llvm::StringRef ConditionUnexpanded, + InclusionPathHandle InclusionPathHandle) { // Ignore header guards, assuming the header guard is the only conditional. if (InNestedHeader) return; @@ -1291,9 +1290,9 @@ PreprocessorTracker::~PreprocessorTracker() {} // Create instance of PreprocessorTracker. -PreprocessorTracker *PreprocessorTracker::create( - llvm::SmallVector &Headers, - bool DoBlockCheckHeaderListOnly) { +PreprocessorTracker * +PreprocessorTracker::create(llvm::SmallVector &Headers, + bool DoBlockCheckHeaderListOnly) { return new PreprocessorTrackerImpl(Headers, DoBlockCheckHeaderListOnly); } @@ -1366,19 +1365,19 @@ (MI ? "true" : "false"), PPTracker.getCurrentInclusionPathHandle()); } -void PreprocessorCallbacks::If(clang::SourceLocation Loc, - clang::SourceRange ConditionRange, - clang::PPCallbacks::ConditionValueKind ConditionResult) { +void PreprocessorCallbacks::If( + clang::SourceLocation Loc, clang::SourceRange ConditionRange, + clang::PPCallbacks::ConditionValueKind ConditionResult) { std::string Unexpanded(getSourceString(PP, ConditionRange)); PPTracker.addConditionalExpansionInstance( PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_if, ConditionResult, Unexpanded, PPTracker.getCurrentInclusionPathHandle()); } -void PreprocessorCallbacks::Elif(clang::SourceLocation Loc, - clang::SourceRange ConditionRange, - clang::PPCallbacks::ConditionValueKind ConditionResult, - clang::SourceLocation IfLoc) { +void PreprocessorCallbacks::Elif( + clang::SourceLocation Loc, clang::SourceRange ConditionRange, + clang::PPCallbacks::ConditionValueKind ConditionResult, + clang::SourceLocation IfLoc) { std::string Unexpanded(getSourceString(PP, ConditionRange)); PPTracker.addConditionalExpansionInstance( PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_elif, @@ -1389,7 +1388,7 @@ const clang::Token &MacroNameTok, const clang::MacroDefinition &MD) { clang::PPCallbacks::ConditionValueKind IsDefined = - (MD ? clang::PPCallbacks::CVK_True : clang::PPCallbacks::CVK_False ); + (MD ? clang::PPCallbacks::CVK_True : clang::PPCallbacks::CVK_False); PPTracker.addConditionalExpansionInstance( PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_ifdef, IsDefined, PP.getSpelling(MacroNameTok), @@ -1400,7 +1399,7 @@ const clang::Token &MacroNameTok, const clang::MacroDefinition &MD) { clang::PPCallbacks::ConditionValueKind IsNotDefined = - (!MD ? clang::PPCallbacks::CVK_True : clang::PPCallbacks::CVK_False ); + (!MD ? clang::PPCallbacks::CVK_True : clang::PPCallbacks::CVK_False); PPTracker.addConditionalExpansionInstance( PP, PPTracker.getCurrentHeaderHandle(), Loc, clang::tok::pp_ifndef, IsNotDefined, PP.getSpelling(MacroNameTok), Index: pp-trace/PPCallbacksTracker.h =================================================================== --- pp-trace/PPCallbacksTracker.h +++ pp-trace/PPCallbacksTracker.h @@ -142,15 +142,14 @@ void If(clang::SourceLocation Loc, clang::SourceRange ConditionRange, ConditionValueKind ConditionValue) override; void Elif(clang::SourceLocation Loc, clang::SourceRange ConditionRange, - ConditionValueKind ConditionValue, clang::SourceLocation IfLoc) override; + ConditionValueKind ConditionValue, + clang::SourceLocation IfLoc) override; void Ifdef(clang::SourceLocation Loc, const clang::Token &MacroNameTok, const clang::MacroDefinition &MD) override; void Ifndef(clang::SourceLocation Loc, const clang::Token &MacroNameTok, const clang::MacroDefinition &MD) override; - void Else(clang::SourceLocation Loc, - clang::SourceLocation IfLoc) override; - void Endif(clang::SourceLocation Loc, - clang::SourceLocation IfLoc) override; + void Else(clang::SourceLocation Loc, clang::SourceLocation IfLoc) override; + void Endif(clang::SourceLocation Loc, clang::SourceLocation IfLoc) override; // Helper functions. Index: pp-trace/PPCallbacksTracker.cpp =================================================================== --- pp-trace/PPCallbacksTracker.cpp +++ pp-trace/PPCallbacksTracker.cpp @@ -55,37 +55,31 @@ // FileChangeReason strings. static const char *const FileChangeReasonStrings[] = { - "EnterFile", "ExitFile", "SystemHeaderPragma", "RenameFile" -}; + "EnterFile", "ExitFile", "SystemHeaderPragma", "RenameFile"}; // CharacteristicKind strings. -static const char *const CharacteristicKindStrings[] = { "C_User", "C_System", - "C_ExternCSystem" }; +static const char *const CharacteristicKindStrings[] = {"C_User", "C_System", + "C_ExternCSystem"}; // MacroDirective::Kind strings. static const char *const MacroDirectiveKindStrings[] = { - "MD_Define","MD_Undefine", "MD_Visibility" -}; + "MD_Define", "MD_Undefine", "MD_Visibility"}; // PragmaIntroducerKind strings. -static const char *const PragmaIntroducerKindStrings[] = { "PIK_HashPragma", - "PIK__Pragma", - "PIK___pragma" }; +static const char *const PragmaIntroducerKindStrings[] = { + "PIK_HashPragma", "PIK__Pragma", "PIK___pragma"}; // PragmaMessageKind strings. static const char *const PragmaMessageKindStrings[] = { - "PMK_Message", "PMK_Warning", "PMK_Error" -}; + "PMK_Message", "PMK_Warning", "PMK_Error"}; // ConditionValueKind strings. static const char *const ConditionValueKindStrings[] = { - "CVK_NotEvaluated", "CVK_False", "CVK_True" -}; + "CVK_NotEvaluated", "CVK_False", "CVK_True"}; // Mapping strings. -static const char *const MappingStrings[] = { "0", "MAP_IGNORE", - "MAP_REMARK", "MAP_WARNING", - "MAP_ERROR", "MAP_FATAL" }; +static const char *const MappingStrings[] = { + "0", "MAP_IGNORE", "MAP_REMARK", "MAP_WARNING", "MAP_ERROR", "MAP_FATAL"}; // PPCallbacksTracker functions. @@ -111,10 +105,9 @@ // Callback invoked whenever a source file is skipped as the result // of header guard optimization. -void -PPCallbacksTracker::FileSkipped(const clang::FileEntry &SkippedFile, - const clang::Token &FilenameTok, - clang::SrcMgr::CharacteristicKind FileType) { +void PPCallbacksTracker::FileSkipped( + const clang::FileEntry &SkippedFile, const clang::Token &FilenameTok, + clang::SrcMgr::CharacteristicKind FileType) { beginCallback("FileSkipped"); appendArgument("ParentFile", &SkippedFile); appendArgument("FilenameTok", FilenameTok); @@ -123,9 +116,8 @@ // Callback invoked whenever an inclusion directive results in a // file-not-found error. -bool -PPCallbacksTracker::FileNotFound(llvm::StringRef FileName, - llvm::SmallVectorImpl &RecoveryPath) { +bool PPCallbacksTracker::FileNotFound( + llvm::StringRef FileName, llvm::SmallVectorImpl &RecoveryPath) { beginCallback("FileNotFound"); appendFilePathArgument("FileName", FileName); return false; @@ -174,9 +166,8 @@ } // Callback invoked when start reading any pragma directive. -void -PPCallbacksTracker::PragmaDirective(clang::SourceLocation Loc, - clang::PragmaIntroducerKind Introducer) { +void PPCallbacksTracker::PragmaDirective( + clang::SourceLocation Loc, clang::PragmaIntroducerKind Introducer) { beginCallback("PragmaDirective"); appendArgument("Loc", Loc); appendArgument("Introducer", Introducer, PragmaIntroducerKindStrings); @@ -300,11 +291,10 @@ // Called by Preprocessor::HandleMacroExpandedIdentifier when a // macro invocation is found. -void -PPCallbacksTracker::MacroExpands(const clang::Token &MacroNameTok, - const clang::MacroDefinition &MacroDefinition, - clang::SourceRange Range, - const clang::MacroArgs *Args) { +void PPCallbacksTracker::MacroExpands( + const clang::Token &MacroNameTok, + const clang::MacroDefinition &MacroDefinition, clang::SourceRange Range, + const clang::MacroArgs *Args) { beginCallback("MacroExpands"); appendArgument("MacroNameTok", MacroNameTok); appendArgument("MacroDefinition", MacroDefinition); @@ -313,9 +303,9 @@ } // Hook called whenever a macro definition is seen. -void -PPCallbacksTracker::MacroDefined(const clang::Token &MacroNameTok, - const clang::MacroDirective *MacroDirective) { +void PPCallbacksTracker::MacroDefined( + const clang::Token &MacroNameTok, + const clang::MacroDirective *MacroDirective) { beginCallback("MacroDefined"); appendArgument("MacroNameTok", MacroNameTok); appendArgument("MacroDirective", MacroDirective); @@ -570,7 +560,8 @@ Any = true; } for (auto *MM : Value.getModuleMacros()) { - if (Any) SS << ", "; + if (Any) + SS << ", "; SS << MM->getOwningModule()->getFullModuleName(); } SS << "]"; Index: pp-trace/PPTrace.cpp =================================================================== --- pp-trace/PPTrace.cpp +++ pp-trace/PPTrace.cpp @@ -110,8 +110,8 @@ PPTraceConsumer(SmallSet &Ignore, std::vector &CallbackCalls, Preprocessor &PP) { // PP takes ownership. - PP.addPPCallbacks(llvm::make_unique(Ignore, - CallbackCalls, PP)); + PP.addPPCallbacks( + llvm::make_unique(Ignore, CallbackCalls, PP)); } }; @@ -183,8 +183,9 @@ // Parse the IgnoreCallbacks list into strings. SmallVector IgnoreCallbacksStrings; - StringRef(IgnoreCallbacks).split(IgnoreCallbacksStrings, ",", - /*MaxSplit=*/ -1, /*KeepEmpty=*/false); + StringRef(IgnoreCallbacks) + .split(IgnoreCallbacksStrings, ",", + /*MaxSplit=*/-1, /*KeepEmpty=*/false); SmallSet Ignore; for (SmallVector::iterator I = IgnoreCallbacksStrings.begin(), E = IgnoreCallbacksStrings.end(); Index: tool-template/ToolTemplate.cpp =================================================================== --- tool-template/ToolTemplate.cpp +++ tool-template/ToolTemplate.cpp @@ -34,8 +34,8 @@ // //===----------------------------------------------------------------------===// -#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"