} else if (const auto *TLoc = Result.Nodes.getNodeAs<TypeLoc>("type")) {
fixTypeLoc(Result, startLocationForType(*TLoc), EndLocationForType(*TLoc),
*TLoc);
- } else if (const auto *VarRef = Result.Nodes.getNodeAs<DeclRefExpr>("var_ref")){
+ } else if (const auto *VarRef =
+ Result.Nodes.getNodeAs<DeclRefExpr>("var_ref")) {
const auto *Var = Result.Nodes.getNodeAs<VarDecl>("var_decl");
assert(Var);
if (Var->getCanonicalDecl()->isStaticDataMember())
VarRefRange.getEnd(), Name);
} else {
const auto *Call = Result.Nodes.getNodeAs<clang::CallExpr>("call");
- assert(Call != nullptr &&"Expecting callback for CallExpr.");
- const clang::FunctionDecl* Func = Call->getDirectCallee();
+ assert(Call != nullptr && "Expecting callback for CallExpr.");
+ const clang::FunctionDecl *Func = Call->getDirectCallee();
assert(Func != nullptr);
// Ignore out-of-line static methods since they will be handled by nested
// name specifiers.
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.
typedef std::vector<clang::tooling::Range> RangeVector;
/// \brief Collection of TranslationUnitReplacements.
-typedef std::vector<clang::tooling::TranslationUnitReplacements>
-TUReplacements;
+typedef std::vector<clang::tooling::TranslationUnitReplacements> TUReplacements;
/// \brief Collection of TranslationUnitReplacement files.
typedef std::vector<std::string> TUReplacementFiles;
///
/// \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.
/// \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(
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;
Rewriter &Rewrite) {
bool Result = true;
for (std::vector<tooling::Replacement>::const_iterator I = Replaces.begin(),
- E = Replaces.end();
+ E = Replaces.end();
I != E; ++I) {
if (I->isApplicable()) {
Result = I->apply(Rewrite) && Result;
return Result;
}
-
// FIXME: moved from libToolingCore. remove this when std::vector<Replacement>
// is replaced with tooling::Replacements class.
static void deduplicate(std::vector<tooling::Replacement> &Replaces,
- std::vector<tooling::Range> &Conflicts) {
+ std::vector<tooling::Range> &Conflicts) {
if (Replaces.empty())
return;
"merging/replacing."),
cl::init(false), cl::cat(ReplacementCategory));
-
static cl::opt<bool> DoFormat(
"format",
cl::desc("Enable formatting of code changed by applying replacements.\n"
cl::init(""), cl::cat(FormattingCategory));
static cl::opt<std::string>
-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
clang::DiagnosticsEngine &Diagnostics)
: TURFiles(Files), Diag(Diagnostics) {}
- ~ScopedFileRemover() {
- deleteReplacementFiles(TURFiles, Diag);
- }
+ ~ScopedFileRemover() { deleteReplacementFiles(TURFiles, Diag); }
private:
const TUReplacementFiles &TURFiles;
static bool
getRewrittenData(const std::vector<tooling::Replacement> &Replacements,
Rewriter &Rewrites, std::string &Result) {
- if (Replacements.empty()) return true;
+ if (Replacements.empty())
+ return true;
if (!applyAllReplacements(Replacements, Rewrites))
return false;
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions());
DiagnosticsEngine Diagnostics(
- IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()),
- DiagOpts.get());
+ IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), DiagOpts.get());
// Determine a formatting style from options.
format::FormatStyle FormatStyle;
namespace {
// FIXME: Move to ASTMatchers.
-AST_MATCHER(VarDecl, isStaticDataMember) {
- return Node.isStaticDataMember();
-}
+AST_MATCHER(VarDecl, isStaticDataMember) { return Node.isStaticDataMember(); }
AST_MATCHER_P(Decl, hasOutermostEnclosingClass,
ast_matchers::internal::Matcher<Decl>, InnerMatcher) {
- const auto* Context = Node.getDeclContext();
- if (!Context) return false;
+ const auto *Context = Node.getDeclContext();
+ if (!Context)
+ return false;
while (const auto *NextContext = Context->getParent()) {
if (isa<NamespaceDecl>(NextContext) ||
isa<TranslationUnitDecl>(NextContext))
AST_MATCHER_P(CXXMethodDecl, ofOutermostEnclosingClass,
ast_matchers::internal::Matcher<CXXRecordDecl>, InnerMatcher) {
const CXXRecordDecl *Parent = Node.getParent();
- if (!Parent) return false;
+ if (!Parent)
+ return false;
while (const auto *NextParent =
dyn_cast<CXXRecordDecl>(Parent->getParent())) {
Parent = NextParent;
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);
//
// 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<char, 128> AbsoluteFilename;
// 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'.
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());
}
clang::tooling::Replacements
createInsertedReplacements(const std::vector<std::string> &Includes,
const std::vector<ClangMoveTool::MovedDecl> &Decls,
- llvm::StringRef FileName,
- bool IsHeader = false) {
+ llvm::StringRef FileName, bool IsHeader = false) {
std::string NewCode;
std::string GuardName(FileName);
if (IsHeader) {
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));
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);
// 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);
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(
MovedDecls.emplace_back(FWD, &Result.Context->getSourceManager());
}
}
- } else if (const auto *ANS = Result.Nodes.getNodeAs<clang::NamespaceDecl>(
- "anonymous_ns")) {
+ } else if (const auto *ANS =
+ Result.Nodes.getNodeAs<clang::NamespaceDecl>("anonymous_ns")) {
MovedDecls.emplace_back(ANS, &Result.Context->getSourceManager());
} else if (const auto *ND =
Result.Nodes.getNodeAs<clang::NamedDecl>("static_decls")) {
}
}
-void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader,
- bool IsAngled,
+void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
llvm::StringRef SearchPath,
llvm::StringRef FileName,
- const SourceManager& SM) {
+ const SourceManager &SM) {
SmallVector<char, 128> HeaderWithSearchPath;
llvm::sys::path::append(HeaderWithSearchPath, SearchPath, IncludeHeader);
std::string AbsoluteOldHeader =
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);
/// 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();
// Add "-fparse-all-comments" compile option to make clang parse all comments,
// otherwise, ordinary comments like "//" and "/*" won't get parsed (This is
// a bit of hacky).
- std::vector<std::string> ExtraArgs( argv, argv + argc );
- ExtraArgs.insert(ExtraArgs.begin()+1, "-extra-arg=-fparse-all-comments");
+ std::vector<std::string> ExtraArgs(argv, argv + argc);
+ ExtraArgs.insert(ExtraArgs.begin() + 1, "-extra-arg=-fparse-all-comments");
std::unique_ptr<const char *[]> RawExtraArgs(
new const char *[ExtraArgs.size()]);
for (size_t i = 0; i < ExtraArgs.size(); ++i)
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;
}
};
-} // namespace
+} // namespace
bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
unsigned MatchCount = 0;
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;
}
namespace clang {
namespace query {
-enum OutputKind {
- OK_Diag,
- OK_Print,
- OK_Dump
-};
+enum OutputKind { OK_Diag, OK_Print, OK_Dump };
enum QueryKind {
QK_Invalid,
return *this;
}
- T Default(const T& Value) const {
- return Switch.Default(Value);
- }
+ T Default(const T &Value) const { return Switch.Default(Value); }
};
// Lexes a word and stores it in Word. Returns a LexOrCompleteWord<T> object
QueryRef QueryParser::parseSetBool(bool QuerySession::*Var) {
StringRef ValStr;
unsigned Value = lexOrCompleteWord<unsigned>(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 + "'");
}
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;
return new InvalidQuery(OS.str());
}
-} // namespace
+} // namespace
QueryRef QueryParser::completeMatcherExpression() {
std::vector<MatcherCompletion> Comps = Parser::completeExpression(
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();
// 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!");
}
}
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.
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) {
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;
/// this object.
class ClangTidyCheckFactories {
public:
- typedef std::function<ClangTidyCheck *(
- StringRef Name, ClangTidyContext *Context)> CheckFactory;
+ typedef std::function<ClangTidyCheck *(StringRef Name,
+ ClangTidyContext *Context)>
+ CheckFactory;
/// \brief Registers check \p Factory with name \p Name.
///
template <typename CheckType> 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
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
// \brief A pair of configuration file base name and a function parsing
// configuration from text in the corresponding format.
typedef std::pair<std::string, std::function<llvm::ErrorOr<ClangTidyOptions>(
- llvm::StringRef)>> ConfigFileHandler;
+ llvm::StringRef)>>
+ ConfigFileHandler;
/// \brief Configuration file handlers listed in the order of priority.
///
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
// C++ checkers
// DCL
- CheckFactories.registerCheck<VariadicFunctionDefCheck>(
- "cert-dcl50-cpp");
+ CheckFactories.registerCheck<VariadicFunctionDefCheck>("cert-dcl50-cpp");
CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
"cert-dcl54-cpp");
CheckFactories.registerCheck<google::build::UnnamedNamespaceInHeaderCheck>(
// ERR
CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(
"cert-err09-cpp");
- CheckFactories.registerCheck<SetLongJmpCheck>(
- "cert-err52-cpp");
- CheckFactories.registerCheck<StaticObjectExceptionCheck>(
- "cert-err58-cpp");
- CheckFactories.registerCheck<ThrownExceptionTypeCheck>(
- "cert-err60-cpp");
+ CheckFactories.registerCheck<SetLongJmpCheck>("cert-err52-cpp");
+ CheckFactories.registerCheck<StaticObjectExceptionCheck>("cert-err58-cpp");
+ CheckFactories.registerCheck<ThrownExceptionTypeCheck>("cert-err60-cpp");
CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(
"cert-err61-cpp");
// MSC
- CheckFactories.registerCheck<LimitedRandomnessCheck>(
- "cert-msc50-cpp");
+ CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc50-cpp");
// C checkers
// DCL
- CheckFactories.registerCheck<misc::StaticAssertCheck>(
- "cert-dcl03-c");
+ CheckFactories.registerCheck<misc::StaticAssertCheck>("cert-dcl03-c");
// ENV
- CheckFactories.registerCheck<CommandProcessorCheck>(
- "cert-env33-c");
+ CheckFactories.registerCheck<CommandProcessorCheck>("cert-env33-c");
// FLP
- CheckFactories.registerCheck<FloatLoopCounter>(
- "cert-flp30-c");
+ CheckFactories.registerCheck<FloatLoopCounter>("cert-flp30-c");
// FIO
- CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>(
- "cert-fio38-c");
+ CheckFactories.registerCheck<misc::NonCopyableObjectsCheck>("cert-fio38-c");
// ERR
- CheckFactories.registerCheck<StrToNumCheck>(
- "cert-err34-c");
+ CheckFactories.registerCheck<StrToNumCheck>("cert-err34-c");
// MSC
- CheckFactories.registerCheck<LimitedRandomnessCheck>(
- "cert-msc30-c");
+ CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc30-c");
}
ClangTidyOptions getModuleOptions() override {
ClangTidyOptions Options;
// Register the MiscTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<cert::CERTModule>
-X("cert-module",
- "Adds lint checks corresponding to CERT secure coding guidelines.");
+ 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.
msg = "; use C++11 random library instead";
const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator");
- diag(MatchedDecl->getLocStart(),
- "rand() has limited randomness" + msg);
+ diag(MatchedDecl->getLocStart(), "rand() has limited randomness" + msg);
}
} // namespace cert
} // namespace tidy
} // namespace clang
-
<< 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)
//===----------------------------------------------------------------------===//
#include "StrToNumCheck.h"
-#include "clang/Analysis/Analyses/FormatString.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Analysis/Analyses/FormatString.h"
#include "llvm/ADT/StringSwitch.h"
#include <cassert>
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;
};
#include "ProTypeStaticCastDowncastCheck.h"
#include "ProTypeUnionAccessCheck.h"
#include "ProTypeVarargCheck.h"
-#include "SpecialMemberFunctionsCheck.h"
#include "SlicingCheck.h"
+#include "SpecialMemberFunctionsCheck.h"
namespace clang {
namespace tidy {
"cppcoreguidelines-pro-type-vararg");
CheckFactories.registerCheck<SpecialMemberFunctionsCheck>(
"cppcoreguidelines-special-member-functions");
- CheckFactories.registerCheck<SlicingCheck>(
- "cppcoreguidelines-slicing");
+ CheckFactories.registerCheck<SlicingCheck>("cppcoreguidelines-slicing");
CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>(
"cppcoreguidelines-c-copy-assignment-signature");
}
// 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(
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;
}
// 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);
}
}
this);
}
-void
-ProBoundsPointerArithmeticCheck::check(const MatchFinder::MatchResult &Result) {
+void ProBoundsPointerArithmeticCheck::check(
+ const MatchFinder::MatchResult &Result) {
const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr");
diag(MatchedExpr->getExprLoc(), "do not use pointer arithmetic");
namespace cppcoreguidelines {
/// 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
// AST.
Finder->addMatcher(
cxxRecordDecl(
- isDefinition(), unless(isInstantiated()),
- hasDefaultConstructor(),
+ isDefinition(), unless(isInstantiated()), hasDefaultConstructor(),
anyOf(has(cxxConstructorDecl(isDefaultConstructor(), isDefaulted(),
unless(isImplicit()))),
unless(has(cxxConstructorDecl()))),
<< toCommaSeparatedString(AllBases, BasesToInit);
if (Ctor)
- fixInitializerList(Context, Diag, Ctor, BasesToInit);
+ fixInitializerList(Context, Diag, Ctor, BasesToInit);
}
void ProTypeMemberInitCheck::checkUninitializedTrivialType(
this);
}
-void ProTypeStaticCastDowncastCheck::check(const MatchFinder::MatchResult &Result) {
+void ProTypeStaticCastDowncastCheck::check(
+ const MatchFinder::MatchResult &Result) {
const auto *MatchedCast = Result.Nodes.getNodeAs<CXXStaticCastExpr>("cast");
if (MatchedCast->getCastKind() != CK_BaseToDerived)
return;
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
if (!getLangOpts().CPlusPlus)
return;
- Finder->addMatcher(memberExpr(hasObjectExpression(hasType(recordDecl(isUnion())))).bind("expr"), this);
+ Finder->addMatcher(
+ memberExpr(hasObjectExpression(hasType(recordDecl(isUnion()))))
+ .bind("expr"),
+ this);
}
void ProTypeUnionAccessCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Matched = Result.Nodes.getNodeAs<MemberExpr>("expr");
- diag(Matched->getMemberLoc(), "do not access members of unions; use (boost::)variant instead");
+ diag(Matched->getMemberLoc(),
+ "do not access members of unions; use (boost::)variant instead");
}
} // namespace cppcoreguidelines
} // namespace tidy
} // namespace clang
-
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_UNION_ACCESS_H
-
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) {
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
// 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);
}
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
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)
callee(expr(ignoringParenImpCasts(
declRefExpr(hasExplicitTemplateArgs(),
to(functionDecl(hasName("::std::make_pair"))))
- .bind("declref"))))).bind("call"),
+ .bind("declref")))))
+ .bind("call"),
this);
}
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()));
}
}
RawStringHeaderFileExtensions(
Options.getLocalOrGlobal("HeaderFileExtensions", "h")) {
if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
- HeaderFileExtensions,
- ',')) {
+ HeaderFileExtensions, ',')) {
llvm::errs() << "Invalid header file extension: "
<< RawStringHeaderFileExtensions << "\n";
}
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) {
return;
}
- if (const auto* UsingDirective = dyn_cast<UsingDirectiveDecl>(D)) {
+ if (const auto *UsingDirective = dyn_cast<UsingDirectiveDecl>(D)) {
if (UsingDirective->getNominatedNamespace()->isAnonymousNamespace()) {
// Anynoumous namespaces inject a using directive into the AST to import
// the names into the containing namespace.
#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"
namespace google {
namespace runtime {
-
IntegerTypesCheck::IntegerTypesCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context),
UnsignedTypePrefix(Options.get("UnsignedTypePrefix", "uint")),
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.
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) {
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(),
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)
// 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);
}
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<FieldDecl>("member");
diag(Member->getLocStart(), "const string& members are dangerous; it is much "
"better to use alternatives, such as pointers or "
RawStringHeaderFileExtensions(
Options.getLocalOrGlobal("HeaderFileExtensions", "h,hh,hpp,hxx")) {
if (!utils::parseHeaderFileExtensions(RawStringHeaderFileExtensions,
- HeaderFileExtensions,
- ',')) {
+ HeaderFileExtensions, ',')) {
llvm::errs() << "Invalid header file extension: "
<< RawStringHeaderFileExtensions << "\n";
}
this);
}
-void
-UnnamedNamespaceInHeaderCheck::check(const MatchFinder::MatchResult &Result) {
+void UnnamedNamespaceInHeaderCheck::check(
+ const MatchFinder::MatchResult &Result) {
const auto *N = Result.Nodes.getNodeAs<NamespaceDecl>("anonymousNamespace");
SourceLocation Loc = N->getLocStart();
if (!Loc.isValid())
Finder->addMatcher(usingDirectiveDecl().bind("usingNamespace"), this);
}
-void
-UsingNamespaceDirectiveCheck::check(const MatchFinder::MatchResult &Result) {
+void UsingNamespaceDirectiveCheck::check(
+ const MatchFinder::MatchResult &Result) {
const auto *U = Result.Nodes.getNodeAs<UsingDirectiveDecl>("usingNamespace");
SourceLocation Loc = U->getLocStart();
if (U->isImplicit() || !Loc.isValid())
namespace llvm {
LLVMHeaderGuardCheck::LLVMHeaderGuardCheck(StringRef Name,
- ClangTidyContext* Context)
+ ClangTidyContext *Context)
: HeaderGuardCheck(Name, Context),
RawStringHeaderFileExtensions(
Options.getLocalOrGlobal("HeaderFileExtensions", ",h,hh,hpp,hxx")) {
<< 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)
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;
hasType(pointerType(pointee(booleanType()))),
ignoringParenImpCasts(declRefExpr().bind("expr")))),
hasCastKind(CK_PointerToBoolean))))),
- unless(isInTemplateInstantiation())).bind("if"),
+ unless(isInTemplateInstantiation()))
+ .bind("if"),
this);
}
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_BOOLPOINTERIMPLICITCONVERSIONCHECK_H
-
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: "
//===----------------------------------------------------------------------===//
#include "ForwardDeclarationNamespaceCheck.h"
-#include <stack>
-#include <string>
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
+#include <stack>
+#include <string>
using namespace clang::ast_matchers;
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_FORWARDDECLARATIONNAMESPACECHECK_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_FORWARDDECLARATIONNAMESPACECHECK_H
+#include "../ClangTidy.h"
+#include "llvm/ADT/SmallPtrSet.h"
#include <set>
#include <vector>
-#include "llvm/ADT/SmallPtrSet.h"
-#include "../ClangTidy.h"
namespace clang {
namespace tidy {
}
} // namespace
-
void IncorrectRoundings::registerMatchers(MatchFinder *MatchFinder) {
// Match a floating literal with value 0.5.
auto FloatHalf = floatLiteral(floatHalf());
} // namespace tidy
} // namespace clang
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCORRECTROUNDINGS_H_
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_INCORRECTROUNDINGS_H_
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;
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.
#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 {
#include "../ClangTidyModuleRegistry.h"
#include "ArgumentCommentCheck.h"
#include "AssertSideEffectCheck.h"
-#include "MisplacedConstCheck.h"
-#include "UnconventionalAssignOperatorCheck.h"
#include "BoolPointerImplicitConversionCheck.h"
#include "DanglingHandleCheck.h"
#include "DefinitionsInHeadersCheck.h"
#include "InefficientAlgorithmCheck.h"
#include "MacroParenthesesCheck.h"
#include "MacroRepeatedSideEffectsCheck.h"
+#include "MisplacedConstCheck.h"
#include "MisplacedWideningCastCheck.h"
#include "MoveConstantArgumentCheck.h"
#include "MoveConstructorInitCheck.h"
#include "SuspiciousStringCompareCheck.h"
#include "SwappedArgumentsCheck.h"
#include "ThrowByValueCatchByReferenceCheck.h"
+#include "UnconventionalAssignOperatorCheck.h"
#include "UndelegatedConstructor.h"
#include "UniqueptrResetReleaseCheck.h"
#include "UnusedAliasDeclsCheck.h"
CheckFactories.registerCheck<ArgumentCommentCheck>("misc-argument-comment");
CheckFactories.registerCheck<AssertSideEffectCheck>(
"misc-assert-side-effect");
- CheckFactories.registerCheck<MisplacedConstCheck>(
- "misc-misplaced-const");
+ CheckFactories.registerCheck<MisplacedConstCheck>("misc-misplaced-const");
CheckFactories.registerCheck<UnconventionalAssignOperatorCheck>(
"misc-unconventional-assign-operator");
CheckFactories.registerCheck<BoolPointerImplicitConversionCheck>(
"misc-bool-pointer-implicit-conversion");
- CheckFactories.registerCheck<DanglingHandleCheck>(
- "misc-dangling-handle");
+ CheckFactories.registerCheck<DanglingHandleCheck>("misc-dangling-handle");
CheckFactories.registerCheck<DefinitionsInHeadersCheck>(
"misc-definitions-in-headers");
- CheckFactories.registerCheck<FoldInitTypeCheck>(
- "misc-fold-init-type");
+ CheckFactories.registerCheck<FoldInitTypeCheck>("misc-fold-init-type");
CheckFactories.registerCheck<ForwardDeclarationNamespaceCheck>(
"misc-forward-declaration-namespace");
- CheckFactories.registerCheck<InaccurateEraseCheck>(
- "misc-inaccurate-erase");
+ CheckFactories.registerCheck<InaccurateEraseCheck>("misc-inaccurate-erase");
CheckFactories.registerCheck<IncorrectRoundings>(
"misc-incorrect-roundings");
CheckFactories.registerCheck<InefficientAlgorithmCheck>(
CheckFactories.registerCheck<SizeofContainerCheck>("misc-sizeof-container");
CheckFactories.registerCheck<SizeofExpressionCheck>(
"misc-sizeof-expression");
- CheckFactories.registerCheck<StaticAssertCheck>(
- "misc-static-assert");
+ CheckFactories.registerCheck<StaticAssertCheck>("misc-static-assert");
CheckFactories.registerCheck<StringConstructorCheck>(
"misc-string-constructor");
CheckFactories.registerCheck<StringIntegerAssignmentCheck>(
// Register the MiscTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<misc::MiscModule>
-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.
//===----------------------------------------------------------------------===//
#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;
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);
}
"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) {
void MoveConstructorInitCheck::handleMoveConstructor(
const MatchFinder::MatchResult &Result) {
const auto *CopyCtor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
- const auto *Initializer = Result.Nodes.getNodeAs<CXXCtorInitializer>("move-init");
+ const auto *Initializer =
+ Result.Nodes.getNodeAs<CXXCtorInitializer>("move-init");
// Do not diagnose if the expression used to perform the initialization is a
// trivially-copyable type.
const Stmt *Parent = Parents[0].get<Stmt>();
if (!Parent)
return nullptr;
- const Stmt* Prev = nullptr;
+ const Stmt *Prev = nullptr;
for (const Stmt *Child : Parent->children()) {
if (Prev == S)
return Child;
return Locs;
}
-} // namespace
+} // namespace
void MultipleStatementMacroCheck::registerMatchers(MatchFinder *Finder) {
const auto Inner = expr(isInMacro(), unless(compoundStmt())).bind("inner");
OverloadedOperatorKind getCorrespondingOverload(const FunctionDecl *FD) {
switch (FD->getOverloadedOperator()) {
- default: break;
+ default:
+ break;
case OO_New:
return OO_Delete;
case OO_Delete:
const char *getOperatorName(OverloadedOperatorKind K) {
switch (K) {
- default: break;
+ default:
+ break;
case OO_New:
return "operator new";
case OO_Delete:
// 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);
}
class NewDeleteOverloadsCheck : public ClangTidyCheck {
std::map<const clang::CXXRecordDecl *,
- llvm::SmallVector<const clang::FunctionDecl *, 4>> Overloads;
+ llvm::SmallVector<const clang::FunctionDecl *, 4>>
+ Overloads;
public:
NewDeleteOverloadsCheck(StringRef Name, ClangTidyContext *Context)
- : ClangTidyCheck(Name, Context) {}
+ : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void onEndOfTranslationUnit() override;
}
const auto *ProtoType = Decl->getType()->getAs<FunctionProtoType>();
- switch(ProtoType->getNoexceptSpec(*Result.Context)) {
- case FunctionProtoType::NR_NoNoexcept:
+ switch (ProtoType->getNoexceptSpec(*Result.Context)) {
+ case FunctionProtoType::NR_NoNoexcept:
diag(Decl->getLocation(), "move %0s should be marked noexcept")
<< MethodType;
// FIXME: Add a fixit.
} // namespace misc
} // namespace tidy
} // namespace clang
-
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NOEXCEPTMOVECONSTRUCTORCHECK_H
-
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;
};
} // namespace misc
} // namespace tidy
} // namespace clang
-
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_SIZEOF_CONTAINER_H
-
//===----------------------------------------------------------------------===//
#include "SizeofExpressionCheck.h"
+#include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "../utils/Matchers.h"
using namespace clang::ast_matchers;
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_INTEGER_ASSIGNMENT_H
-
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);
// "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);
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)
// Skip small arrays as they often generate false-positive.
unsigned int Size = InitializerList->getNumInits();
- if (Size < SizeThreshold) return;
+ if (Size < SizeThreshold)
+ return;
// Count the number of occurence of concatenated string literal.
unsigned int Count = 0;
for (unsigned int i = 0; i < Size; ++i) {
const Expr *Child = InitializerList->getInit(i)->IgnoreImpCasts();
if (const auto *Literal = dyn_cast<StringLiteral>(Child)) {
- if (Literal->getNumConcatenated() > 1) ++Count;
+ if (Literal->getNumConcatenated() > 1)
+ ++Count;
}
}
// Warn only when concatenation is not common in this initializer list.
// The current threshold is set to less than 1/5 of the string literals.
- if (double(Count) / Size > RatioThreshold) return;
+ if (double(Count) / Size > RatioThreshold)
+ return;
diag(ConcatenatedLiteral->getLocStart(),
"suspicious string literal, probably missing a comma");
}
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace misc
+} // namespace tidy
+} // namespace clang
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
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;"
.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:
<< Decl;
}
- if (const auto* BinOp = Result.Nodes.getNodeAs<BinaryOperator>("suspicious-operator")) {
+ if (const auto *BinOp =
+ Result.Nodes.getNodeAs<BinaryOperator>("suspicious-operator")) {
diag(Call->getLocStart(), "results of function %0 used by operator '%1'")
<< Decl << BinOp->getOpcodeStr();
}
#include "ThrowByValueCatchByReferenceCheck.h"
#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/AST/OperationKinds.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers;
namespace 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)
this);
}
-void UnconventionalAssignOperatorCheck::check(const MatchFinder::MatchResult &Result) {
+void UnconventionalAssignOperatorCheck::check(
+ const MatchFinder::MatchResult &Result) {
if (const auto *RetStmt = Result.Nodes.getNodeAs<ReturnStmt>("returnStmt")) {
diag(RetStmt->getLocStart(), "operator=() should always return '*this'");
} else {
this);
}
-void UndelegatedConstructorCheck::check(const MatchFinder::MatchResult &Result) {
+void UndelegatedConstructorCheck::check(
+ const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getStmtAs<CXXConstructExpr>("construct");
diag(E->getLocStart(), "did you intend to call a delegated constructor? "
"A temporary object is created here instead");
return false;
}
-} // namespace
+} // namespace
void UniqueptrResetReleaseCheck::check(const MatchFinder::MatchResult &Result) {
if (!areDeletersCompatible(Result))
}
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
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H
-
void UnusedParametersCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("function");
if (!Function->doesThisDeclarationHaveABody() ||
- !Function->hasWrittenPrototype() ||
- Function->isTemplateInstantiation())
+ !Function->hasWrittenPrototype() || Function->isTemplateInstantiation())
return;
if (const auto *Method = dyn_cast<CXXMethodDecl>(Function))
if (Method->isLambdaStaticInvoker())
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H
-
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) {
}
// Check the uninstantiated template function usage.
if (const auto *ULE = Result.Nodes.getNodeAs<UnresolvedLookupExpr>("used")) {
- for (const NamedDecl* ND : ULE->decls()) {
+ for (const NamedDecl *ND : ULE->decls()) {
if (const auto *USD = dyn_cast<UsingShadowDecl>(ND))
removeFromFoundDecls(USD->getTargetDecl()->getCanonicalDecl());
}
}
}
-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();
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(
addPlaceholderArgs(Args, Stream);
Stream << " { return ";
Ref->printPretty(Stream, nullptr, Result.Context->getPrintingPolicy());
- Stream<< "(";
+ Stream << "(";
addFunctionCallArgs(Args, Stream);
Stream << "); };";
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_UNIQUE_H
-
class ModernizeModule : public ClangTidyModule {
public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
- CheckFactories.registerCheck<AvoidBindCheck>(
- "modernize-avoid-bind");
+ CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind");
CheckFactories.registerCheck<DeprecatedHeadersCheck>(
"modernize-deprecated-headers");
CheckFactories.registerCheck<LoopConvertCheck>("modernize-loop-convert");
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
#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;
/// 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))
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_DEFAULT_H
-
/// 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,
/// \param LO language options
void checkArguments(ArrayRef<const Type *> BufferTypes,
ArrayRef<const Expr *> BufferExprs,
- ArrayRef<StringRef> MPIDatatypes,
- const LangOptions &LO);
+ ArrayRef<StringRef> MPIDatatypes, const LangOptions &LO);
};
} // namespace mpi
}
// 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;
}
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",
bool IsNonTrivialImplicitCast(const Stmt *ST) {
if (const auto *ICE = dyn_cast<ImplicitCastExpr>(ST)) {
return (ICE->getCastKind() != CK_NoOp) ||
- IsNonTrivialImplicitCast(ICE->getSubExpr());
+ IsNonTrivialImplicitCast(ICE->getSubExpr());
}
return false;
}
// 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);
};
} // 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_
} // namespace
-
using namespace ::clang::ast_matchers;
using utils::decl_ref_expr::isOnlyUsedAsConst;
// 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())));
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")))),
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.
//===----------------------------------------------------------------------===//
#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;
// 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);
}
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;
const ASTContext *Context);
private:
- std::set<const Stmt*> ForceBracesStmts;
+ std::set<const Stmt *> ForceBracesStmts;
const unsigned ShortStatementLines;
};
#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"
/// 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);
if (const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declRef")) {
SourceRange Range = DeclRef->getNameInfo().getSourceRange();
- addUsage(NamingCheckFailures, DeclRef->getDecl(), Range, Result.SourceManager);
+ addUsage(NamingCheckFailures, DeclRef->getDecl(), Range,
+ Result.SourceManager);
return;
}
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",
SourceParamName != OtherParamName) {
SourceRange OtherParamNameRange =
DeclarationNameInfo((*OtherParamIt)->getDeclName(),
- (*OtherParamIt)->getLocation()).getSourceRange();
+ (*OtherParamIt)->getLocation())
+ .getSourceRange();
bool GenerateFixItHint = checkIfFixItHintIsApplicable(
ParameterSourceDeclaration, *SourceParamIt, OriginalDeclaration);
}
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,
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.
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"));
namespace readability {
void RedundantDeclarationCheck::registerMatchers(MatchFinder *Finder) {
- Finder->addMatcher(namedDecl(anyOf(varDecl(), functionDecl())).bind("Decl"), this);
+ Finder->addMatcher(namedDecl(anyOf(varDecl(), functionDecl())).bind("Decl"),
+ this);
}
void RedundantDeclarationCheck::check(const MatchFinder::MatchResult &Result) {
const 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<VarDecl>(D)) {
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));
//===----------------------------------------------------------------------===//
#include "RedundantMemberInitCheck.h"
+#include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h"
-#include "../utils/Matchers.h"
#include <algorithm>
using namespace clang::ast_matchers;
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"))),
.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),
// 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.
// 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
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,
/// http://clang.llvm.org/extra/clang-tidy/checks/readability-static-definition-in-anonymous-namespace.html
class StaticDefinitionInAnonymousNamespaceCheck : public ClangTidyCheck {
public:
- StaticDefinitionInAnonymousNamespaceCheck(StringRef Name, ClangTidyContext *Context)
+ StaticDefinitionInAnonymousNamespaceCheck(StringRef Name,
+ ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
} // namespace readability
} // namespace tidy
} // namespace clang
-
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UNIQUEPTR_DELETE_RELEASE_H
-
SystemHeaders("system-headers",
cl::desc("Display the errors from system headers."),
cl::init(false), cl::cat(ClangTidyCategory));
-static cl::opt<std::string>
- LineFilter("line-filter",
- cl::desc(R"(
+static cl::opt<std::string> LineFilter("line-filter", cl::desc(R"(
List of files with line ranges to filter the
warnings. Can be used together with
-header-filter. The format of the list is a
{"name":"file2.h"}
]
)"),
- cl::init(""), cl::cat(ClangTidyCategory));
+ cl::init(""),
+ cl::cat(ClangTidyCategory));
static cl::opt<bool> Fix("fix", cl::desc(R"(
Apply suggested fixes. Without -fix-errors
std::vector<std::pair<llvm::TimeRecord, StringRef>> Timers;
TimeRecord Total;
- for (const auto& P : Profile.Records) {
+ for (const auto &P : Profile.Records) {
Timers.emplace_back(P.getValue(), P.getKey());
Total += P.getValue();
}
std::vector<std::string> EnabledChecks = getCheckNames(EffectiveOptions);
if (ExplainConfig) {
- //FIXME: Show other ClangTidyOptions' fields, like ExtraArg.
+ // FIXME: Show other ClangTidyOptions' fields, like ExtraArg.
std::vector<clang::tidy::ClangTidyOptionsProvider::OptionsSource>
RawOptions = OptionsProvider->getRawOptions(FilePath);
for (const std::string &Check : EnabledChecks) {
std::vector<ClangTidyError> Errors;
ClangTidyStats Stats =
runClangTidy(std::move(OptionsProvider), OptionsParser.getCompilations(),
- PathList, &Errors,
- EnableCheckProfile ? &Profile : nullptr);
+ PathList, &Errors, EnableCheckProfile ? &Profile : nullptr);
bool FoundErrors =
std::find_if(Errors.begin(), Errors.end(), [](const ClangTidyError &E) {
return E.DiagLevel == ClangTidyError::Error;
// 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;
// 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 {
#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 {
return Node.isRelationalOp();
}
-AST_MATCHER(BinaryOperator, isEqualityOperator) {
- return Node.isEqualityOp();
-}
+AST_MATCHER(BinaryOperator, isEqualityOperator) { return Node.isEqualityOp(); }
AST_MATCHER(BinaryOperator, isComparisonOperator) {
return Node.isComparisonOp();
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.
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;
}
// Based on QualType::isTrivial.
-bool isTriviallyDefaultConstructible(QualType Type,
- const ASTContext &Context) {
+bool isTriviallyDefaultConstructible(QualType Type, const ASTContext &Context) {
if (Type.isNull())
return false;
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);
//
//===----------------------------------------------------------------------===//
-#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"