This is an archive of the discontinued LLVM Phabricator instance.

Differential D141770

[clang-tidy][NFC] Use C++17 nested namespaces in the clang-tidy folder
ClosedPublic

Authored by carlosgalvezp on Jan 14 2023, 9:46 AM.

Details

Reviewers
njames93
jdoerfert
Eugene.Zelenko
lebedev.ri
Commits
rG7d2ea6c422d3: [clang-tidy][NFC] Use C++17 nested namespaces in the clang-tidy folder
Summary

Fix applied by running:

run-clang-tidy.py -checks=-*,modernize-concat-nested-namespaces

Diff Detail

Event Timeline

carlosgalvezp created this revision.Jan 14 2023, 9:46 AM
Herald added a reviewer: lebedev.ri. · View Herald TranscriptJan 14 2023, 9:46 AM
Herald added a reviewer: lebedev.ri. · View Herald Transcript
Herald added a reviewer: njames93. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: abrachet, ormris, lebedev.ri and 8 others. · View Herald Transcript
carlosgalvezp requested review of this revision.Jan 14 2023, 9:46 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptJan 14 2023, 9:46 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, StephenFan, sstefan1. · View Herald Transcript
carlosgalvezp mentioned this in D141769: [clang-tidy][NFC] Use C++17 nested namespaces in add_new_check.py and rename_check.py.Jan 14 2023, 9:48 AM
lebedev.ri removed a reviewer: lebedev.ri.Jan 14 2023, 9:50 AM
Herald added a reviewer: lebedev.ri. · View Herald TranscriptJan 14 2023, 9:50 AM
Herald added a reviewer: lebedev.ri. · View Herald Transcript
carlosgalvezp updated this revision to Diff 489276.Jan 14 2023, 9:53 AM

Also update add_new_check.py and rename_check.py

carlosgalvezp edited reviewers, added: Eugene.Zelenko; removed: lebedev.ri.Jan 14 2023, 9:56 AM
Herald added a reviewer: lebedev.ri. · View Herald TranscriptJan 14 2023, 9:56 AM
Herald added a reviewer: lebedev.ri. · View Herald Transcript
njames93 accepted this revision.Jan 14 2023, 10:15 AM

Assuming the pre-merge is happy, this LGTM

This revision is now accepted and ready to land.Jan 14 2023, 10:15 AM
Harbormaster completed remote builds in B207841: Diff 489276.Jan 14 2023, 10:50 AM
Closed by commit rG7d2ea6c422d3: [clang-tidy][NFC] Use C++17 nested namespaces in the clang-tidy folder (authored by carlosgalvezp). · Explain WhyJan 14 2023, 10:52 AM
This revision was automatically updated to reflect the committed changes.
carlosgalvezp added a commit: rG7d2ea6c422d3: [clang-tidy][NFC] Use C++17 nested namespaces in the clang-tidy folder.

Revision Contents

PathSize
clang-tools-extra/
clang-tidy/
6 lines
6 lines
6 lines
6 lines
12 lines
6 lines
6 lines
6 lines
6 lines
abseil/
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
16 lines
altera/
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
android/
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
boost/
6 lines
8 lines
bugprone/
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
9 lines
8 lines
cert/
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
concurrency/
6 lines
6 lines
8 lines
cppcoreguidelines/
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
darwin/
8 lines
6 lines
8 lines
fuchsia/
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
google/
10 lines
10 lines
10 lines
10 lines
8 lines
8 lines
8 lines
10 lines
10 lines
10 lines
6 lines
8 lines
10 lines
10 lines
10 lines
8 lines
10 lines
hicpp/
8 lines
6 lines
8 lines
8 lines
8 lines
linuxkernel/
6 lines
8 lines
llvm/
8 lines
8 lines
6 lines
6 lines
8 lines
8 lines
llvmlibc/
8 lines
8 lines
6 lines
8 lines
misc/
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
9 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
modernize/
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
mpi/
8 lines
6 lines
8 lines
objc/
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
openmp/
8 lines
6 lines
8 lines
performance/
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
plugin/
6 lines
portability/
6 lines
8 lines
8 lines
8 lines
readability/
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
8 lines
6 lines
5 lines
tool/
6 lines
utils/
8 lines
8 lines
10 lines
9 lines
8 lines
8 lines
10 lines
8 lines
8 lines
6 lines
10 lines
8 lines
10 lines
6 lines
8 lines
10 lines
8 lines
zircon/
8 lines
6 lines

Diff 489282

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

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::driver; using namespace clang::driver;
using namespace clang::tooling; using namespace clang::tooling;
using namespace llvm; using namespace llvm;
LLVM_INSTANTIATE_REGISTRY(clang::tidy::ClangTidyModuleRegistry) LLVM_INSTANTIATE_REGISTRY(clang::tidy::ClangTidyModuleRegistry)
namespace clang { namespace clang::tidy {
namespace tidy {
namespace { namespace {
#if CLANG_TIDY_ENABLE_STATIC_ANALYZER #if CLANG_TIDY_ENABLE_STATIC_ANALYZER
static const char *AnalyzerCheckNamePrefix = "clang-analyzer-"; static const char *AnalyzerCheckNamePrefix = "clang-analyzer-";
class AnalyzerDiagnosticConsumer : public ento::PathDiagnosticConsumer { class AnalyzerDiagnosticConsumer : public ento::PathDiagnosticConsumer {
public: public:
AnalyzerDiagnosticConsumer(ClangTidyContext &Context) : Context(Context) {} AnalyzerDiagnosticConsumer(ClangTidyContext &Context) : Context(Context) {}
▲ Show 20 Lines • Show All 585 Lines • ▼ Show 20 Lines#endif // CLANG_TIDY_ENABLE_STATIC_ANALYZER
Context.setOptionsCollector(&Result.Options); Context.setOptionsCollector(&Result.Options);
for (const auto &Factory : Factories) { for (const auto &Factory : Factories) {
Factory.getValue()(Factory.getKey(), &Context); Factory.getValue()(Factory.getKey(), &Context);
} }
return Result; return Result;
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

//===--- ClangTidyCheck.cpp - clang-tidy ------------------------*- C++ -*-===// //===--- ClangTidyCheck.cpp - clang-tidy ------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ClangTidyCheck.h" #include "ClangTidyCheck.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.h"
#include "llvm/Support/YAMLParser.h" #include "llvm/Support/YAMLParser.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy {
namespace tidy {
ClangTidyCheck::ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context) ClangTidyCheck::ClangTidyCheck(StringRef CheckName, ClangTidyContext *Context)
: CheckName(CheckName), Context(Context), : CheckName(CheckName), Context(Context),
Options(CheckName, Context->getOptions().CheckOptions, Context) { Options(CheckName, Context->getOptions().CheckOptions, Context) {
assert(Context != nullptr); assert(Context != nullptr);
assert(!CheckName.empty()); assert(!CheckName.empty());
} }
▲ Show 20 Lines • Show All 194 Lines • ▼ Show 20 LinesStringRef ClangTidyCheck::OptionsView::get(StringRef LocalName,
return get(LocalName).value_or(Default); return get(LocalName).value_or(Default);
} }
StringRef StringRef
ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName, ClangTidyCheck::OptionsView::getLocalOrGlobal(StringRef LocalName,
StringRef Default) const { StringRef Default) const {
return getLocalOrGlobal(LocalName).value_or(Default); return getLocalOrGlobal(LocalName).value_or(Default);
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

Show First 20 Lines • Show All 313 Lines • ▼ Show 20 Lines if (!Errors.empty()) {
} else { } else {
++Context.Stats.ErrorsDisplayed; ++Context.Stats.ErrorsDisplayed;
} }
} }
LastErrorRelatesToUserCode = false; LastErrorRelatesToUserCode = false;
LastErrorPassesLineFilter = false; LastErrorPassesLineFilter = false;
} }
namespace clang { namespace clang::tidy {
namespace tidy {
const llvm::StringMap<tooling::Replacements> * const llvm::StringMap<tooling::Replacements> *
getFixIt(const tooling::Diagnostic &Diagnostic, bool GetFixFromNotes) { getFixIt(const tooling::Diagnostic &Diagnostic, bool GetFixFromNotes) {
if (!Diagnostic.Message.Fix.empty()) if (!Diagnostic.Message.Fix.empty())
return &Diagnostic.Message.Fix; return &Diagnostic.Message.Fix;
if (!GetFixFromNotes) if (!GetFixFromNotes)
return nullptr; return nullptr;
const llvm::StringMap<tooling::Replacements> *Result = nullptr; const llvm::StringMap<tooling::Replacements> *Result = nullptr;
for (const auto &Note : Diagnostic.Notes) { for (const auto &Note : Diagnostic.Notes) {
if (!Note.Fix.empty()) { if (!Note.Fix.empty()) {
if (Result) if (Result)
// We have 2 different fixes in notes, bail out. // We have 2 different fixes in notes, bail out.
return nullptr; return nullptr;
Result = &Note.Fix; Result = &Note.Fix;
} }
} }
return Result; return Result;
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang
void ClangTidyDiagnosticConsumer::HandleDiagnostic( void ClangTidyDiagnosticConsumer::HandleDiagnostic(
DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) { DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
if (LastErrorWasIgnored && DiagLevel == DiagnosticsEngine::Note) if (LastErrorWasIgnored && DiagLevel == DiagnosticsEngine::Note)
return; return;
SmallVector<tooling::Diagnostic, 1> SuppressionErrors; SmallVector<tooling::Diagnostic, 1> SuppressionErrors;
if (Context.shouldSuppressDiagnostic(DiagLevel, Info, SuppressionErrors, if (Context.shouldSuppressDiagnostic(DiagLevel, Info, SuppressionErrors,
▲ Show 20 Lines • Show All 441 Lines • Show Last 20 Lines

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

//===--- tools/extra/clang-tidy/ClangTidyModule.cpp - Clang tidy tool -----===// //===--- tools/extra/clang-tidy/ClangTidyModule.cpp - Clang tidy tool -----===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ///
/// \file Implements classes required to build clang-tidy modules. /// \file Implements classes required to build clang-tidy modules.
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ClangTidyModule.h" #include "ClangTidyModule.h"
#include "ClangTidyCheck.h" #include "ClangTidyCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
void ClangTidyCheckFactories::registerCheckFactory(StringRef Name, void ClangTidyCheckFactories::registerCheckFactory(StringRef Name,
CheckFactory Factory) { CheckFactory Factory) {
Factories.insert_or_assign(Name, std::move(Factory)); Factories.insert_or_assign(Name, std::move(Factory));
} }
std::vector<std::unique_ptr<ClangTidyCheck>> std::vector<std::unique_ptr<ClangTidyCheck>>
ClangTidyCheckFactories::createChecks(ClangTidyContext *Context) const { ClangTidyCheckFactories::createChecks(ClangTidyContext *Context) const {
Show All 20 LinesClangTidyCheckFactories::createChecksForLanguage(
} }
return Checks; return Checks;
} }
ClangTidyOptions ClangTidyModule::getModuleOptions() { ClangTidyOptions ClangTidyModule::getModuleOptions() {
return ClangTidyOptions(); return ClangTidyOptions();
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

Show All 22 Lines
using clang::tidy::ClangTidyOptions; using clang::tidy::ClangTidyOptions;
using clang::tidy::FileFilter; using clang::tidy::FileFilter;
using OptionsSource = clang::tidy::ClangTidyOptionsProvider::OptionsSource; using OptionsSource = clang::tidy::ClangTidyOptionsProvider::OptionsSource;
LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter) LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter)
LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange) LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FileFilter::LineRange)
namespace llvm { namespace llvm::yaml {
namespace yaml {
// Map std::pair<int, int> to a JSON array of size 2. // Map std::pair<int, int> to a JSON array of size 2.
template <> struct SequenceTraits<FileFilter::LineRange> { template <> struct SequenceTraits<FileFilter::LineRange> {
static size_t size(IO &IO, FileFilter::LineRange &Range) { static size_t size(IO &IO, FileFilter::LineRange &Range) {
return Range.first == 0 ? 0 : Range.second == 0 ? 1 : 2; return Range.first == 0 ? 0 : Range.second == 0 ? 1 : 2;
} }
static unsigned &element(IO &IO, FileFilter::LineRange &Range, size_t Index) { static unsigned &element(IO &IO, FileFilter::LineRange &Range, size_t Index) {
if (Index > 1) if (Index > 1)
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines static void mapping(IO &IO, ClangTidyOptions &Options) {
IO.mapOptional("CheckOptions", Options.CheckOptions); IO.mapOptional("CheckOptions", Options.CheckOptions);
IO.mapOptional("ExtraArgs", Options.ExtraArgs); IO.mapOptional("ExtraArgs", Options.ExtraArgs);
IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore); IO.mapOptional("ExtraArgsBefore", Options.ExtraArgsBefore);
IO.mapOptional("InheritParentConfig", Options.InheritParentConfig); IO.mapOptional("InheritParentConfig", Options.InheritParentConfig);
IO.mapOptional("UseColor", Options.UseColor); IO.mapOptional("UseColor", Options.UseColor);
} }
}; };
} // namespace yaml } // namespace llvm::yaml
} // namespace llvm
namespace clang { namespace clang::tidy {
namespace tidy {
ClangTidyOptions ClangTidyOptions::getDefaults() { ClangTidyOptions ClangTidyOptions::getDefaults() {
ClangTidyOptions Options; ClangTidyOptions Options;
Options.Checks = ""; Options.Checks = "";
Options.WarningsAsErrors = ""; Options.WarningsAsErrors = "";
Options.HeaderFilterRegex = ""; Options.HeaderFilterRegex = "";
Options.SystemHeaders = false; Options.SystemHeaders = false;
Options.FormatStyle = "none"; Options.FormatStyle = "none";
▲ Show 20 Lines • Show All 296 Lines • ▼ Show 20 Linesstd::string configurationAsText(const ClangTidyOptions &Options) {
llvm::yaml::Output Output(Stream); llvm::yaml::Output Output(Stream);
// We use the same mapping method for input and output, so we need a non-const // We use the same mapping method for input and output, so we need a non-const
// reference here. // reference here.
ClangTidyOptions NonConstValue = Options; ClangTidyOptions NonConstValue = Options;
Output << NonConstValue; Output << NonConstValue;
return Stream.str(); return Stream.str();
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

Show All 11 Lines
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <optional> #include <optional>
#include <system_error> #include <system_error>
#include <utility> #include <utility>
#define DEBUG_TYPE "clang-tidy-profiling" #define DEBUG_TYPE "clang-tidy-profiling"
namespace clang { namespace clang::tidy {
namespace tidy {
ClangTidyProfiling::StorageParams::StorageParams(llvm::StringRef ProfilePrefix, ClangTidyProfiling::StorageParams::StorageParams(llvm::StringRef ProfilePrefix,
llvm::StringRef SourceFile) llvm::StringRef SourceFile)
: Timestamp(std::chrono::system_clock::now()), SourceFilename(SourceFile) { : Timestamp(std::chrono::system_clock::now()), SourceFilename(SourceFile) {
llvm::SmallString<32> TimestampStr; llvm::SmallString<32> TimestampStr;
llvm::raw_svector_ostream OS(TimestampStr); llvm::raw_svector_ostream OS(TimestampStr);
llvm::format_provider<decltype(Timestamp)>::format(Timestamp, OS, llvm::format_provider<decltype(Timestamp)>::format(Timestamp, OS,
"%Y%m%d%H%M%S%N"); "%Y%m%d%H%M%S%N");
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 LinesClangTidyProfiling::~ClangTidyProfiling() {
TG.emplace("clang-tidy", "clang-tidy checks profiling", Records); TG.emplace("clang-tidy", "clang-tidy checks profiling", Records);
if (!Storage) if (!Storage)
printUserFriendlyTable(llvm::errs()); printUserFriendlyTable(llvm::errs());
else else
storeProfileData(); storeProfileData();
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetInfo.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/PreprocessorOptions.h" #include "clang/Lex/PreprocessorOptions.h"
#include "clang/Serialization/ASTReader.h" #include "clang/Serialization/ASTReader.h"
#include <optional> #include <optional>
#define DEBUG_TYPE "clang-tidy" #define DEBUG_TYPE "clang-tidy"
namespace clang { namespace clang::tooling {
namespace tooling {
class ExpandModularHeadersPPCallbacks::FileRecorder { class ExpandModularHeadersPPCallbacks::FileRecorder {
public: public:
/// Records that a given file entry is needed for replaying callbacks. /// Records that a given file entry is needed for replaying callbacks.
void addNecessaryFile(const FileEntry *File) { void addNecessaryFile(const FileEntry *File) {
// Don't record modulemap files because it breaks same file detection. // Don't record modulemap files because it breaks same file detection.
if (!(File->getName().endswith("module.modulemap") || if (!(File->getName().endswith("module.modulemap") ||
File->getName().endswith("module.private.modulemap") || File->getName().endswith("module.private.modulemap") ||
▲ Show 20 Lines • Show All 272 Lines • ▼ Show 20 Lines
void ExpandModularHeadersPPCallbacks::Else(SourceLocation Loc, SourceLocation) { void ExpandModularHeadersPPCallbacks::Else(SourceLocation Loc, SourceLocation) {
parseToLocation(Loc); parseToLocation(Loc);
} }
void ExpandModularHeadersPPCallbacks::Endif(SourceLocation Loc, void ExpandModularHeadersPPCallbacks::Endif(SourceLocation Loc,
SourceLocation) { SourceLocation) {
parseToLocation(Loc); parseToLocation(Loc);
} }
} // namespace tooling } // namespace clang::tooling
} // namespace clang

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

//===--- tools/extra/clang-tidy/GlobList.cpp ------------------------------===// //===--- tools/extra/clang-tidy/GlobList.cpp ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "GlobList.h" #include "GlobList.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
namespace clang { namespace clang::tidy {
namespace tidy {
// Returns true if GlobList starts with the negative indicator ('-'), removes it // Returns true if GlobList starts with the negative indicator ('-'), removes it
// from the GlobList. // from the GlobList.
static bool consumeNegativeIndicator(StringRef &GlobList) { static bool consumeNegativeIndicator(StringRef &GlobList) {
GlobList = GlobList.trim(); GlobList = GlobList.trim();
if (GlobList.startswith("-")) { if (GlobList.startswith("-")) {
GlobList = GlobList.substr(1); GlobList = GlobList.substr(1);
return true; return true;
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Linesbool CachedGlobList::contains(StringRef S) const {
auto Entry = Cache.try_emplace(S); auto Entry = Cache.try_emplace(S);
bool &Value = Entry.first->getValue(); bool &Value = Entry.first->getValue();
// If the entry was just inserted, determine its required value. // If the entry was just inserted, determine its required value.
if (Entry.second) if (Entry.second)
Value = GlobList::contains(S); Value = GlobList::contains(S);
return Value; return Value;
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

Show All 27 Lines
#include <cstddef> #include <cstddef>
#include <iterator> #include <iterator>
#include <optional> #include <optional>
#include <string> #include <string>
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
namespace clang { namespace clang::tidy {
namespace tidy {
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// NoLintType // NoLintType
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// The type - one of NOLINT[NEXTLINE/BEGIN/END]. // The type - one of NOLINT[NEXTLINE/BEGIN/END].
enum class NoLintType { NoLint, NoLintNextLine, NoLintBegin, NoLintEnd }; enum class NoLintType { NoLint, NoLintNextLine, NoLintBegin, NoLintEnd };
▲ Show 20 Lines • Show All 360 Lines • ▼ Show 20 Lines
bool NoLintDirectiveHandler::shouldSuppress( bool NoLintDirectiveHandler::shouldSuppress(
DiagnosticsEngine::Level DiagLevel, const Diagnostic &Diag, DiagnosticsEngine::Level DiagLevel, const Diagnostic &Diag,
StringRef DiagName, SmallVectorImpl<tooling::Diagnostic> &NoLintErrors, StringRef DiagName, SmallVectorImpl<tooling::Diagnostic> &NoLintErrors,
bool AllowIO, bool EnableNoLintBlocks) { bool AllowIO, bool EnableNoLintBlocks) {
return PImpl->shouldSuppress(DiagLevel, Diag, DiagName, NoLintErrors, AllowIO, return PImpl->shouldSuppress(DiagLevel, Diag, DiagName, NoLintErrors, AllowIO,
EnableNoLintBlocks); EnableNoLintBlocks);
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

Show All 23 Lines
#include "RedundantStrcatCallsCheck.h" #include "RedundantStrcatCallsCheck.h"
#include "StrCatAppendCheck.h" #include "StrCatAppendCheck.h"
#include "StringFindStartswithCheck.h" #include "StringFindStartswithCheck.h"
#include "StringFindStrContainsCheck.h" #include "StringFindStrContainsCheck.h"
#include "TimeComparisonCheck.h" #include "TimeComparisonCheck.h"
#include "TimeSubtractionCheck.h" #include "TimeSubtractionCheck.h"
#include "UpgradeDurationConversionsCheck.h" #include "UpgradeDurationConversionsCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace abseil { namespace abseil {
class AbseilModule : public ClangTidyModule { class AbseilModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<CleanupCtadCheck>("abseil-cleanup-ctad"); CheckFactories.registerCheck<CleanupCtadCheck>("abseil-cleanup-ctad");
CheckFactories.registerCheck<DurationAdditionCheck>( CheckFactories.registerCheck<DurationAdditionCheck>(
"abseil-duration-addition"); "abseil-duration-addition");
Show All 38 Linesstatic ClangTidyModuleRegistry::Add<AbseilModule> X("abseil-module",
"Add Abseil checks."); "Add Abseil checks.");
} // namespace abseil } // namespace abseil
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the AbseilModule. // and thus register the AbseilModule.
volatile int AbseilModuleAnchorSource = 0; volatile int AbseilModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

Show All 13 Lines
#include "clang/Tooling/Transformer/RangeSelector.h" #include "clang/Tooling/Transformer/RangeSelector.h"
#include "clang/Tooling/Transformer/RewriteRule.h" #include "clang/Tooling/Transformer/RewriteRule.h"
#include "clang/Tooling/Transformer/Stencil.h" #include "clang/Tooling/Transformer/Stencil.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
using namespace ::clang::ast_matchers; using namespace ::clang::ast_matchers;
using namespace ::clang::transformer; using namespace ::clang::transformer;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
RewriteRuleWith<std::string> CleanupCtadCheckImpl() { RewriteRuleWith<std::string> CleanupCtadCheckImpl() {
auto warning_message = cat("prefer absl::Cleanup's class template argument " auto warning_message = cat("prefer absl::Cleanup's class template argument "
"deduction pattern in C++17 and higher"); "deduction pattern in C++17 and higher");
return makeRule( return makeRule(
declStmt(hasSingleDecl(varDecl( declStmt(hasSingleDecl(varDecl(
hasType(autoType()), hasTypeLoc(typeLoc().bind("auto_type_loc")), hasType(autoType()), hasTypeLoc(typeLoc().bind("auto_type_loc")),
hasInitializer(hasDescendant( hasInitializer(hasDescendant(
callExpr(callee(functionDecl(hasName("absl::MakeCleanup"))), callExpr(callee(functionDecl(hasName("absl::MakeCleanup"))),
argumentCountIs(1)) argumentCountIs(1))
.bind("make_cleanup_call")))))), .bind("make_cleanup_call")))))),
{changeTo(node("auto_type_loc"), cat("absl::Cleanup")), {changeTo(node("auto_type_loc"), cat("absl::Cleanup")),
changeTo(node("make_cleanup_call"), cat(callArgs("make_cleanup_call")))}, changeTo(node("make_cleanup_call"), cat(callArgs("make_cleanup_call")))},
warning_message); warning_message);
} }
CleanupCtadCheck::CleanupCtadCheck(StringRef Name, ClangTidyContext *Context) CleanupCtadCheck::CleanupCtadCheck(StringRef Name, ClangTidyContext *Context)
: utils::TransformerClangTidyCheck(CleanupCtadCheckImpl(), Name, Context) {} : utils::TransformerClangTidyCheck(CleanupCtadCheckImpl(), Name, Context) {}
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "DurationRewriter.h" #include "DurationRewriter.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
void DurationAdditionCheck::registerMatchers(MatchFinder *Finder) { void DurationAdditionCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
binaryOperator(hasOperatorName("+"), binaryOperator(hasOperatorName("+"),
hasEitherOperand(expr(ignoringParenImpCasts( hasEitherOperand(expr(ignoringParenImpCasts(
callExpr(callee(functionDecl(TimeConversionFunction()) callExpr(callee(functionDecl(TimeConversionFunction())
.bind("function_decl"))) .bind("function_decl")))
.bind("call"))))) .bind("call")))))
Show All 35 Lines Hint = FixItHint::CreateReplacement(
" + " + tooling::fixit::getText(*Call->getArg(0), *Result.Context) + " + " + tooling::fixit::getText(*Call->getArg(0), *Result.Context) +
")") ")")
.str()); .str());
} }
diag(Binop->getBeginLoc(), "perform addition in the duration domain") << Hint; diag(Binop->getBeginLoc(), "perform addition in the duration domain") << Hint;
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "DurationRewriter.h" #include "DurationRewriter.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
void DurationComparisonCheck::registerMatchers(MatchFinder *Finder) { void DurationComparisonCheck::registerMatchers(MatchFinder *Finder) {
auto Matcher = expr(comparisonOperatorWithCallee(functionDecl( auto Matcher = expr(comparisonOperatorWithCallee(functionDecl(
functionDecl(DurationConversionFunction()) functionDecl(DurationConversionFunction())
.bind("function_decl")))) .bind("function_decl"))))
.bind("binop"); .bind("binop");
Finder->addMatcher(Matcher, this); Finder->addMatcher(Matcher, this);
Show All 21 Linesvoid DurationComparisonCheck::check(const MatchFinder::MatchResult &Result) {
diag(Binop->getBeginLoc(), "perform comparison in the duration domain") diag(Binop->getBeginLoc(), "perform comparison in the duration domain")
<< FixItHint::CreateReplacement(Binop->getSourceRange(), << FixItHint::CreateReplacement(Binop->getSourceRange(),
(llvm::Twine(LhsReplacement) + " " + (llvm::Twine(LhsReplacement) + " " +
Binop->getOpcodeStr() + " " + Binop->getOpcodeStr() + " " +
RhsReplacement) RhsReplacement)
.str()); .str());
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "DurationRewriter.h" #include "DurationRewriter.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
void DurationConversionCastCheck::registerMatchers(MatchFinder *Finder) { void DurationConversionCastCheck::registerMatchers(MatchFinder *Finder) {
auto CallMatcher = ignoringImpCasts(callExpr( auto CallMatcher = ignoringImpCasts(callExpr(
callee(functionDecl(DurationConversionFunction()).bind("func_decl")), callee(functionDecl(DurationConversionFunction()).bind("func_decl")),
hasArgument(0, expr().bind("arg")))); hasArgument(0, expr().bind("arg"))));
Finder->addMatcher( Finder->addMatcher(
expr(anyOf( expr(anyOf(
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines diag(MatchedCast->getBeginLoc(), "duration should be converted directly to "
<< FixItHint::CreateReplacement( << FixItHint::CreateReplacement(
MatchedCast->getSourceRange(), MatchedCast->getSourceRange(),
(llvm::Twine(NewFuncName.substr(2)) + "(" + (llvm::Twine(NewFuncName.substr(2)) + "(" +
tooling::fixit::getText(*Arg, *Result.Context) + ")") tooling::fixit::getText(*Arg, *Result.Context) + ")")
.str()); .str());
} }
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

//===--- DurationDivisionCheck.cpp - clang-tidy----------------------------===// //===--- DurationDivisionCheck.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DurationDivisionCheck.h" #include "DurationDivisionCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
void DurationDivisionCheck::registerMatchers(MatchFinder *Finder) { void DurationDivisionCheck::registerMatchers(MatchFinder *Finder) {
const auto DurationExpr = const auto DurationExpr =
expr(hasType(cxxRecordDecl(hasName("::absl::Duration")))); expr(hasType(cxxRecordDecl(hasName("::absl::Duration"))));
Finder->addMatcher( Finder->addMatcher(
traverse(TK_AsIs, traverse(TK_AsIs,
Show All 22 Lines diag(OpCall->getOperatorLoc(),
", ") ", ")
<< FixItHint::CreateInsertion( << FixItHint::CreateInsertion(
Lexer::getLocForEndOfToken( Lexer::getLocForEndOfToken(
Result.SourceManager->getSpellingLoc(OpCall->getEndLoc()), 0, Result.SourceManager->getSpellingLoc(OpCall->getEndLoc()), 0,
*Result.SourceManager, Result.Context->getLangOpts()), *Result.SourceManager, Result.Context->getLangOpts()),
")"); ")");
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
// Returns `true` if `Range` is inside a macro definition. // Returns `true` if `Range` is inside a macro definition.
static bool insideMacroDefinition(const MatchFinder::MatchResult &Result, static bool insideMacroDefinition(const MatchFinder::MatchResult &Result,
SourceRange Range) { SourceRange Range) {
return !clang::Lexer::makeFileCharRange( return !clang::Lexer::makeFileCharRange(
clang::CharSourceRange::getCharRange(Range), clang::CharSourceRange::getCharRange(Range),
*Result.SourceManager, Result.Context->getLangOpts()) *Result.SourceManager, Result.Context->getLangOpts())
.isValid(); .isValid();
Show All 31 Linesvoid DurationFactoryFloatCheck::check(const MatchFinder::MatchResult &Result) {
if (SimpleArg) { if (SimpleArg) {
diag(MatchedCall->getBeginLoc(), "use the integer version of absl::%0") diag(MatchedCall->getBeginLoc(), "use the integer version of absl::%0")
<< MatchedCall->getDirectCallee()->getName() << MatchedCall->getDirectCallee()->getName()
<< FixItHint::CreateReplacement(Arg->getSourceRange(), *SimpleArg); << FixItHint::CreateReplacement(Arg->getSourceRange(), *SimpleArg);
} }
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "DurationRewriter.h" #include "DurationRewriter.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
// Given the name of a duration factory function, return the appropriate // Given the name of a duration factory function, return the appropriate
// `DurationScale` for that factory. If no factory can be found for // `DurationScale` for that factory. If no factory can be found for
// `FactoryName`, return `std::nullopt`. // `FactoryName`, return `std::nullopt`.
static std::optional<DurationScale> static std::optional<DurationScale>
getScaleForFactory(llvm::StringRef FactoryName) { getScaleForFactory(llvm::StringRef FactoryName) {
return llvm::StringSwitch<std::optional<DurationScale>>(FactoryName) return llvm::StringSwitch<std::optional<DurationScale>>(FactoryName)
.Case("Nanoseconds", DurationScale::Nanoseconds) .Case("Nanoseconds", DurationScale::Nanoseconds)
▲ Show 20 Lines • Show All 190 Lines • ▼ Show 20 Lines diag(Call->getBeginLoc(), "internal duration scaling can be removed")
<< FixItHint::CreateReplacement( << FixItHint::CreateReplacement(
Call->getSourceRange(), Call->getSourceRange(),
(llvm::Twine(getDurationFactoryForScale(*NewScale)) + "(" + (llvm::Twine(getDurationFactoryForScale(*NewScale)) + "(" +
tooling::fixit::getText(*Remainder, *Result.Context) + ")") tooling::fixit::getText(*Remainder, *Result.Context) + ")")
.str()); .str());
} }
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include <optional> #include <optional>
#include "DurationRewriter.h" #include "DurationRewriter.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include "llvm/ADT/IndexedMap.h" #include "llvm/ADT/IndexedMap.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
struct DurationScale2IndexFunctor { struct DurationScale2IndexFunctor {
using argument_type = DurationScale; using argument_type = DurationScale;
unsigned operator()(DurationScale Scale) const { unsigned operator()(DurationScale Scale) const {
return static_cast<unsigned>(Scale); return static_cast<unsigned>(Scale);
} }
}; };
▲ Show 20 Lines • Show All 288 Lines • ▼ Show 20 Lines while (Result.SourceManager->isMacroArgExpansion(Loc)) {
// equivalent to calling getImmediateSpellingLoc in this context according // equivalent to calling getImmediateSpellingLoc in this context according
// to Clang implementation. We are not calling getImmediateSpellingLoc // to Clang implementation. We are not calling getImmediateSpellingLoc
// because Clang comment says it "should not generally be used by clients." // because Clang comment says it "should not generally be used by clients."
Loc = Result.SourceManager->getImmediateMacroCallerLoc(Loc); Loc = Result.SourceManager->getImmediateMacroCallerLoc(Loc);
} }
return Loc.isMacroID(); return Loc.isMacroID();
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "DurationRewriter.h" #include "DurationRewriter.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
void DurationSubtractionCheck::registerMatchers(MatchFinder *Finder) { void DurationSubtractionCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
binaryOperator( binaryOperator(
hasOperatorName("-"), hasOperatorName("-"),
hasLHS(callExpr(callee(functionDecl(DurationConversionFunction()) hasLHS(callExpr(callee(functionDecl(DurationConversionFunction())
.bind("function_decl")), .bind("function_decl")),
hasArgument(0, expr().bind("lhs_arg"))))) hasArgument(0, expr().bind("lhs_arg")))))
Show All 23 Lines diag(Binop->getBeginLoc(), "perform subtraction in the duration domain")
<< FixItHint::CreateReplacement( << FixItHint::CreateReplacement(
Binop->getSourceRange(), Binop->getSourceRange(),
(llvm::Twine("absl::") + FuncDecl->getName() + "(" + (llvm::Twine("absl::") + FuncDecl->getName() + "(" +
tooling::fixit::getText(*LhsArg, *Result.Context) + " - " + tooling::fixit::getText(*LhsArg, *Result.Context) + " - " +
RhsReplacement + ")") RhsReplacement + ")")
.str()); .str());
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "DurationUnnecessaryConversionCheck.h" #include "DurationUnnecessaryConversionCheck.h"
#include "DurationRewriter.h" #include "DurationRewriter.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
void DurationUnnecessaryConversionCheck::registerMatchers(MatchFinder *Finder) { void DurationUnnecessaryConversionCheck::registerMatchers(MatchFinder *Finder) {
for (const auto &Scale : {"Hours", "Minutes", "Seconds", "Milliseconds", for (const auto &Scale : {"Hours", "Minutes", "Seconds", "Milliseconds",
"Microseconds", "Nanoseconds"}) { "Microseconds", "Nanoseconds"}) {
std::string DurationFactory = (llvm::Twine("::absl::") + Scale).str(); std::string DurationFactory = (llvm::Twine("::absl::") + Scale).str();
std::string FloatConversion = std::string FloatConversion =
(llvm::Twine("::absl::ToDouble") + Scale).str(); (llvm::Twine("::absl::ToDouble") + Scale).str();
std::string IntegerConversion = std::string IntegerConversion =
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines Hint = FixItHint::CreateReplacement(
OuterCall->getSourceRange(), OuterCall->getSourceRange(),
tooling::fixit::getText(*Arg, *Result.Context)); tooling::fixit::getText(*Arg, *Result.Context));
} }
diag(OuterCall->getBeginLoc(), diag(OuterCall->getBeginLoc(),
"remove unnecessary absl::Duration conversions") "remove unnecessary absl::Duration conversions")
<< Hint; << Hint;
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

//===--- FasterStrsplitDelimiterCheck.cpp - clang-tidy---------------------===// //===--- FasterStrsplitDelimiterCheck.cpp - clang-tidy---------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FasterStrsplitDelimiterCheck.h" #include "FasterStrsplitDelimiterCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
namespace { namespace {
AST_MATCHER(StringLiteral, lengthIsOne) { return Node.getLength() == 1; } AST_MATCHER(StringLiteral, lengthIsOne) { return Node.getLength() == 1; }
std::optional<std::string> makeCharacterLiteral(const StringLiteral *Literal, std::optional<std::string> makeCharacterLiteral(const StringLiteral *Literal,
const ASTContext &Context) { const ASTContext &Context) {
assert(Literal->getLength() == 1 && assert(Literal->getLength() == 1 &&
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines diag(
"%select{absl::StrSplit()|absl::MaxSplits()}0 called with a string " "%select{absl::StrSplit()|absl::MaxSplits()}0 called with a string "
"literal " "literal "
"consisting of a single character; consider using the character overload") "consisting of a single character; consider using the character overload")
<< (Result.Nodes.getNodeAs<CallExpr>("StrSplit") ? 0 : 1) << (Result.Nodes.getNodeAs<CallExpr>("StrSplit") ? 0 : 1)
<< FixItHint::CreateReplacement(CharSourceRange::getTokenRange(Range), << FixItHint::CreateReplacement(CharSourceRange::getTokenRange(Range),
*Replacement); *Replacement);
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

//===--- NoInternalDependenciesCheck.cpp - clang-tidy----------------------===// //===--- NoInternalDependenciesCheck.cpp - clang-tidy----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NoInternalDependenciesCheck.h" #include "NoInternalDependenciesCheck.h"
#include "AbseilMatcher.h" #include "AbseilMatcher.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
void NoInternalDependenciesCheck::registerMatchers(MatchFinder *Finder) { void NoInternalDependenciesCheck::registerMatchers(MatchFinder *Finder) {
// TODO: refactor matcher to be configurable or just match on any internal // TODO: refactor matcher to be configurable or just match on any internal
// access from outside the enclosing namespace. // access from outside the enclosing namespace.
Finder->addMatcher( Finder->addMatcher(
nestedNameSpecifierLoc(loc(specifiesNamespace(namespaceDecl( nestedNameSpecifierLoc(loc(specifiesNamespace(namespaceDecl(
matchesName("internal"), matchesName("internal"),
Show All 13 Linesvoid NoInternalDependenciesCheck::check(const MatchFinder::MatchResult &Result) {
if (!LocAtFault.isValid()) if (!LocAtFault.isValid())
return; return;
diag(LocAtFault, diag(LocAtFault,
"do not reference any 'internal' namespaces; those implementation " "do not reference any 'internal' namespaces; those implementation "
"details are reserved to Abseil"); "details are reserved to Abseil");
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

//===--- NoNamespaceCheck.cpp - clang-tidy---------------------------------===// //===--- NoNamespaceCheck.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NoNamespaceCheck.h" #include "NoNamespaceCheck.h"
#include "AbseilMatcher.h" #include "AbseilMatcher.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
void NoNamespaceCheck::registerMatchers(MatchFinder *Finder) { void NoNamespaceCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
namespaceDecl(hasName("::absl"), unless(isInAbseilFile())) namespaceDecl(hasName("::absl"), unless(isInAbseilFile()))
.bind("abslNamespace"), .bind("abslNamespace"),
this); this);
} }
void NoNamespaceCheck::check(const MatchFinder::MatchResult &Result) { void NoNamespaceCheck::check(const MatchFinder::MatchResult &Result) {
const auto *AbslNamespaceDecl = const auto *AbslNamespaceDecl =
Result.Nodes.getNodeAs<NamespaceDecl>("abslNamespace"); Result.Nodes.getNodeAs<NamespaceDecl>("abslNamespace");
diag(AbslNamespaceDecl->getLocation(), diag(AbslNamespaceDecl->getLocation(),
"namespace 'absl' is reserved for implementation of the Abseil library " "namespace 'absl' is reserved for implementation of the Abseil library "
"and should not be opened in user code"); "and should not be opened in user code");
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

//===--- RedundantStrcatCallsCheck.cpp - clang-tidy------------------------===// //===--- RedundantStrcatCallsCheck.cpp - clang-tidy------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RedundantStrcatCallsCheck.h" #include "RedundantStrcatCallsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
// TODO: Features to add to the check: // TODO: Features to add to the check:
// - Make it work if num_args > 26. // - Make it work if num_args > 26.
// - Remove empty literal string arguments. // - Remove empty literal string arguments.
// - Collapse consecutive literal string arguments into one (remove the ,). // - Collapse consecutive literal string arguments into one (remove the ,).
// - Replace StrCat(a + b) -> StrCat(a, b) if a or b are strings. // - Replace StrCat(a + b) -> StrCat(a, b) if a or b are strings.
// - Make it work in macros if the outer and inner StrCats are both in the // - Make it work in macros if the outer and inner StrCats are both in the
// argument. // argument.
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Lines if (CheckResult.NumCalls == 1) {
return; return;
} }
diag(RootCall->getBeginLoc(), diag(RootCall->getBeginLoc(),
"multiple calls to 'absl::StrCat' can be flattened into a single call") "multiple calls to 'absl::StrCat' can be flattened into a single call")
<< CheckResult.Hints; << CheckResult.Hints;
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

//===--- StrCatAppendCheck.cpp - clang-tidy--------------------------------===// //===--- StrCatAppendCheck.cpp - clang-tidy--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StrCatAppendCheck.h" #include "StrCatAppendCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
namespace { namespace {
// Skips any combination of temporary materialization, temporary binding and // Skips any combination of temporary materialization, temporary binding and
// implicit casting. // implicit casting.
AST_MATCHER_P(Stmt, IgnoringTemporaries, ast_matchers::internal::Matcher<Stmt>, AST_MATCHER_P(Stmt, IgnoringTemporaries, ast_matchers::internal::Matcher<Stmt>,
InnerMatcher) { InnerMatcher) {
const Stmt *E = &Node; const Stmt *E = &Node;
while (true) { while (true) {
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines diag(Op->getBeginLoc(),
"string to avoid a performance penalty") "string to avoid a performance penalty")
<< FixItHint::CreateReplacement( << FixItHint::CreateReplacement(
CharSourceRange::getTokenRange(Op->getBeginLoc(), CharSourceRange::getTokenRange(Op->getBeginLoc(),
Call->getCallee()->getEndLoc()), Call->getCallee()->getEndLoc()),
"absl::StrAppend") "absl::StrAppend")
<< FixItHint::CreateInsertion(Call->getArg(0)->getBeginLoc(), "&"); << FixItHint::CreateInsertion(Call->getArg(0)->getBeginLoc(), "&");
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 11 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
StringFindStartswithCheck::StringFindStartswithCheck(StringRef Name, StringFindStartswithCheck::StringFindStartswithCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
StringLikeClasses(utils::options::parseStringList( StringLikeClasses(utils::options::parseStringList(
Options.get("StringLikeClasses", "::std::basic_string"))), Options.get("StringLikeClasses", "::std::basic_string"))),
IncludeInserter(Options.getLocalOrGlobal("IncludeStyle", IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
utils::IncludeSorter::IS_LLVM), utils::IncludeSorter::IS_LLVM),
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines
void StringFindStartswithCheck::storeOptions( void StringFindStartswithCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "StringLikeClasses", Options.store(Opts, "StringLikeClasses",
utils::options::serializeStringList(StringLikeClasses)); utils::options::serializeStringList(StringLikeClasses));
Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle()); Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
Options.store(Opts, "AbseilStringsMatchHeader", AbseilStringsMatchHeader); Options.store(Opts, "AbseilStringsMatchHeader", AbseilStringsMatchHeader);
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 14 Lines
#include "clang/Tooling/Transformer/RewriteRule.h" #include "clang/Tooling/Transformer/RewriteRule.h"
#include "clang/Tooling/Transformer/Stencil.h" #include "clang/Tooling/Transformer/Stencil.h"
// FixItHint - Hint to check documentation script to mark this check as // FixItHint - Hint to check documentation script to mark this check as
// providing a FixIt. // providing a FixIt.
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
using ::clang::transformer::addInclude; using ::clang::transformer::addInclude;
using ::clang::transformer::applyFirst; using ::clang::transformer::applyFirst;
using ::clang::transformer::cat; using ::clang::transformer::cat;
using ::clang::transformer::changeTo; using ::clang::transformer::changeTo;
using ::clang::transformer::makeRule; using ::clang::transformer::makeRule;
using ::clang::transformer::node; using ::clang::transformer::node;
using ::clang::transformer::RewriteRuleWith; using ::clang::transformer::RewriteRuleWith;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesvoid StringFindStrContainsCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
TransformerClangTidyCheck::storeOptions(Opts); TransformerClangTidyCheck::storeOptions(Opts);
Options.store(Opts, "StringLikeClasses", Options.store(Opts, "StringLikeClasses",
utils::options::serializeStringList(StringLikeClassesOption)); utils::options::serializeStringList(StringLikeClassesOption));
Options.store(Opts, "AbseilStringsMatchHeader", Options.store(Opts, "AbseilStringsMatchHeader",
AbseilStringsMatchHeaderOption); AbseilStringsMatchHeaderOption);
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "DurationRewriter.h" #include "DurationRewriter.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
void TimeComparisonCheck::registerMatchers(MatchFinder *Finder) { void TimeComparisonCheck::registerMatchers(MatchFinder *Finder) {
auto Matcher = auto Matcher =
expr(comparisonOperatorWithCallee(functionDecl( expr(comparisonOperatorWithCallee(functionDecl(
functionDecl(TimeConversionFunction()).bind("function_decl")))) functionDecl(TimeConversionFunction()).bind("function_decl"))))
.bind("binop"); .bind("binop");
Finder->addMatcher(Matcher, this); Finder->addMatcher(Matcher, this);
Show All 22 Linesvoid TimeComparisonCheck::check(const MatchFinder::MatchResult &Result) {
diag(Binop->getBeginLoc(), "perform comparison in the time domain") diag(Binop->getBeginLoc(), "perform comparison in the time domain")
<< FixItHint::CreateReplacement(Binop->getSourceRange(), << FixItHint::CreateReplacement(Binop->getSourceRange(),
(llvm::Twine(LhsReplacement) + " " + (llvm::Twine(LhsReplacement) + " " +
Binop->getOpcodeStr() + " " + Binop->getOpcodeStr() + " " +
RhsReplacement) RhsReplacement)
.str()); .str());
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
// Returns `true` if `Range` is inside a macro definition. // Returns `true` if `Range` is inside a macro definition.
static bool insideMacroDefinition(const MatchFinder::MatchResult &Result, static bool insideMacroDefinition(const MatchFinder::MatchResult &Result,
SourceRange Range) { SourceRange Range) {
return !clang::Lexer::makeFileCharRange( return !clang::Lexer::makeFileCharRange(
clang::CharSourceRange::getCharRange(Range), clang::CharSourceRange::getCharRange(Range),
*Result.SourceManager, Result.Context->getLangOpts()) *Result.SourceManager, Result.Context->getLangOpts())
.isValid(); .isValid();
▲ Show 20 Lines • Show All 162 Lines • ▼ Show 20 Lines if (MaybeCallArg && MaybeCallArg->getArg(0)->IgnoreImpCasts() == BinOp &&
"(" + rewriteExprFromNumberToTime(Result, *Scale, BinOp->getLHS()) + "(" + rewriteExprFromNumberToTime(Result, *Scale, BinOp->getLHS()) +
" - " + " - " +
rewriteExprFromNumberToTime(Result, *Scale, BinOp->getRHS()) + ")") rewriteExprFromNumberToTime(Result, *Scale, BinOp->getRHS()) + ")")
.str()); .str());
} }
} }
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

//===--- UpgradeDurationConversionsCheck.cpp - clang-tidy -----------------===// //===--- UpgradeDurationConversionsCheck.cpp - clang-tidy -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UpgradeDurationConversionsCheck.h" #include "UpgradeDurationConversionsCheck.h"
#include "DurationRewriter.h" #include "DurationRewriter.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::abseil {
namespace tidy {
namespace abseil {
void UpgradeDurationConversionsCheck::registerMatchers(MatchFinder *Finder) { void UpgradeDurationConversionsCheck::registerMatchers(MatchFinder *Finder) {
// For the arithmetic calls, we match only the uses of the templated operators // For the arithmetic calls, we match only the uses of the templated operators
// where the template parameter is not a built-in type. This means the // where the template parameter is not a built-in type. This means the
// instantiation makes use of an available user defined conversion to // instantiation makes use of an available user defined conversion to
// `int64_t`. // `int64_t`.
// //
// The implementation of these templates will be updated to fail SFINAE for // The implementation of these templates will be updated to fail SFINAE for
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines if (SourceRange.isInvalid())
// fix is likely needed so we do not create a fix-it hint. // fix is likely needed so we do not create a fix-it hint.
return; return;
Diag << FixItHint::CreateInsertion(SourceRange.getBegin(), Diag << FixItHint::CreateInsertion(SourceRange.getBegin(),
"static_cast<int64_t>(") "static_cast<int64_t>(")
<< FixItHint::CreateInsertion(SourceRange.getEnd(), ")"); << FixItHint::CreateInsertion(SourceRange.getEnd(), ")");
} }
} // namespace abseil } // namespace clang::tidy::abseil
} // namespace tidy
} // namespace clang

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

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef %(header_guard)s #ifndef %(header_guard)s
#define %(header_guard)s #define %(header_guard)s
#include "../ClangTidyCheck.h" #include "../ClangTidyCheck.h"
namespace clang { namespace clang::tidy::%(namespace)s {
namespace tidy {
namespace %(namespace)s {
/// FIXME: Write a short description. /// FIXME: Write a short description.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/%(module)s/%(check_name)s.html /// http://clang.llvm.org/extra/clang-tidy/checks/%(module)s/%(check_name)s.html
class %(check_name_camel)s : public ClangTidyCheck { class %(check_name_camel)s : public ClangTidyCheck {
public: public:
%(check_name_camel)s(StringRef Name, ClangTidyContext *Context) %(check_name_camel)s(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
}; };
} // namespace %(namespace)s } // namespace clang::tidy::%(namespace)s
} // namespace tidy
} // namespace clang
#endif // %(header_guard)s #endif // %(header_guard)s
""" % {'header_guard': header_guard, """ % {'header_guard': header_guard,
'check_name_camel': check_name_camel, 'check_name_camel': check_name_camel,
'check_name': check_name, 'check_name': check_name,
'module': module, 'module': module,
'namespace': namespace}) 'namespace': namespace})
Show All 17 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "%(check_name)s.h" #include "%(check_name)s.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::%(namespace)s {
namespace tidy {
namespace %(namespace)s {
void %(check_name)s::registerMatchers(MatchFinder *Finder) { void %(check_name)s::registerMatchers(MatchFinder *Finder) {
// FIXME: Add matchers. // FIXME: Add matchers.
Finder->addMatcher(functionDecl().bind("x"), this); Finder->addMatcher(functionDecl().bind("x"), this);
} }
void %(check_name)s::check(const MatchFinder::MatchResult &Result) { void %(check_name)s::check(const MatchFinder::MatchResult &Result) {
// FIXME: Add callback implementation. // FIXME: Add callback implementation.
const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("x"); const auto *MatchedDecl = Result.Nodes.getNodeAs<FunctionDecl>("x");
if (!MatchedDecl->getIdentifier() || MatchedDecl->getName().startswith("awesome_")) if (!MatchedDecl->getIdentifier() || MatchedDecl->getName().startswith("awesome_"))
return; return;
diag(MatchedDecl->getLocation(), "function %%0 is insufficiently awesome") diag(MatchedDecl->getLocation(), "function %%0 is insufficiently awesome")
<< MatchedDecl; << MatchedDecl;
diag(MatchedDecl->getLocation(), "insert 'awesome'", DiagnosticIDs::Note) diag(MatchedDecl->getLocation(), "insert 'awesome'", DiagnosticIDs::Note)
<< FixItHint::CreateInsertion(MatchedDecl->getLocation(), "awesome_"); << FixItHint::CreateInsertion(MatchedDecl->getLocation(), "awesome_");
} }
} // namespace %(namespace)s } // namespace clang::tidy::%(namespace)s
} // namespace tidy
} // namespace clang
""" % {'check_name': check_name_camel, """ % {'check_name': check_name_camel,
'module': module, 'module': module,
'namespace': namespace}) 'namespace': namespace})
# Returns the source filename that implements the module. # Returns the source filename that implements the module.
def get_module_filename(module_path, module): def get_module_filename(module_path, module):
modulecpp = list(filter( modulecpp = list(filter(
▲ Show 20 Lines • Show All 432 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/altera/AlteraTidyModule.cpp

Show All 11 Lines
#include "IdDependentBackwardBranchCheck.h" #include "IdDependentBackwardBranchCheck.h"
#include "KernelNameRestrictionCheck.h" #include "KernelNameRestrictionCheck.h"
#include "SingleWorkItemBarrierCheck.h" #include "SingleWorkItemBarrierCheck.h"
#include "StructPackAlignCheck.h" #include "StructPackAlignCheck.h"
#include "UnrollLoopsCheck.h" #include "UnrollLoopsCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
namespace altera { namespace altera {
class AlteraModule : public ClangTidyModule { class AlteraModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<IdDependentBackwardBranchCheck>( CheckFactories.registerCheck<IdDependentBackwardBranchCheck>(
"altera-id-dependent-backward-branch"); "altera-id-dependent-backward-branch");
CheckFactories.registerCheck<KernelNameRestrictionCheck>( CheckFactories.registerCheck<KernelNameRestrictionCheck>(
Show All 11 Lines
// Register the AlteraTidyModule using this statically initialized variable. // Register the AlteraTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<altera::AlteraModule> static ClangTidyModuleRegistry::Add<altera::AlteraModule>
X("altera-module", "Adds Altera FPGA OpenCL lint checks."); X("altera-module", "Adds Altera FPGA OpenCL lint checks.");
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the AlteraModule. // and thus register the AlteraModule.
volatile int AlteraModuleAnchorSource = 0; volatile int AlteraModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/altera/IdDependentBackwardBranchCheck.cpp

//===--- IdDependentBackwardBranchCheck.cpp - clang-tidy ------------------===// //===--- IdDependentBackwardBranchCheck.cpp - clang-tidy ------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "IdDependentBackwardBranchCheck.h" #include "IdDependentBackwardBranchCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::altera {
namespace tidy {
namespace altera {
void IdDependentBackwardBranchCheck::registerMatchers(MatchFinder *Finder) { void IdDependentBackwardBranchCheck::registerMatchers(MatchFinder *Finder) {
// Prototype to identify all variables which hold a thread-variant ID. // Prototype to identify all variables which hold a thread-variant ID.
// First Matcher just finds all the direct assignments of either ID call. // First Matcher just finds all the direct assignments of either ID call.
const auto ThreadID = expr(hasDescendant(callExpr(callee(functionDecl( const auto ThreadID = expr(hasDescendant(callExpr(callee(functionDecl(
anyOf(hasName("get_global_id"), hasName("get_local_id"))))))); anyOf(hasName("get_global_id"), hasName("get_local_id")))))));
const auto RefVarOrField = forEachDescendant( const auto RefVarOrField = forEachDescendant(
▲ Show 20 Lines • Show All 228 Lines • ▼ Show 20 Lines if (IdDepVar) {
diag(CondExpr->getBeginLoc(), diag(CondExpr->getBeginLoc(),
"backward branch (%select{do|while|for}0 loop) is ID-dependent due " "backward branch (%select{do|while|for}0 loop) is ID-dependent due "
"to member reference to %1 and may cause performance degradation") "to member reference to %1 and may cause performance degradation")
<< Type << IdDepField->FieldDeclaration; << Type << IdDepField->FieldDeclaration;
} }
} }
} }
} // namespace altera } // namespace clang::tidy::altera
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/altera/KernelNameRestrictionCheck.cpp

Show All 9 Lines
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include <string> #include <string>
#include <vector> #include <vector>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::altera {
namespace tidy {
namespace altera {
namespace { namespace {
class KernelNameRestrictionPPCallbacks : public PPCallbacks { class KernelNameRestrictionPPCallbacks : public PPCallbacks {
public: public:
explicit KernelNameRestrictionPPCallbacks(ClangTidyCheck &Check, explicit KernelNameRestrictionPPCallbacks(ClangTidyCheck &Check,
const SourceManager &SM) const SourceManager &SM)
: Check(Check), SM(SM) {} : Check(Check), SM(SM) {}
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines if (fileNameIsRestricted(FileName))
Check.diag(ID.Loc, Check.diag(ID.Loc,
"including '%0' may cause additional compilation errors due " "including '%0' may cause additional compilation errors due "
"to the name of the kernel source file; consider renaming the " "to the name of the kernel source file; consider renaming the "
"included kernel source file") "included kernel source file")
<< FileName; << FileName;
} }
} }
} // namespace altera } // namespace clang::tidy::altera
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/altera/SingleWorkItemBarrierCheck.cpp

//===--- SingleWorkItemBarrierCheck.cpp - clang-tidy-----------------------===// //===--- SingleWorkItemBarrierCheck.cpp - clang-tidy-----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SingleWorkItemBarrierCheck.h" #include "SingleWorkItemBarrierCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::altera {
namespace tidy {
namespace altera {
void SingleWorkItemBarrierCheck::registerMatchers(MatchFinder *Finder) { void SingleWorkItemBarrierCheck::registerMatchers(MatchFinder *Finder) {
// Find any function that calls barrier but does not call an ID function. // Find any function that calls barrier but does not call an ID function.
// hasAttr(attr::Kind::OpenCLKernel) restricts it to only kernel functions. // hasAttr(attr::Kind::OpenCLKernel) restricts it to only kernel functions.
// FIXME: Have it accept all functions but check for a parameter that gets an // FIXME: Have it accept all functions but check for a parameter that gets an
// ID from one of the four ID functions. // ID from one of the four ID functions.
Finder->addMatcher( Finder->addMatcher(
// Find function declarations... // Find function declarations...
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Linesvoid SingleWorkItemBarrierCheck::check(const MatchFinder::MatchResult &Result) {
} }
} }
void SingleWorkItemBarrierCheck::storeOptions( void SingleWorkItemBarrierCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "AOCVersion", AOCVersion); Options.store(Opts, "AOCVersion", AOCVersion);
} }
} // namespace altera } // namespace clang::tidy::altera
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/altera/StructPackAlignCheck.cpp

//===--- StructPackAlignCheck.cpp - clang-tidy ----------------------------===// //===--- StructPackAlignCheck.cpp - clang-tidy ----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StructPackAlignCheck.h" #include "StructPackAlignCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/RecordLayout.h" #include "clang/AST/RecordLayout.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <math.h> #include <math.h>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::altera {
namespace tidy {
namespace altera {
void StructPackAlignCheck::registerMatchers(MatchFinder *Finder) { void StructPackAlignCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(recordDecl(isStruct(), isDefinition(), Finder->addMatcher(recordDecl(isStruct(), isDefinition(),
unless(isExpansionInSystemHeader())) unless(isExpansionInSystemHeader()))
.bind("struct"), .bind("struct"),
this); this);
} }
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines diag(Struct->getLocation(),
<< NewAlignQuantity << Struct; << NewAlignQuantity << Struct;
} }
} }
void StructPackAlignCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void StructPackAlignCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "MaxConfiguredAlignment", MaxConfiguredAlignment); Options.store(Opts, "MaxConfiguredAlignment", MaxConfiguredAlignment);
} }
} // namespace altera } // namespace clang::tidy::altera
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/altera/UnrollLoopsCheck.cpp

Show All 11 Lines
#include "clang/AST/ASTTypeTraits.h" #include "clang/AST/ASTTypeTraits.h"
#include "clang/AST/OperationKinds.h" #include "clang/AST/OperationKinds.h"
#include "clang/AST/ParentMapContext.h" #include "clang/AST/ParentMapContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <math.h> #include <math.h>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::altera {
namespace tidy {
namespace altera {
UnrollLoopsCheck::UnrollLoopsCheck(StringRef Name, ClangTidyContext *Context) UnrollLoopsCheck::UnrollLoopsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
MaxLoopIterations(Options.get("MaxLoopIterations", 100U)) {} MaxLoopIterations(Options.get("MaxLoopIterations", 100U)) {}
void UnrollLoopsCheck::registerMatchers(MatchFinder *Finder) { void UnrollLoopsCheck::registerMatchers(MatchFinder *Finder) {
const auto HasLoopBound = hasDescendant( const auto HasLoopBound = hasDescendant(
varDecl(allOf(matchesName("__end*"), varDecl(allOf(matchesName("__end*"),
▲ Show 20 Lines • Show All 231 Lines • ▼ Show 20 Linesbool UnrollLoopsCheck::exprHasLargeNumIterations(const Expr *Expression,
// iterations. // iterations.
return false; return false;
} }
void UnrollLoopsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void UnrollLoopsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "MaxLoopIterations", MaxLoopIterations); Options.store(Opts, "MaxLoopIterations", MaxLoopIterations);
} }
} // namespace altera } // namespace clang::tidy::altera
} // namespace tidy
} // namespace clang

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

Show All 21 Lines
#include "CloexecOpenCheck.h" #include "CloexecOpenCheck.h"
#include "CloexecPipe2Check.h" #include "CloexecPipe2Check.h"
#include "CloexecPipeCheck.h" #include "CloexecPipeCheck.h"
#include "CloexecSocketCheck.h" #include "CloexecSocketCheck.h"
#include "ComparisonInTempFailureRetryCheck.h" #include "ComparisonInTempFailureRetryCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
namespace android { namespace android {
/// This module is for Android specific checks. /// This module is for Android specific checks.
class AndroidModule : public ClangTidyModule { class AndroidModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<CloexecAccept4Check>("android-cloexec-accept4"); CheckFactories.registerCheck<CloexecAccept4Check>("android-cloexec-accept4");
CheckFactories.registerCheck<CloexecAcceptCheck>("android-cloexec-accept"); CheckFactories.registerCheck<CloexecAcceptCheck>("android-cloexec-accept");
Show All 24 Linesstatic ClangTidyModuleRegistry::Add<AndroidModule>
X("android-module", "Adds Android platform checks."); X("android-module", "Adds Android platform checks.");
} // namespace android } // namespace android
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the AndroidModule. // and thus register the AndroidModule.
volatile int AndroidModuleAnchorSource = 0; volatile int AndroidModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

//===--- CloexecAccept4Check.cpp - clang-tidy------------------------------===// //===--- CloexecAccept4Check.cpp - clang-tidy------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecAccept4Check.h" #include "CloexecAccept4Check.h"
#include "../utils/ASTUtils.h" #include "../utils/ASTUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecAccept4Check::registerMatchers(MatchFinder *Finder) { void CloexecAccept4Check::registerMatchers(MatchFinder *Finder) {
auto SockAddrPointerType = auto SockAddrPointerType =
hasType(pointsTo(recordDecl(isStruct(), hasName("sockaddr")))); hasType(pointsTo(recordDecl(isStruct(), hasName("sockaddr"))));
auto SockLenPointerType = hasType(pointsTo(namedDecl(hasName("socklen_t")))); auto SockLenPointerType = hasType(pointsTo(namedDecl(hasName("socklen_t"))));
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(returns(isInteger()), hasName("accept4"), functionDecl(returns(isInteger()), hasName("accept4"),
hasParameter(0, hasType(isInteger())), hasParameter(0, hasType(isInteger())),
hasParameter(1, SockAddrPointerType), hasParameter(1, SockAddrPointerType),
hasParameter(2, SockLenPointerType), hasParameter(2, SockLenPointerType),
hasParameter(3, hasType(isInteger())))); hasParameter(3, hasType(isInteger()))));
} }
void CloexecAccept4Check::check(const MatchFinder::MatchResult &Result) { void CloexecAccept4Check::check(const MatchFinder::MatchResult &Result) {
insertMacroFlag(Result, /*MacroFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/3); insertMacroFlag(Result, /*MacroFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/3);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecAcceptCheck.cpp - clang-tidy-------------------------------===// //===--- CloexecAcceptCheck.cpp - clang-tidy-------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecAcceptCheck.h" #include "CloexecAcceptCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecAcceptCheck::registerMatchers(MatchFinder *Finder) { void CloexecAcceptCheck::registerMatchers(MatchFinder *Finder) {
auto SockAddrPointerType = auto SockAddrPointerType =
hasType(pointsTo(recordDecl(isStruct(), hasName("sockaddr")))); hasType(pointsTo(recordDecl(isStruct(), hasName("sockaddr"))));
auto SockLenPointerType = hasType(pointsTo(namedDecl(hasName("socklen_t")))); auto SockLenPointerType = hasType(pointsTo(namedDecl(hasName("socklen_t"))));
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(returns(isInteger()), hasName("accept"), functionDecl(returns(isInteger()), hasName("accept"),
Show All 10 Lines std::string ReplacementText =
.str(); .str();
replaceFunc( replaceFunc(
Result, Result,
"prefer accept4() to accept() because accept4() allows SOCK_CLOEXEC", "prefer accept4() to accept() because accept4() allows SOCK_CLOEXEC",
ReplacementText); ReplacementText);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecCheck.cpp - clang-tidy-------------------------------------===// //===--- CloexecCheck.cpp - clang-tidy-------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecCheck.h" #include "CloexecCheck.h"
#include "../utils/ASTUtils.h" #include "../utils/ASTUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
namespace { namespace {
// Helper function to form the correct string mode for Type3. // Helper function to form the correct string mode for Type3.
// Build the replace text. If it's string constant, add <Mode> directly in the // Build the replace text. If it's string constant, add <Mode> directly in the
// end of the string. Else, add <Mode>. // end of the string. Else, add <Mode>.
std::string buildFixMsgForStringFlag(const Expr *Arg, const SourceManager &SM, std::string buildFixMsgForStringFlag(const Expr *Arg, const SourceManager &SM,
const LangOptions &LangOpts, char Mode) { const LangOptions &LangOpts, char Mode) {
if (Arg->getBeginLoc().isMacroID()) if (Arg->getBeginLoc().isMacroID())
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 LinesStringRef CloexecCheck::getSpellingArg(const MatchFinder::MatchResult &Result,
int N) const { int N) const {
const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr); const auto *MatchedCall = Result.Nodes.getNodeAs<CallExpr>(FuncBindingStr);
const SourceManager &SM = *Result.SourceManager; const SourceManager &SM = *Result.SourceManager;
return Lexer::getSourceText( return Lexer::getSourceText(
CharSourceRange::getTokenRange(MatchedCall->getArg(N)->getSourceRange()), CharSourceRange::getTokenRange(MatchedCall->getArg(N)->getSourceRange()),
SM, Result.Context->getLangOpts()); SM, Result.Context->getLangOpts());
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecCreatCheck.cpp - clang-tidy--------------------------------===// //===--- CloexecCreatCheck.cpp - clang-tidy--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecCreatCheck.h" #include "CloexecCreatCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecCreatCheck::registerMatchers(MatchFinder *Finder) { void CloexecCreatCheck::registerMatchers(MatchFinder *Finder) {
auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter()))); auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter())));
auto MODETType = hasType(namedDecl(hasName("mode_t"))); auto MODETType = hasType(namedDecl(hasName("mode_t")));
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(isExternC(), returns(isInteger()), functionDecl(isExternC(), returns(isInteger()),
hasName("creat"), hasName("creat"),
hasParameter(0, CharPointerType), hasParameter(0, CharPointerType),
hasParameter(1, MODETType))); hasParameter(1, MODETType)));
} }
void CloexecCreatCheck::check(const MatchFinder::MatchResult &Result) { void CloexecCreatCheck::check(const MatchFinder::MatchResult &Result) {
const std::string &ReplacementText = const std::string &ReplacementText =
(Twine("open (") + getSpellingArg(Result, 0) + (Twine("open (") + getSpellingArg(Result, 0) +
", O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, " + ", O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, " +
getSpellingArg(Result, 1) + ")") getSpellingArg(Result, 1) + ")")
.str(); .str();
replaceFunc(Result, replaceFunc(Result,
"prefer open() to creat() because open() allows O_CLOEXEC", "prefer open() to creat() because open() allows O_CLOEXEC",
ReplacementText); ReplacementText);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecDupCheck.cpp - clang-tidy----------------------------------===// //===--- CloexecDupCheck.cpp - clang-tidy----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecDupCheck.h" #include "CloexecDupCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecDupCheck::registerMatchers(MatchFinder *Finder) { void CloexecDupCheck::registerMatchers(MatchFinder *Finder) {
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(returns(isInteger()), hasName("dup"), functionDecl(returns(isInteger()), hasName("dup"),
hasParameter(0, hasType(isInteger())))); hasParameter(0, hasType(isInteger()))));
} }
void CloexecDupCheck::check(const MatchFinder::MatchResult &Result) { void CloexecDupCheck::check(const MatchFinder::MatchResult &Result) {
std::string ReplacementText = std::string ReplacementText =
(Twine("fcntl(") + getSpellingArg(Result, 0) + ", F_DUPFD_CLOEXEC)") (Twine("fcntl(") + getSpellingArg(Result, 0) + ", F_DUPFD_CLOEXEC)")
.str(); .str();
replaceFunc(Result, replaceFunc(Result,
"prefer fcntl() to dup() because fcntl() allows F_DUPFD_CLOEXEC", "prefer fcntl() to dup() because fcntl() allows F_DUPFD_CLOEXEC",
ReplacementText); ReplacementText);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecEpollCreate1Check.cpp - clang-tidy-------------------------===// //===--- CloexecEpollCreate1Check.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecEpollCreate1Check.h" #include "CloexecEpollCreate1Check.h"
#include "../utils/ASTUtils.h" #include "../utils/ASTUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecEpollCreate1Check::registerMatchers(MatchFinder *Finder) { void CloexecEpollCreate1Check::registerMatchers(MatchFinder *Finder) {
registerMatchersImpl( registerMatchersImpl(
Finder, functionDecl(returns(isInteger()), hasName("epoll_create1"), Finder, functionDecl(returns(isInteger()), hasName("epoll_create1"),
hasParameter(0, hasType(isInteger())))); hasParameter(0, hasType(isInteger()))));
} }
void CloexecEpollCreate1Check::check(const MatchFinder::MatchResult &Result) { void CloexecEpollCreate1Check::check(const MatchFinder::MatchResult &Result) {
insertMacroFlag(Result, /*MacroFlag=*/"EPOLL_CLOEXEC", /*ArgPos=*/0); insertMacroFlag(Result, /*MacroFlag=*/"EPOLL_CLOEXEC", /*ArgPos=*/0);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecEpollCreateCheck.cpp - clang-tidy--------------------------===// //===--- CloexecEpollCreateCheck.cpp - clang-tidy--------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecEpollCreateCheck.h" #include "CloexecEpollCreateCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecEpollCreateCheck::registerMatchers(MatchFinder *Finder) { void CloexecEpollCreateCheck::registerMatchers(MatchFinder *Finder) {
registerMatchersImpl( registerMatchersImpl(
Finder, functionDecl(returns(isInteger()), hasName("epoll_create"), Finder, functionDecl(returns(isInteger()), hasName("epoll_create"),
hasParameter(0, hasType(isInteger())))); hasParameter(0, hasType(isInteger()))));
} }
void CloexecEpollCreateCheck::check(const MatchFinder::MatchResult &Result) { void CloexecEpollCreateCheck::check(const MatchFinder::MatchResult &Result) {
replaceFunc(Result, replaceFunc(Result,
"prefer epoll_create() to epoll_create1() " "prefer epoll_create() to epoll_create1() "
"because epoll_create1() allows " "because epoll_create1() allows "
"EPOLL_CLOEXEC", "EPOLL_CLOEXEC",
"epoll_create1(EPOLL_CLOEXEC)"); "epoll_create1(EPOLL_CLOEXEC)");
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecFopenCheck.cpp - clang-tidy--------------------------------===// //===--- CloexecFopenCheck.cpp - clang-tidy--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecFopenCheck.h" #include "CloexecFopenCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/Type.h" #include "clang/AST/Type.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecFopenCheck::registerMatchers(MatchFinder *Finder) { void CloexecFopenCheck::registerMatchers(MatchFinder *Finder) {
auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter()))); auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter())));
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(isExternC(), returns(asString("FILE *")), functionDecl(isExternC(), returns(asString("FILE *")),
hasName("fopen"), hasName("fopen"),
hasParameter(0, CharPointerType), hasParameter(0, CharPointerType),
hasParameter(1, CharPointerType))); hasParameter(1, CharPointerType)));
} }
void CloexecFopenCheck::check(const MatchFinder::MatchResult &Result) { void CloexecFopenCheck::check(const MatchFinder::MatchResult &Result) {
insertStringFlag(Result, /*Mode=*/'e', /*ArgPos=*/1); insertStringFlag(Result, /*Mode=*/'e', /*ArgPos=*/1);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecInotifyInit1Check.cpp - clang-tidy-------------------------===// //===--- CloexecInotifyInit1Check.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecInotifyInit1Check.h" #include "CloexecInotifyInit1Check.h"
#include "../utils/ASTUtils.h" #include "../utils/ASTUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecInotifyInit1Check::registerMatchers(MatchFinder *Finder) { void CloexecInotifyInit1Check::registerMatchers(MatchFinder *Finder) {
registerMatchersImpl( registerMatchersImpl(
Finder, functionDecl(returns(isInteger()), hasName("inotify_init1"), Finder, functionDecl(returns(isInteger()), hasName("inotify_init1"),
hasParameter(0, hasType(isInteger())))); hasParameter(0, hasType(isInteger()))));
} }
void CloexecInotifyInit1Check::check(const MatchFinder::MatchResult &Result) { void CloexecInotifyInit1Check::check(const MatchFinder::MatchResult &Result) {
insertMacroFlag(Result, /*MacroFlag=*/"IN_CLOEXEC", /*ArgPos=*/0); insertMacroFlag(Result, /*MacroFlag=*/"IN_CLOEXEC", /*ArgPos=*/0);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecInotifyInitCheck.cpp - clang-tidy--------------------------===// //===--- CloexecInotifyInitCheck.cpp - clang-tidy--------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecInotifyInitCheck.h" #include "CloexecInotifyInitCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecInotifyInitCheck::registerMatchers(MatchFinder *Finder) { void CloexecInotifyInitCheck::registerMatchers(MatchFinder *Finder) {
registerMatchersImpl( registerMatchersImpl(
Finder, functionDecl(returns(isInteger()), hasName("inotify_init"))); Finder, functionDecl(returns(isInteger()), hasName("inotify_init")));
} }
void CloexecInotifyInitCheck::check(const MatchFinder::MatchResult &Result) { void CloexecInotifyInitCheck::check(const MatchFinder::MatchResult &Result) {
replaceFunc(Result, /*WarningMsg=*/ replaceFunc(Result, /*WarningMsg=*/
"prefer inotify_init() to inotify_init1() " "prefer inotify_init() to inotify_init1() "
"because inotify_init1() allows IN_CLOEXEC", "because inotify_init1() allows IN_CLOEXEC",
/*FixMsg=*/"inotify_init1(IN_CLOEXEC)"); /*FixMsg=*/"inotify_init1(IN_CLOEXEC)");
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecMemfdCreateCheck.cpp - clang-tidy--------------------------===// //===--- CloexecMemfdCreateCheck.cpp - clang-tidy--------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecMemfdCreateCheck.h" #include "CloexecMemfdCreateCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecMemfdCreateCheck::registerMatchers(MatchFinder *Finder) { void CloexecMemfdCreateCheck::registerMatchers(MatchFinder *Finder) {
auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter()))); auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter())));
registerMatchersImpl( registerMatchersImpl(
Finder, functionDecl(returns(isInteger()), hasName("memfd_create"), Finder, functionDecl(returns(isInteger()), hasName("memfd_create"),
hasParameter(0, CharPointerType), hasParameter(0, CharPointerType),
hasParameter(1, hasType(isInteger())))); hasParameter(1, hasType(isInteger()))));
} }
void CloexecMemfdCreateCheck::check(const MatchFinder::MatchResult &Result) { void CloexecMemfdCreateCheck::check(const MatchFinder::MatchResult &Result) {
insertMacroFlag(Result, "MFD_CLOEXEC", /*ArgPos=*/1); insertMacroFlag(Result, "MFD_CLOEXEC", /*ArgPos=*/1);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecOpenCheck.cpp - clang-tidy---------------------------------===// //===--- CloexecOpenCheck.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecOpenCheck.h" #include "CloexecOpenCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecOpenCheck::registerMatchers(MatchFinder *Finder) { void CloexecOpenCheck::registerMatchers(MatchFinder *Finder) {
auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter()))); auto CharPointerType = hasType(pointerType(pointee(isAnyCharacter())));
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(isExternC(), returns(isInteger()), functionDecl(isExternC(), returns(isInteger()),
hasAnyName("open", "open64"), hasAnyName("open", "open64"),
hasParameter(0, CharPointerType), hasParameter(0, CharPointerType),
hasParameter(1, hasType(isInteger())))); hasParameter(1, hasType(isInteger()))));
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(isExternC(), returns(isInteger()), functionDecl(isExternC(), returns(isInteger()),
hasName("openat"), hasName("openat"),
hasParameter(0, hasType(isInteger())), hasParameter(0, hasType(isInteger())),
hasParameter(1, CharPointerType), hasParameter(1, CharPointerType),
hasParameter(2, hasType(isInteger())))); hasParameter(2, hasType(isInteger()))));
} }
void CloexecOpenCheck::check(const MatchFinder::MatchResult &Result) { void CloexecOpenCheck::check(const MatchFinder::MatchResult &Result) {
const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>(FuncDeclBindingStr); const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>(FuncDeclBindingStr);
assert(FD->param_size() > 1); assert(FD->param_size() > 1);
int ArgPos = (FD->param_size() > 2) ? 2 : 1; int ArgPos = (FD->param_size() > 2) ? 2 : 1;
insertMacroFlag(Result, /*MacroFlag=*/"O_CLOEXEC", ArgPos); insertMacroFlag(Result, /*MacroFlag=*/"O_CLOEXEC", ArgPos);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecPipe2Check.cpp - clang-tidy--------------------------------===// //===--- CloexecPipe2Check.cpp - clang-tidy--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecPipe2Check.h" #include "CloexecPipe2Check.h"
#include "../utils/ASTUtils.h" #include "../utils/ASTUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecPipe2Check::registerMatchers(MatchFinder *Finder) { void CloexecPipe2Check::registerMatchers(MatchFinder *Finder) {
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(returns(isInteger()), hasName("pipe2"), functionDecl(returns(isInteger()), hasName("pipe2"),
hasParameter(0, hasType(pointsTo(isInteger()))), hasParameter(0, hasType(pointsTo(isInteger()))),
hasParameter(1, hasType(isInteger())))); hasParameter(1, hasType(isInteger()))));
} }
void CloexecPipe2Check::check(const MatchFinder::MatchResult &Result) { void CloexecPipe2Check::check(const MatchFinder::MatchResult &Result) {
insertMacroFlag(Result, /*MacroFlag=*/"O_CLOEXEC", /*ArgPos=*/1); insertMacroFlag(Result, /*MacroFlag=*/"O_CLOEXEC", /*ArgPos=*/1);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecPipeCheck.cpp - clang-tidy---------------------------------===// //===--- CloexecPipeCheck.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecPipeCheck.h" #include "CloexecPipeCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecPipeCheck::registerMatchers(MatchFinder *Finder) { void CloexecPipeCheck::registerMatchers(MatchFinder *Finder) {
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(returns(isInteger()), hasName("pipe"), functionDecl(returns(isInteger()), hasName("pipe"),
hasParameter(0, hasType(pointsTo(isInteger()))))); hasParameter(0, hasType(pointsTo(isInteger())))));
} }
void CloexecPipeCheck::check(const MatchFinder::MatchResult &Result) { void CloexecPipeCheck::check(const MatchFinder::MatchResult &Result) {
std::string ReplacementText = std::string ReplacementText =
(Twine("pipe2(") + getSpellingArg(Result, 0) + ", O_CLOEXEC)").str(); (Twine("pipe2(") + getSpellingArg(Result, 0) + ", O_CLOEXEC)").str();
replaceFunc( replaceFunc(
Result, Result,
"prefer pipe2() with O_CLOEXEC to avoid leaking file descriptors to child processes", "prefer pipe2() with O_CLOEXEC to avoid leaking file descriptors to child processes",
ReplacementText); ReplacementText);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- CloexecSocketCheck.cpp - clang-tidy-------------------------------===// //===--- CloexecSocketCheck.cpp - clang-tidy-------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CloexecSocketCheck.h" #include "CloexecSocketCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
void CloexecSocketCheck::registerMatchers(MatchFinder *Finder) { void CloexecSocketCheck::registerMatchers(MatchFinder *Finder) {
registerMatchersImpl(Finder, registerMatchersImpl(Finder,
functionDecl(isExternC(), returns(isInteger()), functionDecl(isExternC(), returns(isInteger()),
hasName("socket"), hasName("socket"),
hasParameter(0, hasType(isInteger())), hasParameter(0, hasType(isInteger())),
hasParameter(1, hasType(isInteger())), hasParameter(1, hasType(isInteger())),
hasParameter(2, hasType(isInteger())))); hasParameter(2, hasType(isInteger()))));
} }
void CloexecSocketCheck::check(const MatchFinder::MatchResult &Result) { void CloexecSocketCheck::check(const MatchFinder::MatchResult &Result) {
insertMacroFlag(Result, /*MacroFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/1); insertMacroFlag(Result, /*MacroFlag=*/"SOCK_CLOEXEC", /*ArgPos=*/1);
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===--- ComparisonInTempFailureRetryCheck.cpp - clang-tidy----------------===// //===--- ComparisonInTempFailureRetryCheck.cpp - clang-tidy----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "ComparisonInTempFailureRetryCheck.h" #include "ComparisonInTempFailureRetryCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::android {
namespace tidy {
namespace android {
ComparisonInTempFailureRetryCheck::ComparisonInTempFailureRetryCheck( ComparisonInTempFailureRetryCheck::ComparisonInTempFailureRetryCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
RawRetryList(Options.get("RetryMacros", "TEMP_FAILURE_RETRY")) { RawRetryList(Options.get("RetryMacros", "TEMP_FAILURE_RETRY")) {
StringRef(RawRetryList).split(RetryMacros, ",", -1, false); StringRef(RawRetryList).split(RetryMacros, ",", -1, false);
} }
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Linesvoid ComparisonInTempFailureRetryCheck::check(
const auto &Inner = *Result.Nodes.getNodeAs<BinaryOperator>("inner"); const auto &Inner = *Result.Nodes.getNodeAs<BinaryOperator>("inner");
diag(Inner.getOperatorLoc(), "top-level comparison in %0") << RetryMacroName; diag(Inner.getOperatorLoc(), "top-level comparison in %0") << RetryMacroName;
// FIXME: FixIts would be nice, but potentially nontrivial when nested macros // FIXME: FixIts would be nice, but potentially nontrivial when nested macros
// happen, e.g. `TEMP_FAILURE_RETRY(IS_ZERO(foo()))` // happen, e.g. `TEMP_FAILURE_RETRY(IS_ZERO(foo()))`
} }
} // namespace android } // namespace clang::tidy::android
} // namespace tidy
} // namespace clang

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

//===------- BoostTidyModule.cpp - clang-tidy -----------------------------===// //===------- BoostTidyModule.cpp - clang-tidy -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "UseToStringCheck.h" #include "UseToStringCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
namespace boost { namespace boost {
class BoostModule : public ClangTidyModule { class BoostModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<UseToStringCheck>("boost-use-to-string"); CheckFactories.registerCheck<UseToStringCheck>("boost-use-to-string");
} }
}; };
// Register the BoostModule using this statically initialized variable. // Register the BoostModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<BoostModule> X("boost-module", static ClangTidyModuleRegistry::Add<BoostModule> X("boost-module",
"Add boost checks."); "Add boost checks.");
} // namespace boost } // namespace boost
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the BoostModule. // and thus register the BoostModule.
volatile int BoostModuleAnchorSource = 0; volatile int BoostModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

//===--- UseToStringCheck.cpp - clang-tidy---------------------------------===// //===--- UseToStringCheck.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseToStringCheck.h" #include "UseToStringCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::boost {
namespace tidy {
namespace boost {
namespace { namespace {
AST_MATCHER(Type, isStrictlyInteger) { AST_MATCHER(Type, isStrictlyInteger) {
return Node.isIntegerType() && !Node.isAnyCharacterType() && return Node.isIntegerType() && !Node.isAnyCharacterType() &&
!Node.isBooleanType(); !Node.isBooleanType();
} }
} // namespace } // namespace
Show All 37 Lines if (Loc.isMacroID())
return; return;
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
CharSourceRange::getCharRange(Call->getBeginLoc(), CharSourceRange::getCharRange(Call->getBeginLoc(),
Call->getArg(0)->getBeginLoc()), Call->getArg(0)->getBeginLoc()),
(llvm::Twine("std::to_") + StringType + "(").str()); (llvm::Twine("std::to_") + StringType + "(").str());
} }
} // namespace boost } // namespace clang::tidy::boost
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/Token.h" #include "clang/Lex/Token.h"
#include "../utils/LexerUtils.h" #include "../utils/LexerUtils.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER(Decl, isFromStdNamespaceOrSystemHeader) { AST_MATCHER(Decl, isFromStdNamespaceOrSystemHeader) {
if (const auto *D = Node.getDeclContext()->getEnclosingNamespaceContext()) if (const auto *D = Node.getDeclContext()->getEnclosingNamespaceContext())
if (D->isStdNamespace()) if (D->isStdNamespace())
return true; return true;
if (Node.getLocation().isInvalid()) if (Node.getLocation().isInvalid())
return false; return false;
return Node.getASTContext().getSourceManager().isInSystemHeader( return Node.getASTContext().getSourceManager().isInSystemHeader(
▲ Show 20 Lines • Show All 333 Lines • ▼ Show 20 Lines if (const auto *Call = dyn_cast<CallExpr>(E)) {
} }
checkCallArgs( checkCallArgs(
Result.Context, Construct->getConstructor(), Result.Context, Construct->getConstructor(),
Construct->getParenOrBraceRange().getBegin(), Construct->getParenOrBraceRange().getBegin(),
llvm::ArrayRef(Construct->getArgs(), Construct->getNumArgs())); llvm::ArrayRef(Construct->getArgs(), Construct->getNumArgs()));
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 15 Lines
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include <algorithm> #include <algorithm>
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER_P2(Expr, hasSideEffect, bool, CheckFunctionCalls, AST_MATCHER_P2(Expr, hasSideEffect, bool, CheckFunctionCalls,
clang::ast_matchers::internal::Matcher<NamedDecl>, clang::ast_matchers::internal::Matcher<NamedDecl>,
IgnoredFunctionsMatcher) { IgnoredFunctionsMatcher) {
const Expr *E = &Node; const Expr *E = &Node;
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Linesvoid AssertSideEffectCheck::check(const MatchFinder::MatchResult &Result) {
} }
if (AssertMacroName.empty()) if (AssertMacroName.empty())
return; return;
diag(Loc, "side effect in %0() condition discarded in release builds") diag(Loc, "side effect in %0() condition discarded in release builds")
<< AssertMacroName; << AssertMacroName;
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- AssignmentInIfConditionCheck.cpp - clang-tidy --------------------===// //===--- AssignmentInIfConditionCheck.cpp - clang-tidy --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AssignmentInIfConditionCheck.h" #include "AssignmentInIfConditionCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/RecursiveASTVisitor.h" #include "clang/AST/RecursiveASTVisitor.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void AssignmentInIfConditionCheck::registerMatchers(MatchFinder *Finder) { void AssignmentInIfConditionCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(translationUnitDecl(), this); Finder->addMatcher(translationUnitDecl(), this);
} }
void AssignmentInIfConditionCheck::check( void AssignmentInIfConditionCheck::check(
const ast_matchers::MatchFinder::MatchResult &Result) { const ast_matchers::MatchFinder::MatchResult &Result) {
class Visitor : public RecursiveASTVisitor<Visitor> { class Visitor : public RecursiveASTVisitor<Visitor> {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines diag(OpLoc, "an assignment within an 'if' condition is bug-prone")
<< AssignmentExpr->getSourceRange(); << AssignmentExpr->getSourceRange();
diag(OpLoc, diag(OpLoc,
"if it should be an assignment, move it out of the 'if' condition", "if it should be an assignment, move it out of the 'if' condition",
DiagnosticIDs::Note); DiagnosticIDs::Note);
diag(OpLoc, "if it is meant to be an equality check, change '=' to '=='", diag(OpLoc, "if it is meant to be an equality check, change '=' to '=='",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- BadSignalToKillThreadCheck.cpp - clang-tidy ---------------------===// //===--- BadSignalToKillThreadCheck.cpp - clang-tidy ---------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "BadSignalToKillThreadCheck.h" #include "BadSignalToKillThreadCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void BadSignalToKillThreadCheck::registerMatchers(MatchFinder *Finder) { void BadSignalToKillThreadCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
callExpr(allOf(callee(functionDecl(hasName("::pthread_kill"))), callExpr(allOf(callee(functionDecl(hasName("::pthread_kill"))),
argumentCountIs(2)), argumentCountIs(2)),
hasArgument(1, integerLiteral().bind("integer-literal"))) hasArgument(1, integerLiteral().bind("integer-literal")))
.bind("thread-kill"), .bind("thread-kill"),
this); this);
Show All 37 Linesvoid BadSignalToKillThreadCheck::check(const MatchFinder::MatchResult &Result) {
} }
} }
void BadSignalToKillThreadCheck::registerPPCallbacks( void BadSignalToKillThreadCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *Pp, Preprocessor *ModuleExpanderPP) { const SourceManager &SM, Preprocessor *Pp, Preprocessor *ModuleExpanderPP) {
PP = Pp; PP = Pp;
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- BoolPointerImplicitConversionCheck.cpp - clang-tidy --------------===// //===--- BoolPointerImplicitConversionCheck.cpp - clang-tidy --------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "BoolPointerImplicitConversionCheck.h" #include "BoolPointerImplicitConversionCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void BoolPointerImplicitConversionCheck::registerMatchers(MatchFinder *Finder) { void BoolPointerImplicitConversionCheck::registerMatchers(MatchFinder *Finder) {
// Look for ifs that have an implicit bool* to bool conversion in the // Look for ifs that have an implicit bool* to bool conversion in the
// condition. Filter negations. // condition. Filter negations.
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
TK_AsIs, TK_AsIs,
ifStmt( ifStmt(
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines const Decl *D = isa<DeclRefExpr>(E) ? cast<DeclRefExpr>(E)->getDecl()
: cast<MemberExpr>(E)->getMemberDecl(); : cast<MemberExpr>(E)->getMemberDecl();
const auto M = const auto M =
ignoringParenImpCasts(anyOf(declRefExpr(to(equalsNode(D))), ignoringParenImpCasts(anyOf(declRefExpr(to(equalsNode(D))),
memberExpr(hasDeclaration(equalsNode(D))))); memberExpr(hasDeclaration(equalsNode(D)))));
checkImpl(Result, E, If, M, *this); checkImpl(Result, E, If, M, *this);
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines if (!areStatementsIdentical(LHS[I]->stripLabelLikeStatements(),
RHS[I]->stripLabelLikeStatements(), Context)) { RHS[I]->stripLabelLikeStatements(), Context)) {
return false; return false;
} }
} }
return true; return true;
} }
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void BranchCloneCheck::registerMatchers(MatchFinder *Finder) { void BranchCloneCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
ifStmt(unless(allOf(isConstexpr(), isInTemplateInstantiation())), ifStmt(unless(allOf(isConstexpr(), isInTemplateInstantiation())),
stmt().bind("if"), stmt().bind("if"),
hasParent(stmt(unless(ifStmt(hasElse(equalsBoundNode("if")))))), hasParent(stmt(unless(ifStmt(hasElse(equalsBoundNode("if")))))),
hasElse(stmt().bind("else"))), hasElse(stmt().bind("else"))),
this); this);
▲ Show 20 Lines • Show All 155 Lines • ▼ Show 20 Lines while (BeginCurrent < End) {
BeginCurrent = EndCurrent; BeginCurrent = EndCurrent;
} }
return; return;
} }
llvm_unreachable("No if statement and no switch statement."); llvm_unreachable("No if statement and no switch statement.");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines
#include "UndelegatedConstructorCheck.h" #include "UndelegatedConstructorCheck.h"
#include "UnhandledExceptionAtNewCheck.h" #include "UnhandledExceptionAtNewCheck.h"
#include "UnhandledSelfAssignmentCheck.h" #include "UnhandledSelfAssignmentCheck.h"
#include "UnusedRaiiCheck.h" #include "UnusedRaiiCheck.h"
#include "UnusedReturnValueCheck.h" #include "UnusedReturnValueCheck.h"
#include "UseAfterMoveCheck.h" #include "UseAfterMoveCheck.h"
#include "VirtualNearMissCheck.h" #include "VirtualNearMissCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace bugprone { namespace bugprone {
class BugproneModule : public ClangTidyModule { class BugproneModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<ArgumentCommentCheck>( CheckFactories.registerCheck<ArgumentCommentCheck>(
"bugprone-argument-comment"); "bugprone-argument-comment");
CheckFactories.registerCheck<AssertSideEffectCheck>( CheckFactories.registerCheck<AssertSideEffectCheck>(
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Lines
// Register the BugproneTidyModule using this statically initialized variable. // Register the BugproneTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<bugprone::BugproneModule> static ClangTidyModuleRegistry::Add<bugprone::BugproneModule>
X("bugprone-module", "Adds checks for bugprone code constructs."); X("bugprone-module", "Adds checks for bugprone code constructs.");
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the BugproneModule. // and thus register the BugproneModule.
volatile int BugproneModuleAnchorSource = 0; volatile int BugproneModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

//===--- CopyConstructorInitCheck.cpp - clang-tidy-------------------------===// //===--- CopyConstructorInitCheck.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CopyConstructorInitCheck.h" #include "CopyConstructorInitCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void CopyConstructorInitCheck::registerMatchers(MatchFinder *Finder) { void CopyConstructorInitCheck::registerMatchers(MatchFinder *Finder) {
// In the future this might be extended to move constructors? // In the future this might be extended to move constructors?
Finder->addMatcher( Finder->addMatcher(
cxxConstructorDecl( cxxConstructorDecl(
isCopyConstructor(), isCopyConstructor(),
hasAnyConstructorInitializer(cxxCtorInitializer( hasAnyConstructorInitializer(cxxCtorInitializer(
isBaseInitializer(), isBaseInitializer(),
▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines if (!HasWrittenInitializer) {
FixItLoc = (*Ctor->init_begin())->getSourceLocation(); FixItLoc = (*Ctor->init_begin())->getSourceLocation();
FixItMsg += ','; FixItMsg += ',';
} }
FixItMsg += ' '; FixItMsg += ' ';
Diag << FixItHint::CreateInsertion(FixItLoc, FixItMsg); Diag << FixItHint::CreateInsertion(FixItLoc, FixItMsg);
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::tidy::matchers; using namespace clang::tidy::matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
ast_matchers::internal::BindableMatcher<Stmt> ast_matchers::internal::BindableMatcher<Stmt>
handleFrom(const ast_matchers::internal::Matcher<RecordDecl> &IsAHandle, handleFrom(const ast_matchers::internal::Matcher<RecordDecl> &IsAHandle,
const ast_matchers::internal::Matcher<Expr> &Arg) { const ast_matchers::internal::Matcher<Expr> &Arg) {
return expr( return expr(
anyOf(cxxConstructExpr(hasDeclaration(cxxMethodDecl(ofClass(IsAHandle))), anyOf(cxxConstructExpr(hasDeclaration(cxxMethodDecl(ofClass(IsAHandle))),
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Lines
void DanglingHandleCheck::check(const MatchFinder::MatchResult &Result) { void DanglingHandleCheck::check(const MatchFinder::MatchResult &Result) {
auto *Handle = Result.Nodes.getNodeAs<CXXRecordDecl>("handle"); auto *Handle = Result.Nodes.getNodeAs<CXXRecordDecl>("handle");
diag(Result.Nodes.getNodeAs<Stmt>("bad_stmt")->getBeginLoc(), diag(Result.Nodes.getNodeAs<Stmt>("bad_stmt")->getBeginLoc(),
"%0 outlives its value") "%0 outlives its value")
<< Handle->getQualifiedNameAsString(); << Handle->getQualifiedNameAsString();
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- DynamicStaticInitializersCheck.cpp - clang-tidy ------------------===// //===--- DynamicStaticInitializersCheck.cpp - clang-tidy ------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DynamicStaticInitializersCheck.h" #include "DynamicStaticInitializersCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
AST_MATCHER(clang::VarDecl, hasConstantDeclaration) { AST_MATCHER(clang::VarDecl, hasConstantDeclaration) {
const Expr *Init = Node.getInit(); const Expr *Init = Node.getInit();
if (Init && !Init->isValueDependent()) { if (Init && !Init->isValueDependent()) {
if (Node.isConstexpr()) if (Node.isConstexpr())
return true; return true;
return Node.evaluateValue(); return Node.evaluateValue();
} }
Show All 31 Lines if (!Loc.isValid() || !utils::isPresumedLocInHeaderFile(Loc, *Result.SourceManager,
HeaderFileExtensions)) HeaderFileExtensions))
return; return;
// If the initializer is a constant expression, then the compiler // If the initializer is a constant expression, then the compiler
// doesn't have to dynamically initialize it. // doesn't have to dynamically initialize it.
diag(Loc, "static variable %0 may be dynamically initialized in this header file") diag(Loc, "static variable %0 may be dynamically initialized in this header file")
<< Var; << Var;
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show First 20 Lines • Show All 83 Lines • ▼ Show 20 Lines
/// The default value for the NamePrefixSuffixSilenceDissimilarityTreshold /// The default value for the NamePrefixSuffixSilenceDissimilarityTreshold
/// check option. /// check option.
static constexpr std::size_t static constexpr std::size_t
DefaultNamePrefixSuffixSilenceDissimilarityTreshold = 1; DefaultNamePrefixSuffixSilenceDissimilarityTreshold = 1;
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
using TheCheck = EasilySwappableParametersCheck; using TheCheck = EasilySwappableParametersCheck;
namespace filter { namespace filter {
class SimilarlyUsedParameterPairSuppressor; class SimilarlyUsedParameterPairSuppressor;
static bool isIgnoredParameter(const TheCheck &Check, const ParmVarDecl *Node); static bool isIgnoredParameter(const TheCheck &Check, const ParmVarDecl *Node);
static inline bool static inline bool
▲ Show 20 Lines • Show All 2,203 Lines • ▼ Show 20 Lines for (const model::Mix &M : R.Mixes) {
DiagnosticIDs::Note) DiagnosticIDs::Note)
<< static_cast<unsigned>(RTL.UDConvKind) << static_cast<unsigned>(RTL.UDConvKind)
<< RTL.getUserDefinedConversionHighlight(); << RTL.getUserDefinedConversionHighlight();
} }
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 17 Lines
namespace clang { namespace clang {
namespace { namespace {
AST_MATCHER_P(FunctionDecl, isEnabled, llvm::StringSet<>, AST_MATCHER_P(FunctionDecl, isEnabled, llvm::StringSet<>,
FunctionsThatShouldNotThrow) { FunctionsThatShouldNotThrow) {
return FunctionsThatShouldNotThrow.count(Node.getNameAsString()) > 0; return FunctionsThatShouldNotThrow.count(Node.getNameAsString()) > 0;
} }
} // namespace } // namespace
namespace tidy { namespace tidy::bugprone {
namespace bugprone {
ExceptionEscapeCheck::ExceptionEscapeCheck(StringRef Name, ExceptionEscapeCheck::ExceptionEscapeCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), RawFunctionsThatShouldNotThrow(Options.get( : ClangTidyCheck(Name, Context), RawFunctionsThatShouldNotThrow(Options.get(
"FunctionsThatShouldNotThrow", "")), "FunctionsThatShouldNotThrow", "")),
RawIgnoredExceptions(Options.get("IgnoredExceptions", "")) { RawIgnoredExceptions(Options.get("IgnoredExceptions", "")) {
llvm::SmallVector<StringRef, 8> FunctionsThatShouldNotThrowVec, llvm::SmallVector<StringRef, 8> FunctionsThatShouldNotThrowVec,
IgnoredExceptionsVec; IgnoredExceptionsVec;
StringRef(RawFunctionsThatShouldNotThrow) StringRef(RawFunctionsThatShouldNotThrow)
Show All 36 Lines if (Tracer.analyze(MatchedDecl).getBehaviour() ==
utils::ExceptionAnalyzer::State::Throwing) utils::ExceptionAnalyzer::State::Throwing)
// FIXME: We should provide more information about the exact location where // FIXME: We should provide more information about the exact location where
// the exception is thrown, maybe the full path the exception escapes // the exception is thrown, maybe the full path the exception escapes
diag(MatchedDecl->getLocation(), "an exception may be thrown in function " diag(MatchedDecl->getLocation(), "an exception may be thrown in function "
"%0 which should not throw exceptions") "%0 which should not throw exceptions")
<< MatchedDecl; << MatchedDecl;
} }
} // namespace bugprone } // namespace tidy::bugprone
} // namespace tidy
} // namespace clang } // namespace clang

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

//===--- FoldInitTypeCheck.cpp - clang-tidy--------------------------------===// //===--- FoldInitTypeCheck.cpp - clang-tidy--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FoldInitTypeCheck.h" #include "FoldInitTypeCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void FoldInitTypeCheck::registerMatchers(MatchFinder *Finder) { void FoldInitTypeCheck::registerMatchers(MatchFinder *Finder) {
// We match functions of interest and bind the iterator and init value types. // We match functions of interest and bind the iterator and init value types.
// Note: Right now we check only builtin types. // Note: Right now we check only builtin types.
const auto BuiltinTypeWithId = [](const char *ID) { const auto BuiltinTypeWithId = [](const char *ID) {
return hasCanonicalType(builtinType().bind(ID)); return hasCanonicalType(builtinType().bind(ID));
}; };
const auto IteratorWithValueType = [&BuiltinTypeWithId](const char *ID) { const auto IteratorWithValueType = [&BuiltinTypeWithId](const char *ID) {
▲ Show 20 Lines • Show All 103 Lines • ▼ Show 20 Linesvoid FoldInitTypeCheck::check(const MatchFinder::MatchResult &Result) {
doCheck(*IterValueType, *InitType, *Result.Context, *CallNode); doCheck(*IterValueType, *InitType, *Result.Context, *CallNode);
if (const auto *Iter2ValueType = if (const auto *Iter2ValueType =
Result.Nodes.getNodeAs<BuiltinType>("Iter2ValueType")) Result.Nodes.getNodeAs<BuiltinType>("Iter2ValueType"))
doCheck(*Iter2ValueType, *InitType, *Result.Context, *CallNode); doCheck(*Iter2ValueType, *InitType, *Result.Context, *CallNode);
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include <stack> #include <stack>
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void ForwardDeclarationNamespaceCheck::registerMatchers(MatchFinder *Finder) { void ForwardDeclarationNamespaceCheck::registerMatchers(MatchFinder *Finder) {
// Match all class declarations/definitions *EXCEPT* // Match all class declarations/definitions *EXCEPT*
// 1. implicit classes, e.g. `class A {};` has implicit `class A` inside `A`. // 1. implicit classes, e.g. `class A {};` has implicit `class A` inside `A`.
// 2. nested classes declared/defined inside another class. // 2. nested classes declared/defined inside another class.
// 3. template class declaration, template instantiation or // 3. template class declaration, template instantiation or
// specialization (NOTE: extern specialization is filtered out by // specialization (NOTE: extern specialization is filtered out by
// `unless(hasAncestor(cxxRecordDecl()))`). // `unless(hasAncestor(cxxRecordDecl()))`).
▲ Show 20 Lines • Show All 133 Lines • ▼ Show 20 Lines for (const auto *CurDecl : Declarations) {
diag(Def->getLocation(), "a definition of %0 is found here", diag(Def->getLocation(), "a definition of %0 is found here",
DiagnosticIDs::Note) DiagnosticIDs::Note)
<< Def; << Def;
} }
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- ForwardingReferenceOverloadCheck.cpp - clang-tidy-----------------===// //===--- ForwardingReferenceOverloadCheck.cpp - clang-tidy-----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ForwardingReferenceOverloadCheck.h" #include "ForwardingReferenceOverloadCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <algorithm> #include <algorithm>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
// Check if the given type is related to std::enable_if. // Check if the given type is related to std::enable_if.
AST_MATCHER(QualType, isEnableIf) { AST_MATCHER(QualType, isEnableIf) {
auto CheckTemplate = [](const TemplateSpecializationType *Spec) { auto CheckTemplate = [](const TemplateSpecializationType *Spec) {
if (!Spec || !Spec->getTemplateName().getAsTemplateDecl()) { if (!Spec || !Spec->getTemplateName().getAsTemplateDecl()) {
return false; return false;
} }
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines if (OtherCtor->isCopyOrMoveConstructor() && !OtherCtor->isDeleted() &&
OtherCtor->getAccess() != AS_private) { OtherCtor->getAccess() != AS_private) {
diag(OtherCtor->getLocation(), diag(OtherCtor->getLocation(),
"%select{copy|move}0 constructor declared here", DiagnosticIDs::Note) "%select{copy|move}0 constructor declared here", DiagnosticIDs::Note)
<< OtherCtor->isMoveConstructor(); << OtherCtor->isMoveConstructor();
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 15 Lines
namespace clang { namespace clang {
namespace { namespace {
AST_MATCHER(ImplicitCastExpr, isPartOfExplicitCast) { AST_MATCHER(ImplicitCastExpr, isPartOfExplicitCast) {
return Node.isPartOfExplicitCast(); return Node.isPartOfExplicitCast();
} }
} // namespace } // namespace
} // namespace clang } // namespace clang
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
static const Expr *getLHSOfMulBinOp(const Expr *E) { static const Expr *getLHSOfMulBinOp(const Expr *E) {
assert(E == E->IgnoreParens() && "Already skipped all parens!"); assert(E == E->IgnoreParens() && "Already skipped all parens!");
// Is this: long r = int(x) * int(y); ? // Is this: long r = int(x) * int(y); ?
// FIXME: shall we skip brackets/casts/etc? // FIXME: shall we skip brackets/casts/etc?
const auto *BO = dyn_cast<BinaryOperator>(E); const auto *BO = dyn_cast<BinaryOperator>(E);
if (!BO || BO->getOpcode() != BO_Mul) if (!BO || BO->getOpcode() != BO_Mul)
// FIXME: what about: long r = int(x) + (int(y) * int(z)); ? // FIXME: what about: long r = int(x) + (int(y) * int(z)); ?
▲ Show 20 Lines • Show All 233 Lines • ▼ Show 20 Linesvoid ImplicitWideningOfMultiplicationResultCheck::check(
else if (const auto *MatchedDecl = else if (const auto *MatchedDecl =
Result.Nodes.getNodeAs<ArraySubscriptExpr>("x")) Result.Nodes.getNodeAs<ArraySubscriptExpr>("x"))
handlePointerOffsetting(MatchedDecl); handlePointerOffsetting(MatchedDecl);
else if (const auto *MatchedDecl = else if (const auto *MatchedDecl =
Result.Nodes.getNodeAs<BinaryOperator>("x")) Result.Nodes.getNodeAs<BinaryOperator>("x"))
handlePointerOffsetting(MatchedDecl); handlePointerOffsetting(MatchedDecl);
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- InaccurateEraseCheck.cpp - clang-tidy-----------------------------===// //===--- InaccurateEraseCheck.cpp - clang-tidy-----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "InaccurateEraseCheck.h" #include "InaccurateEraseCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void InaccurateEraseCheck::registerMatchers(MatchFinder *Finder) { void InaccurateEraseCheck::registerMatchers(MatchFinder *Finder) {
const auto EndCall = const auto EndCall =
callExpr( callExpr(
callee(functionDecl(hasAnyName("remove", "remove_if", "unique"))), callee(functionDecl(hasAnyName("remove", "remove_if", "unique"))),
hasArgument( hasArgument(
1, optionally(cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end")))) 1, optionally(cxxMemberCallExpr(callee(cxxMethodDecl(hasName("end"))))
.bind("end")))) .bind("end"))))
Show All 29 Lines if (!Loc.isMacroID() && EndExpr) {
Hint = FixItHint::CreateInsertion(EndLoc, ", " + ReplacementText); Hint = FixItHint::CreateInsertion(EndLoc, ", " + ReplacementText);
} }
diag(Loc, "this call will remove at most one item even when multiple items " diag(Loc, "this call will remove at most one item even when multiple items "
"should be removed") "should be removed")
<< Hint; << Hint;
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "clang/AST/DeclBase.h" #include "clang/AST/DeclBase.h"
#include "clang/AST/Type.h" #include "clang/AST/Type.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER(FloatingLiteral, floatHalf) { AST_MATCHER(FloatingLiteral, floatHalf) {
const auto &Literal = Node.getValue(); const auto &Literal = Node.getValue();
if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle()) if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
return Literal.convertToFloat() == 0.5f; return Literal.convertToFloat() == 0.5f;
if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble()) if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
return Literal.convertToDouble() == 0.5; return Literal.convertToDouble() == 0.5;
Show All 32 Lines
void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) { void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) {
const auto *CastExpr = Result.Nodes.getNodeAs<ImplicitCastExpr>("CastExpr"); const auto *CastExpr = Result.Nodes.getNodeAs<ImplicitCastExpr>("CastExpr");
diag(CastExpr->getBeginLoc(), diag(CastExpr->getBeginLoc(),
"casting (double + 0.5) to integer leads to incorrect rounding; " "casting (double + 0.5) to integer leads to incorrect rounding; "
"consider using lround (#include <cmath>) instead"); "consider using lround (#include <cmath>) instead");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 25 Lines return Node.hasAttr<NoReturnAttr>() || Node.hasAttr<CXX11NoReturnAttr>() ||
Node.hasAttr<C11NoReturnAttr>(); Node.hasAttr<C11NoReturnAttr>();
} }
/// matches a FunctionType if the type includes the GNU no return attribute /// matches a FunctionType if the type includes the GNU no return attribute
AST_MATCHER(FunctionType, typeHasNoReturnAttr) { AST_MATCHER(FunctionType, typeHasNoReturnAttr) {
return Node.getNoReturnAttr(); return Node.getNoReturnAttr();
} }
} // namespace ast_matchers } // namespace ast_matchers
namespace tidy { namespace tidy::bugprone {
namespace bugprone {
static internal::Matcher<Stmt> static internal::Matcher<Stmt>
loopEndingStmt(internal::Matcher<Stmt> Internal) { loopEndingStmt(internal::Matcher<Stmt> Internal) {
internal::Matcher<QualType> isNoReturnFunType = internal::Matcher<QualType> isNoReturnFunType =
ignoringParens(functionType(typeHasNoReturnAttr())); ignoringParens(functionType(typeHasNoReturnAttr()));
internal::Matcher<Decl> isNoReturnDecl = internal::Matcher<Decl> isNoReturnDecl =
anyOf(declHasNoReturnAttr(), functionDecl(hasType(isNoReturnFunType)), anyOf(declHasNoReturnAttr(), functionDecl(hasType(isNoReturnFunType)),
varDecl(hasType(blockPointerType(pointee(isNoReturnFunType))))); varDecl(hasType(blockPointerType(pointee(isNoReturnFunType)))));
▲ Show 20 Lines • Show All 280 Lines • ▼ Show 20 Linesvoid InfiniteLoopCheck::check(const MatchFinder::MatchResult &Result) {
} else { } else {
diag(LoopStmt->getBeginLoc(), diag(LoopStmt->getBeginLoc(),
"this loop is infinite; none of its condition variables (%0)" "this loop is infinite; none of its condition variables (%0)"
" are updated in the loop body") " are updated in the loop body")
<< CondVarNames; << CondVarNames;
} }
} }
} // namespace bugprone } // namespace tidy::bugprone
} // namespace tidy
} // namespace clang } // namespace clang

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

//===--- IntegerDivisionCheck.cpp - clang-tidy-----------------------------===// //===--- IntegerDivisionCheck.cpp - clang-tidy-----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "IntegerDivisionCheck.h" #include "IntegerDivisionCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void IntegerDivisionCheck::registerMatchers(MatchFinder *Finder) { void IntegerDivisionCheck::registerMatchers(MatchFinder *Finder) {
const auto IntType = hasType(isInteger()); const auto IntType = hasType(isInteger());
const auto BinaryOperators = binaryOperator( const auto BinaryOperators = binaryOperator(
hasAnyOperatorName("%", "<<", ">>", "<<", "^", "|", "&", "||", "&&", "<", hasAnyOperatorName("%", "<<", ">>", "<<", "^", "|", "&", "||", "&&", "<",
">", "<=", ">=", "==", "!=")); ">", "<=", ">=", "==", "!="));
Show All 18 Lines
} }
void IntegerDivisionCheck::check(const MatchFinder::MatchResult &Result) { void IntegerDivisionCheck::check(const MatchFinder::MatchResult &Result) {
const auto *IntDiv = Result.Nodes.getNodeAs<BinaryOperator>("IntDiv"); const auto *IntDiv = Result.Nodes.getNodeAs<BinaryOperator>("IntDiv");
diag(IntDiv->getBeginLoc(), "result of integer division used in a floating " diag(IntDiv->getBeginLoc(), "result of integer division used in a floating "
"point context; possible loss of precision"); "point context; possible loss of precision");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/MacroInfo.h" #include "clang/Lex/MacroInfo.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
// Keep track of macro expansions that contain both __FILE__ and __LINE__. If // Keep track of macro expansions that contain both __FILE__ and __LINE__. If
// such a macro also uses __func__ or __FUNCTION__, we don't want to issue a // such a macro also uses __func__ or __FUNCTION__, we don't want to issue a
// warning because __FILE__ and __LINE__ may be useful even if __func__ or // warning because __FILE__ and __LINE__ may be useful even if __func__ or
// __FUNCTION__ is not, especially if the macro could be used in the context of // __FUNCTION__ is not, especially if the macro could be used in the context of
// either a function body or a lambda body. // either a function body or a lambda body.
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesvoid LambdaFunctionNameCheck::check(const MatchFinder::MatchResult &Result) {
} }
diag(E->getLocation(), diag(E->getLocation(),
"inside a lambda, '%0' expands to the name of the function call " "inside a lambda, '%0' expands to the name of the function call "
"operator; consider capturing the name of the enclosing function " "operator; consider capturing the name of the enclosing function "
"explicitly") "explicitly")
<< PredefinedExpr::getIdentKindName(E->getIdentKind()); << PredefinedExpr::getIdentKindName(E->getIdentKind());
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- MacroParenthesesCheck.cpp - clang-tidy----------------------------===// //===--- MacroParenthesesCheck.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MacroParenthesesCheck.h" #include "MacroParenthesesCheck.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
class MacroParenthesesPPCallbacks : public PPCallbacks { class MacroParenthesesPPCallbacks : public PPCallbacks {
public: public:
MacroParenthesesPPCallbacks(Preprocessor *PP, MacroParenthesesCheck *Check) MacroParenthesesPPCallbacks(Preprocessor *PP, MacroParenthesesCheck *Check)
: PP(PP), Check(Check) {} : PP(PP), Check(Check) {}
void MacroDefined(const Token &MacroNameTok, void MacroDefined(const Token &MacroNameTok,
▲ Show 20 Lines • Show All 238 Lines • ▼ Show 20 Linesvoid MacroParenthesesPPCallbacks::argument(const Token &MacroNameTok,
} }
} }
void MacroParenthesesCheck::registerPPCallbacks( void MacroParenthesesCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
PP->addPPCallbacks(std::make_unique<MacroParenthesesPPCallbacks>(PP, this)); PP->addPPCallbacks(std::make_unique<MacroParenthesesPPCallbacks>(PP, this));
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- MacroRepeatedSideEffectsCheck.cpp - clang-tidy--------------------===// //===--- MacroRepeatedSideEffectsCheck.cpp - clang-tidy--------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MacroRepeatedSideEffectsCheck.h" #include "MacroRepeatedSideEffectsCheck.h"
#include "clang/Basic/Builtins.h" #include "clang/Basic/Builtins.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/MacroArgs.h" #include "clang/Lex/MacroArgs.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
class MacroRepeatedPPCallbacks : public PPCallbacks { class MacroRepeatedPPCallbacks : public PPCallbacks {
public: public:
MacroRepeatedPPCallbacks(ClangTidyCheck &Check, Preprocessor &PP) MacroRepeatedPPCallbacks(ClangTidyCheck &Check, Preprocessor &PP)
: Check(Check), PP(PP) {} : Check(Check), PP(PP) {}
void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD, void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
▲ Show 20 Lines • Show All 143 Lines • ▼ Show 20 Linesbool MacroRepeatedPPCallbacks::hasSideEffects(
return false; return false;
} }
void MacroRepeatedSideEffectsCheck::registerPPCallbacks( void MacroRepeatedSideEffectsCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
PP->addPPCallbacks(::std::make_unique<MacroRepeatedPPCallbacks>(*this, *PP)); PP->addPPCallbacks(::std::make_unique<MacroRepeatedPPCallbacks>(*this, *PP));
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- MisplacedOperatorInStrlenInAllocCheck.cpp - clang-tidy------------===// //===--- MisplacedOperatorInStrlenInAllocCheck.cpp - clang-tidy------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MisplacedOperatorInStrlenInAllocCheck.h" #include "MisplacedOperatorInStrlenInAllocCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void MisplacedOperatorInStrlenInAllocCheck::registerMatchers( void MisplacedOperatorInStrlenInAllocCheck::registerMatchers(
MatchFinder *Finder) { MatchFinder *Finder) {
const auto StrLenFunc = functionDecl(hasAnyName( const auto StrLenFunc = functionDecl(hasAnyName(
"::strlen", "::std::strlen", "::strnlen", "::std::strnlen", "::strnlen_s", "::strlen", "::std::strlen", "::strnlen", "::std::strnlen", "::strnlen_s",
"::std::strnlen_s", "::wcslen", "::std::wcslen", "::wcsnlen", "::std::strnlen_s", "::wcslen", "::std::wcslen", "::wcsnlen",
"::std::wcsnlen", "::wcsnlen_s", "std::wcsnlen_s")); "::std::wcsnlen", "::wcsnlen_s", "std::wcsnlen_s"));
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines auto Hint = FixItHint::CreateReplacement(
(StrLenBegin + LHSText + StrLenEnd + " + " + RHSText).str()); (StrLenBegin + LHSText + StrLenEnd + " + " + RHSText).str());
diag(Alloc->getBeginLoc(), diag(Alloc->getBeginLoc(),
"addition operator is applied to the argument of %0 instead of its " "addition operator is applied to the argument of %0 instead of its "
"result") "result")
<< StrLen->getDirectCallee()->getName() << Hint; << StrLen->getDirectCallee()->getName() << Hint;
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- MisplacedPointerArithmeticInAllocCheck.cpp - clang-tidy-----------===// //===--- MisplacedPointerArithmeticInAllocCheck.cpp - clang-tidy-----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MisplacedPointerArithmeticInAllocCheck.h" #include "MisplacedPointerArithmeticInAllocCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void MisplacedPointerArithmeticInAllocCheck::registerMatchers( void MisplacedPointerArithmeticInAllocCheck::registerMatchers(
MatchFinder *Finder) { MatchFinder *Finder) {
const auto AllocFunc = const auto AllocFunc =
functionDecl(hasAnyName("::malloc", "std::malloc", "::alloca", "::calloc", functionDecl(hasAnyName("::malloc", "std::malloc", "::alloca", "::calloc",
"std::calloc", "::realloc", "std::realloc")); "std::calloc", "::realloc", "std::realloc"));
const auto AllocFuncPtr = const auto AllocFuncPtr =
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Linesvoid MisplacedPointerArithmeticInAllocCheck::check(
diag(PtrArith->getBeginLoc(), diag(PtrArith->getBeginLoc(),
"arithmetic operation is applied to the result of %0() instead of its " "arithmetic operation is applied to the result of %0() instead of its "
"size-like argument") "size-like argument")
<< CallName << FixItHint::CreateRemoval(OldRParen) << CallName << FixItHint::CreateRemoval(OldRParen)
<< FixItHint::CreateInsertion(NewRParen, RParen); << FixItHint::CreateInsertion(NewRParen, RParen);
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- MisplacedWideningCastCheck.cpp - clang-tidy-----------------------===// //===--- MisplacedWideningCastCheck.cpp - clang-tidy-----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MisplacedWideningCastCheck.h" #include "MisplacedWideningCastCheck.h"
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
MisplacedWideningCastCheck::MisplacedWideningCastCheck( MisplacedWideningCastCheck::MisplacedWideningCastCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
CheckImplicitCasts(Options.get("CheckImplicitCasts", false)) {} CheckImplicitCasts(Options.get("CheckImplicitCasts", false)) {}
void MisplacedWideningCastCheck::storeOptions( void MisplacedWideningCastCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
▲ Show 20 Lines • Show All 194 Lines • ▼ Show 20 Linesvoid MisplacedWideningCastCheck::check(const MatchFinder::MatchResult &Result) {
if (Context.getIntWidth(CalcType) >= getMaxCalculationWidth(Context, Calc)) if (Context.getIntWidth(CalcType) >= getMaxCalculationWidth(Context, Calc))
return; return;
diag(Cast->getBeginLoc(), "either cast from %0 to %1 is ineffective, or " diag(Cast->getBeginLoc(), "either cast from %0 to %1 is ineffective, or "
"there is loss of precision before the conversion") "there is loss of precision before the conversion")
<< CalcType << CastType; << CalcType << CastType;
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- MoveForwardingReferenceCheck.cpp - clang-tidy --------------------===// //===--- MoveForwardingReferenceCheck.cpp - clang-tidy --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MoveForwardingReferenceCheck.h" #include "MoveForwardingReferenceCheck.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <algorithm> #include <algorithm>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
static void replaceMoveWithForward(const UnresolvedLookupExpr *Callee, static void replaceMoveWithForward(const UnresolvedLookupExpr *Callee,
const ParmVarDecl *ParmVar, const ParmVarDecl *ParmVar,
const TemplateTypeParmDecl *TypeParmDecl, const TemplateTypeParmDecl *TypeParmDecl,
DiagnosticBuilder &Diag, DiagnosticBuilder &Diag,
const ASTContext &Context) { const ASTContext &Context) {
const SourceManager &SM = Context.getSourceManager(); const SourceManager &SM = Context.getSourceManager();
const LangOptions &LangOpts = Context.getLangOpts(); const LangOptions &LangOpts = Context.getLangOpts();
▲ Show 20 Lines • Show All 91 Lines • ▼ Show 20 Lines auto Diag = diag(CallMove->getExprLoc(),
"forwarding reference passed to std::move(), which may " "forwarding reference passed to std::move(), which may "
"unexpectedly cause lvalues to be moved; use " "unexpectedly cause lvalues to be moved; use "
"std::forward() instead"); "std::forward() instead");
replaceMoveWithForward(UnresolvedLookup, ParmVar, TypeParmDecl, Diag, replaceMoveWithForward(UnresolvedLookup, ParmVar, TypeParmDecl, Diag,
*Result.Context); *Result.Context);
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- MultipleStatementMacroCheck.cpp - clang-tidy----------------------===// //===--- MultipleStatementMacroCheck.cpp - clang-tidy----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MultipleStatementMacroCheck.h" #include "MultipleStatementMacroCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER(Expr, isInMacro) { return Node.getBeginLoc().isMacroID(); } AST_MATCHER(Expr, isInMacro) { return Node.getBeginLoc().isMacroID(); }
/// Find the next statement after `S`. /// Find the next statement after `S`.
const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) { const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) {
auto Parents = Result.Context->getParents(*S); auto Parents = Result.Context->getParents(*S);
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines if (InnerRanges.empty() || NextRanges.empty() ||
InnerRanges.back() != NextRanges.back()) InnerRanges.back() != NextRanges.back())
return; return;
diag(InnerRanges.back().getBegin(), "multiple statement macro used without " diag(InnerRanges.back().getBegin(), "multiple statement macro used without "
"braces; some statements will be " "braces; some statements will be "
"unconditionally executed"); "unconditionally executed");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- NoEscapeCheck.cpp - clang-tidy -----------------------------------===// //===--- NoEscapeCheck.cpp - clang-tidy -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NoEscapeCheck.h" #include "NoEscapeCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void NoEscapeCheck::registerMatchers(MatchFinder *Finder) { void NoEscapeCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(callExpr(callee(functionDecl(hasName("::dispatch_async"))), Finder->addMatcher(callExpr(callee(functionDecl(hasName("::dispatch_async"))),
argumentCountIs(2), argumentCountIs(2),
hasArgument(1, blockExpr().bind("arg-block"))), hasArgument(1, blockExpr().bind("arg-block"))),
this); this);
Finder->addMatcher(callExpr(callee(functionDecl(hasName("::dispatch_after"))), Finder->addMatcher(callExpr(callee(functionDecl(hasName("::dispatch_after"))),
argumentCountIs(3), argumentCountIs(3),
Show All 15 Lines if (Var && Var->hasAttr<NoEscapeAttr>()) {
"asynchronously-executed block") "asynchronously-executed block")
<< Var; << Var;
diag(Var->getBeginLoc(), "the 'noescape' attribute is declared here.", diag(Var->getBeginLoc(), "the 'noescape' attribute is declared here.",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 11 Lines
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
constexpr llvm::StringLiteral FunctionExprName = "FunctionExpr"; constexpr llvm::StringLiteral FunctionExprName = "FunctionExpr";
constexpr llvm::StringLiteral CastExprName = "CastExpr"; constexpr llvm::StringLiteral CastExprName = "CastExpr";
constexpr llvm::StringLiteral UnknownDestName = "UnknownDest"; constexpr llvm::StringLiteral UnknownDestName = "UnknownDest";
constexpr llvm::StringLiteral DestArrayTyName = "DestArrayTy"; constexpr llvm::StringLiteral DestArrayTyName = "DestArrayTy";
constexpr llvm::StringLiteral DestVarDeclName = "DestVarDecl"; constexpr llvm::StringLiteral DestVarDeclName = "DestVarDecl";
constexpr llvm::StringLiteral DestMallocExprName = "DestMalloc"; constexpr llvm::StringLiteral DestMallocExprName = "DestMalloc";
constexpr llvm::StringLiteral DestExprName = "DestExpr"; constexpr llvm::StringLiteral DestExprName = "DestExpr";
▲ Show 20 Lines • Show All 974 Lines • ▼ Show 20 Lines auto Diag =
diag(Result.Nodes.getNodeAs<CallExpr>(FunctionExprName)->getBeginLoc(), diag(Result.Nodes.getNodeAs<CallExpr>(FunctionExprName)->getBeginLoc(),
"the result from calling '%0' is not null-terminated") "the result from calling '%0' is not null-terminated")
<< Name; << Name;
isDestCapacityFix(Result, Diag); isDestCapacityFix(Result, Diag);
lengthArgHandle(LengthHandleKind::Increase, Result, Diag); lengthArgHandle(LengthHandleKind::Increase, Result, Diag);
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 11 Lines
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include <algorithm> #include <algorithm>
#include <cctype> #include <cctype>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
using BasesVector = llvm::SmallVector<const CXXRecordDecl *, 5>; using BasesVector = llvm::SmallVector<const CXXRecordDecl *, 5>;
static bool isParentOf(const CXXRecordDecl &Parent, static bool isParentOf(const CXXRecordDecl &Parent,
const CXXRecordDecl &ThisClass) { const CXXRecordDecl &ThisClass) {
if (Parent.getCanonicalDecl() == ThisClass.getCanonicalDecl()) if (Parent.getCanonicalDecl() == ThisClass.getCanonicalDecl())
return true; return true;
const CXXRecordDecl *ParentCanonicalDecl = Parent.getCanonicalDecl(); const CXXRecordDecl *ParentCanonicalDecl = Parent.getCanonicalDecl();
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Linesvoid ParentVirtualCallCheck::check(const MatchFinder::MatchResult &Result) {
if (Parents.size() == 1 && if (Parents.size() == 1 &&
// ...unless parent class is templated // ...unless parent class is templated
!isa<ClassTemplateSpecializationDecl>(Parents.front())) !isa<ClassTemplateSpecializationDecl>(Parents.front()))
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
Member->getQualifierLoc().getSourceRange(), Member->getQualifierLoc().getSourceRange(),
getNameAsString(Parents.front()) + "::"); getNameAsString(Parents.front()) + "::");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- PosixReturnCheck.cpp - clang-tidy---------------------------------===// //===--- PosixReturnCheck.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PosixReturnCheck.h" #include "PosixReturnCheck.h"
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
static StringRef getFunctionSpelling(const MatchFinder::MatchResult &Result, static StringRef getFunctionSpelling(const MatchFinder::MatchResult &Result,
const char *BindingStr) { const char *BindingStr) {
const CallExpr *MatchedCall = cast<CallExpr>( const CallExpr *MatchedCall = cast<CallExpr>(
(Result.Nodes.getNodeAs<BinaryOperator>(BindingStr))->getLHS()); (Result.Nodes.getNodeAs<BinaryOperator>(BindingStr))->getLHS());
const SourceManager &SM = *Result.SourceManager; const SourceManager &SM = *Result.SourceManager;
return Lexer::getSourceText(CharSourceRange::getTokenRange( return Lexer::getSourceText(CharSourceRange::getTokenRange(
MatchedCall->getCallee()->getSourceRange()), MatchedCall->getCallee()->getSourceRange()),
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines diag(AlwaysTrueOp->getOperatorLoc(),
<< getFunctionSpelling(Result, "atop"); << getFunctionSpelling(Result, "atop");
return; return;
} }
const auto *BinOp = Result.Nodes.getNodeAs<BinaryOperator>("binop"); const auto *BinOp = Result.Nodes.getNodeAs<BinaryOperator>("binop");
diag(BinOp->getOperatorLoc(), "%0 only returns non-negative values") diag(BinOp->getOperatorLoc(), "%0 only returns non-negative values")
<< getFunctionSpelling(Result, "binop"); << getFunctionSpelling(Result, "binop");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h" #include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using clang::tidy::utils::hasPtrOrReferenceInFunc; using clang::tidy::utils::hasPtrOrReferenceInFunc;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
static const char CondVarStr[] = "cond_var"; static const char CondVarStr[] = "cond_var";
static const char OuterIfStr[] = "outer_if"; static const char OuterIfStr[] = "outer_if";
static const char InnerIfStr[] = "inner_if"; static const char InnerIfStr[] = "inner_if";
static const char OuterIfVar1Str[] = "outer_if_var1"; static const char OuterIfVar1Str[] = "outer_if_var1";
static const char OuterIfVar2Str[] = "outer_if_var2"; static const char OuterIfVar2Str[] = "outer_if_var2";
static const char InnerIfVar1Str[] = "inner_if_var1"; static const char InnerIfVar1Str[] = "inner_if_var1";
static const char InnerIfVar2Str[] = "inner_if_var2"; static const char InnerIfVar2Str[] = "inner_if_var2";
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines if (LeftDRE && LeftDRE->getDecl() == CondVar) {
*Result.SourceManager, getLangOpts()) *Result.SourceManager, getLangOpts())
->getLocation(); ->getLocation();
Diag << FixItHint::CreateRemoval(CharSourceRange::getTokenRange( Diag << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
AfterLHS, CondOp->getRHS()->getEndLoc())); AfterLHS, CondOp->getRHS()->getEndLoc()));
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 14 Lines
#include <algorithm> #include <algorithm>
#include <cctype> #include <cctype>
#include <optional> #include <optional>
// FixItHint // FixItHint
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
static const char DoubleUnderscoreTag[] = "du"; static const char DoubleUnderscoreTag[] = "du";
static const char UnderscoreCapitalTag[] = "uc"; static const char UnderscoreCapitalTag[] = "uc";
static const char GlobalUnderscoreTag[] = "global-under"; static const char GlobalUnderscoreTag[] = "global-under";
static const char NonReservedTag[] = "non-reserved"; static const char NonReservedTag[] = "non-reserved";
static const char Message[] = static const char Message[] =
"declaration uses identifier '%0', which is %select{a reserved " "declaration uses identifier '%0', which is %select{a reserved "
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines
ReservedIdentifierCheck::getDiagInfo(const NamingCheckId &ID, ReservedIdentifierCheck::getDiagInfo(const NamingCheckId &ID,
const NamingCheckFailure &Failure) const { const NamingCheckFailure &Failure) const {
return DiagInfo{Message, [&](DiagnosticBuilder &Diag) { return DiagInfo{Message, [&](DiagnosticBuilder &Diag) {
Diag << ID.second Diag << ID.second
<< getMessageSelectIndex(Failure.Info.KindName); << getMessageSelectIndex(Failure.Info.KindName);
}}; }};
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SharedPtrArrayMismatchCheck.cpp - clang-tidy ---------------------===// //===--- SharedPtrArrayMismatchCheck.cpp - clang-tidy ---------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SharedPtrArrayMismatchCheck.h" #include "SharedPtrArrayMismatchCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
SharedPtrArrayMismatchCheck::SharedPtrArrayMismatchCheck( SharedPtrArrayMismatchCheck::SharedPtrArrayMismatchCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: SmartPtrArrayMismatchCheck(Name, Context, "shared") {} : SmartPtrArrayMismatchCheck(Name, Context, "shared") {}
SharedPtrArrayMismatchCheck::SmartPtrClassMatcher SharedPtrArrayMismatchCheck::SmartPtrClassMatcher
SharedPtrArrayMismatchCheck::getSmartPointerClassMatcher() const { SharedPtrArrayMismatchCheck::getSmartPointerClassMatcher() const {
return classTemplateSpecializationDecl( return classTemplateSpecializationDecl(
hasName("::std::shared_ptr"), templateArgumentCountIs(1), hasName("::std::shared_ptr"), templateArgumentCountIs(1),
hasTemplateArgument( hasTemplateArgument(
0, templateArgument(refersToType(qualType().bind(PointerTypeN))))); 0, templateArgument(refersToType(qualType().bind(PointerTypeN)))));
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Linesconstexpr llvm::StringLiteral POSIXConformingFunctions[] = {
"wmemcmp", "wmemcmp",
"wmemcpy", "wmemcpy",
"wmemmove", "wmemmove",
"wmemset", "wmemset",
"write"}; "write"};
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
template <> template <>
struct OptionEnumMapping< struct OptionEnumMapping<
bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind> { bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind> {
static llvm::ArrayRef<std::pair< static llvm::ArrayRef<std::pair<
bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind, StringRef>> bugprone::SignalHandlerCheck::AsyncSafeFunctionSetKind, StringRef>>
getEnumMapping() { getEnumMapping() {
static constexpr std::pair< static constexpr std::pair<
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Linesvoid SignalHandlerCheck::reportHandlerChain(
if (!SkipPathEnd) if (!SkipPathEnd)
diag(HandlerRef->getBeginLoc(), diag(HandlerRef->getBeginLoc(),
"function %0 registered here as signal handler", DiagnosticIDs::Note) "function %0 registered here as signal handler", DiagnosticIDs::Note)
<< cast<FunctionDecl>(Caller->getDecl()) << cast<FunctionDecl>(Caller->getDecl())
<< HandlerRef->getSourceRange(); << HandlerRef->getSourceRange();
} }
} // namespace bugprone } // namespace bugprone
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

//===--- SignedCharMisuseCheck.cpp - clang-tidy ---------------------------===// //===--- SignedCharMisuseCheck.cpp - clang-tidy ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SignedCharMisuseCheck.h" #include "SignedCharMisuseCheck.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::ast_matchers::internal; using namespace clang::ast_matchers::internal;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
static constexpr int UnsignedASCIIUpperBound = 127; static constexpr int UnsignedASCIIUpperBound = 127;
SignedCharMisuseCheck::SignedCharMisuseCheck(StringRef Name, SignedCharMisuseCheck::SignedCharMisuseCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
CharTypdefsToIgnoreList(Options.get("CharTypdefsToIgnore", "")), CharTypdefsToIgnoreList(Options.get("CharTypdefsToIgnore", "")),
DiagnoseSignedUnsignedCharComparisons( DiagnoseSignedUnsignedCharComparisons(
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Linesvoid SignedCharMisuseCheck::check(const MatchFinder::MatchResult &Result) {
} else { } else {
diag(SignedCastExpression->getBeginLoc(), diag(SignedCastExpression->getBeginLoc(),
"'signed char' to %0 conversion; " "'signed char' to %0 conversion; "
"consider casting to 'unsigned char' first.") "consider casting to 'unsigned char' first.")
<< *IntegerType; << *IntegerType;
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SizeofContainerCheck.cpp - clang-tidy-----------------------------===// //===--- SizeofContainerCheck.cpp - clang-tidy-----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SizeofContainerCheck.h" #include "SizeofContainerCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) { void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
expr(unless(isInTemplateInstantiation()), expr(unless(isInTemplateInstantiation()),
expr(sizeOfExpr(has(ignoringParenImpCasts( expr(sizeOfExpr(has(ignoringParenImpCasts(
expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl( expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
matchesName("^(::std::|::string)"), matchesName("^(::std::|::string)"),
unless(matchesName("^::std::(bitset|array)$")), unless(matchesName("^::std::(bitset|array)$")),
Show All 12 Linesvoid SizeofContainerCheck::check(const MatchFinder::MatchResult &Result) {
const auto *SizeOf = const auto *SizeOf =
Result.Nodes.getNodeAs<UnaryExprOrTypeTraitExpr>("sizeof"); Result.Nodes.getNodeAs<UnaryExprOrTypeTraitExpr>("sizeof");
auto Diag = auto Diag =
diag(SizeOf->getBeginLoc(), "sizeof() doesn't return the size of the " diag(SizeOf->getBeginLoc(), "sizeof() doesn't return the size of the "
"container; did you mean .size()?"); "container; did you mean .size()?");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SizeofExpressionCheck.cpp - clang-tidy----------------------------===// //===--- SizeofExpressionCheck.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SizeofExpressionCheck.h" #include "SizeofExpressionCheck.h"
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) { AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) {
return Node.getValue().ugt(N); return Node.getValue().ugt(N);
} }
AST_MATCHER_P2(Expr, hasSizeOfDescendant, int, Depth, AST_MATCHER_P2(Expr, hasSizeOfDescendant, int, Depth,
▲ Show 20 Lines • Show All 328 Lines • ▼ Show 20 Lines if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-constant")) {
if ((LPtrTy == RPtrTy) && (LPtrTy == SizeofArgTy)) { if ((LPtrTy == RPtrTy) && (LPtrTy == SizeofArgTy)) {
diag(E->getBeginLoc(), "suspicious usage of 'sizeof(...)' in " diag(E->getBeginLoc(), "suspicious usage of 'sizeof(...)' in "
"pointer arithmetic"); "pointer arithmetic");
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SmartPtrArrayMismatchCheck.cpp - clang-tidy ----------------------===// //===--- SmartPtrArrayMismatchCheck.cpp - clang-tidy ----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SmartPtrArrayMismatchCheck.h" #include "SmartPtrArrayMismatchCheck.h"
#include "../utils/ASTUtils.h" #include "../utils/ASTUtils.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
constexpr char ConstructExprN[] = "found_construct_expr"; constexpr char ConstructExprN[] = "found_construct_expr";
constexpr char NewExprN[] = "found_new_expr"; constexpr char NewExprN[] = "found_new_expr";
constexpr char ConstructorN[] = "found_constructor"; constexpr char ConstructorN[] = "found_constructor";
bool isInSingleDeclStmt(const DeclaratorDecl *D) { bool isInSingleDeclStmt(const DeclaratorDecl *D) {
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines if (isInSingleDeclStmt(VarOrField)) {
SourceLocation InsertLoc = Lexer::getLocForEndOfToken( SourceLocation InsertLoc = Lexer::getLocForEndOfToken(
TemplateArgumentRange.getEnd(), 0, SM, Ctx.getLangOpts()); TemplateArgumentRange.getEnd(), 0, SM, Ctx.getLangOpts());
D << FixItHint::CreateInsertion(InsertLoc, "[]"); D << FixItHint::CreateInsertion(InsertLoc, "[]");
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SpuriouslyWakeUpFunctionsCheck.cpp - clang-tidy ------------------===// //===--- SpuriouslyWakeUpFunctionsCheck.cpp - clang-tidy ------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SpuriouslyWakeUpFunctionsCheck.h" #include "SpuriouslyWakeUpFunctionsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void SpuriouslyWakeUpFunctionsCheck::registerMatchers(MatchFinder *Finder) { void SpuriouslyWakeUpFunctionsCheck::registerMatchers(MatchFinder *Finder) {
auto HasUniqueLock = hasDescendant(declRefExpr( auto HasUniqueLock = hasDescendant(declRefExpr(
hasDeclaration(varDecl(hasType(recordDecl(classTemplateSpecializationDecl( hasDeclaration(varDecl(hasType(recordDecl(classTemplateSpecializationDecl(
hasName("::std::unique_lock"), hasName("::std::unique_lock"),
hasTemplateArgument( hasTemplateArgument(
0, templateArgument(refersToType(qualType(hasDeclaration( 0, templateArgument(refersToType(qualType(hasDeclaration(
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Linesvoid SpuriouslyWakeUpFunctionsCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *MatchedWait = Result.Nodes.getNodeAs<CallExpr>("wait"); const auto *MatchedWait = Result.Nodes.getNodeAs<CallExpr>("wait");
StringRef WaitName = MatchedWait->getDirectCallee()->getName(); StringRef WaitName = MatchedWait->getDirectCallee()->getName();
diag(MatchedWait->getExprLoc(), diag(MatchedWait->getExprLoc(),
"'%0' should be placed inside a while statement %select{|or used with a " "'%0' should be placed inside a while statement %select{|or used with a "
"conditional parameter}1") "conditional parameter}1")
<< WaitName << (WaitName != "cnd_wait" && WaitName != "cnd_timedwait"); << WaitName << (WaitName != "cnd_wait" && WaitName != "cnd_timedwait");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 18 Lines
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Basic/Diagnostic.h" #include "clang/Basic/Diagnostic.h"
#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceLocation.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
using ast_matchers::BoundNodes; using ast_matchers::BoundNodes;
using ast_matchers::callee; using ast_matchers::callee;
using ast_matchers::callExpr; using ast_matchers::callExpr;
using ast_matchers::cxxMemberCallExpr; using ast_matchers::cxxMemberCallExpr;
using ast_matchers::cxxMethodDecl; using ast_matchers::cxxMethodDecl;
using ast_matchers::expr; using ast_matchers::expr;
using ast_matchers::functionDecl; using ast_matchers::functionDecl;
▲ Show 20 Lines • Show All 164 Lines • ▼ Show 20 Lines if (const auto *MemberCall =
} }
diag(NonMemberLoc, "ignoring the result of '%0'") diag(NonMemberLoc, "ignoring the result of '%0'")
<< llvm::dyn_cast<NamedDecl>(NonMemberCall->getCalleeDecl()) << llvm::dyn_cast<NamedDecl>(NonMemberCall->getCalleeDecl())
->getQualifiedNameAsString(); ->getQualifiedNameAsString();
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- StringConstructorCheck.cpp - clang-tidy---------------------------===// //===--- StringConstructorCheck.cpp - clang-tidy---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StringConstructorCheck.h" #include "StringConstructorCheck.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) { AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) {
return Node.getValue().getZExtValue() > N; return Node.getValue().getZExtValue() > N;
} }
const char DefaultStringNames[] = const char DefaultStringNames[] =
"::std::basic_string;::std::basic_string_view"; "::std::basic_string;::std::basic_string_view";
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Lines if (!Ptr->isInstantiationDependent() &&
// `bugprone-stringview-nullptr` // `bugprone-stringview-nullptr`
return; return;
} }
diag(Loc, "constructing string from nullptr is undefined behaviour"); diag(Loc, "constructing string from nullptr is undefined behaviour");
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- StringIntegerAssignmentCheck.cpp - clang-tidy---------------------===// //===--- StringIntegerAssignmentCheck.cpp - clang-tidy---------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StringIntegerAssignmentCheck.h" #include "StringIntegerAssignmentCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void StringIntegerAssignmentCheck::registerMatchers(MatchFinder *Finder) { void StringIntegerAssignmentCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
cxxOperatorCallExpr( cxxOperatorCallExpr(
hasAnyOverloadedOperatorName("=", "+="), hasAnyOverloadedOperatorName("=", "+="),
callee(cxxMethodDecl(ofClass(classTemplateSpecializationDecl( callee(cxxMethodDecl(ofClass(classTemplateSpecializationDecl(
hasName("::std::basic_string"), hasName("::std::basic_string"),
hasTemplateArgument(0, refersToType(hasCanonicalType( hasTemplateArgument(0, refersToType(hasCanonicalType(
▲ Show 20 Lines • Show All 145 Lines • ▼ Show 20 Linesvoid StringIntegerAssignmentCheck::check(
if (getLangOpts().CPlusPlus11) { if (getLangOpts().CPlusPlus11) {
Diag << FixItHint::CreateInsertion(Loc, IsWideCharType ? "std::to_wstring(" Diag << FixItHint::CreateInsertion(Loc, IsWideCharType ? "std::to_wstring("
: "std::to_string(") : "std::to_string(")
<< FixItHint::CreateInsertion(EndLoc, ")"); << FixItHint::CreateInsertion(EndLoc, ")");
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- StringLiteralWithEmbeddedNulCheck.cpp - clang-tidy----------------===// //===--- StringLiteralWithEmbeddedNulCheck.cpp - clang-tidy----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StringLiteralWithEmbeddedNulCheck.h" #include "StringLiteralWithEmbeddedNulCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER(StringLiteral, containsNul) { AST_MATCHER(StringLiteral, containsNul) {
for (size_t I = 0; I < Node.getLength(); ++I) for (size_t I = 0; I < Node.getLength(); ++I)
if (Node.getCodeUnit(I) == '\0') if (Node.getCodeUnit(I) == '\0')
return true; return true;
return false; return false;
} }
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Linesvoid StringLiteralWithEmbeddedNulCheck::check(
} }
if (const auto *SL = Result.Nodes.getNodeAs<StringLiteral>("truncated")) { if (const auto *SL = Result.Nodes.getNodeAs<StringLiteral>("truncated")) {
diag(SL->getBeginLoc(), diag(SL->getBeginLoc(),
"truncated string literal with embedded NUL character"); "truncated string literal with embedded NUL character");
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 12 Lines
#include "clang/AST/OperationKinds.h" #include "clang/AST/OperationKinds.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Tooling/Transformer/RangeSelector.h" #include "clang/Tooling/Transformer/RangeSelector.h"
#include "clang/Tooling/Transformer/RewriteRule.h" #include "clang/Tooling/Transformer/RewriteRule.h"
#include "clang/Tooling/Transformer/Stencil.h" #include "clang/Tooling/Transformer/Stencil.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
using namespace ::clang::ast_matchers; using namespace ::clang::ast_matchers;
using namespace ::clang::transformer; using namespace ::clang::transformer;
namespace { namespace {
AST_MATCHER_P(InitListExpr, initCountIs, unsigned, N) { AST_MATCHER_P(InitListExpr, initCountIs, unsigned, N) {
return Node.getNumInits() == N; return Node.getNumInits() == N;
▲ Show 20 Lines • Show All 265 Lines • ▼ Show 20 Lines return applyFirst(
HandleConstructorInvocation}); HandleConstructorInvocation});
} }
StringviewNullptrCheck::StringviewNullptrCheck(StringRef Name, StringviewNullptrCheck::StringviewNullptrCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: utils::TransformerClangTidyCheck(StringviewNullptrCheckImpl(), Name, : utils::TransformerClangTidyCheck(StringviewNullptrCheckImpl(), Name,
Context) {} Context) {}
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SuspiciousEnumUsageCheck.cpp - clang-tidy-------------------------===// //===--- SuspiciousEnumUsageCheck.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SuspiciousEnumUsageCheck.h" #include "SuspiciousEnumUsageCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <algorithm> #include <algorithm>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
static const char DifferentEnumErrorMessage[] = static const char DifferentEnumErrorMessage[] =
"enum values are from different enum types"; "enum values are from different enum types";
static const char BitmaskErrorMessage[] = static const char BitmaskErrorMessage[] =
"enum type seems like a bitmask (contains mostly " "enum type seems like a bitmask (contains mostly "
"power-of-2 literals), but this literal is not a " "power-of-2 literals), but this literal is not a "
"power-of-2"; "power-of-2";
▲ Show 20 Lines • Show All 176 Lines • ▼ Show 20 Linesvoid SuspiciousEnumUsageCheck::check(const MatchFinder::MatchResult &Result) {
// '|' or '+' operator where both argument comes from the same enum type // '|' or '+' operator where both argument comes from the same enum type
const auto *LhsExpr = Result.Nodes.getNodeAs<Expr>("lhsExpr"); const auto *LhsExpr = Result.Nodes.getNodeAs<Expr>("lhsExpr");
checkSuspiciousBitmaskUsage(LhsExpr, EnumDec); checkSuspiciousBitmaskUsage(LhsExpr, EnumDec);
const auto *RhsExpr = Result.Nodes.getNodeAs<Expr>("rhsExpr"); const auto *RhsExpr = Result.Nodes.getNodeAs<Expr>("rhsExpr");
checkSuspiciousBitmaskUsage(RhsExpr, EnumDec); checkSuspiciousBitmaskUsage(RhsExpr, EnumDec);
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SuspiciousIncludeCheck.cpp - clang-tidy --------------------------===// //===--- SuspiciousIncludeCheck.cpp - clang-tidy --------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SuspiciousIncludeCheck.h" #include "SuspiciousIncludeCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
class SuspiciousIncludePPCallbacks : public PPCallbacks { class SuspiciousIncludePPCallbacks : public PPCallbacks {
public: public:
explicit SuspiciousIncludePPCallbacks(SuspiciousIncludeCheck &Check, explicit SuspiciousIncludePPCallbacks(SuspiciousIncludeCheck &Check,
const SourceManager &SM, const SourceManager &SM,
Preprocessor *PP) Preprocessor *PP)
: Check(Check), PP(PP) {} : Check(Check), PP(PP) {}
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines OptionalFileEntryRef File =
nullptr, nullptr, nullptr, nullptr, nullptr, nullptr); nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
if (File) { if (File) {
Check.diag(DiagLoc, "did you mean to include '%0'?", DiagnosticIDs::Note) Check.diag(DiagLoc, "did you mean to include '%0'?", DiagnosticIDs::Note)
<< GuessedFileName; << GuessedFileName;
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SuspiciousMemoryComparisonCheck.cpp - clang-tidy -----------------===// //===--- SuspiciousMemoryComparisonCheck.cpp - clang-tidy -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SuspiciousMemoryComparisonCheck.h" #include "SuspiciousMemoryComparisonCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
static std::optional<uint64_t> tryEvaluateSizeExpr(const Expr *SizeExpr, static std::optional<uint64_t> tryEvaluateSizeExpr(const Expr *SizeExpr,
const ASTContext &Ctx) { const ASTContext &Ctx) {
Expr::EvalResult Result; Expr::EvalResult Result;
if (SizeExpr->EvaluateAsRValue(Result, Ctx)) if (SizeExpr->EvaluateAsRValue(Result, Ctx))
return Ctx.toBits( return Ctx.toBits(
CharUnits::fromQuantity(Result.Val.getInt().getExtValue())); CharUnits::fromQuantity(Result.Val.getInt().getExtValue()));
return std::nullopt; return std::nullopt;
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines if (!PointeeType->isIncompleteType()) {
"values|the members of the object}1 manually") "values|the members of the object}1 manually")
<< PointeeQualifiedType << (PointeeType->isRecordType() ? 1 : 0); << PointeeQualifiedType << (PointeeType->isRecordType() ? 1 : 0);
break; break;
} }
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void SuspiciousMemsetUsageCheck::registerMatchers(MatchFinder *Finder) { void SuspiciousMemsetUsageCheck::registerMatchers(MatchFinder *Finder) {
// Match the standard memset: // Match the standard memset:
// void *memset(void *buffer, int fill_char, size_t byte_count); // void *memset(void *buffer, int fill_char, size_t byte_count);
auto MemsetDecl = auto MemsetDecl =
functionDecl(hasName("::memset"), functionDecl(hasName("::memset"),
parameterCountIs(3), parameterCountIs(3),
hasParameter(0, hasType(pointerType(pointee(voidType())))), hasParameter(0, hasType(pointerType(pointee(voidType())))),
▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines else if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call")) {
if (LHSString.empty() || RHSString.empty()) if (LHSString.empty() || RHSString.empty())
return; return;
D << tooling::fixit::createReplacement(*FillChar, RHSString) D << tooling::fixit::createReplacement(*FillChar, RHSString)
<< tooling::fixit::createReplacement(*ByteCount, LHSString); << tooling::fixit::createReplacement(*ByteCount, LHSString);
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SuspiciousMissingCommaCheck.cpp - clang-tidy----------------------===// //===--- SuspiciousMissingCommaCheck.cpp - clang-tidy----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SuspiciousMissingCommaCheck.h" #include "SuspiciousMissingCommaCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
bool isConcatenatedLiteralsOnPurpose(ASTContext *Ctx, bool isConcatenatedLiteralsOnPurpose(ASTContext *Ctx,
const StringLiteral *Lit) { const StringLiteral *Lit) {
// String literals surrounded by parentheses are assumed to be on purpose. // String literals surrounded by parentheses are assumed to be on purpose.
// i.e.: const char* Array[] = { ("a" "b" "c"), "d", [...] }; // i.e.: const char* Array[] = { ("a" "b" "c"), "d", [...] };
▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Linesvoid SuspiciousMissingCommaCheck::check(
// The current threshold is set to less than 1/5 of the string literals. // The current threshold is set to less than 1/5 of the string literals.
if (double(Count) / Size > RatioThreshold) if (double(Count) / Size > RatioThreshold)
return; return;
diag(ConcatenatedLiteral->getBeginLoc(), diag(ConcatenatedLiteral->getBeginLoc(),
"suspicious string literal, probably missing a comma"); "suspicious string literal, probably missing a comma");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Lines for (const Stmt *Child : S->children())
if (Child && Visit(Child)) if (Child && Visit(Child))
return true; return true;
return false; return false;
} }
}; };
} // namespace } // namespace
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void SuspiciousReallocUsageCheck::registerMatchers(MatchFinder *Finder) { void SuspiciousReallocUsageCheck::registerMatchers(MatchFinder *Finder) {
// void *realloc(void *ptr, size_t size); // void *realloc(void *ptr, size_t size);
auto ReallocDecl = auto ReallocDecl =
functionDecl(hasName("::realloc"), parameterCountIs(2), functionDecl(hasName("::realloc"), parameterCountIs(2),
hasParameter(0, hasType(pointerType(pointee(voidType())))), hasParameter(0, hasType(pointerType(pointee(voidType())))),
hasParameter(1, hasType(isInteger()))) hasParameter(1, hasType(isInteger())))
.bind("realloc"); .bind("realloc");
Show All 36 Lines StringRef CodeOfAssignedExpr = Lexer::getSourceText(
CharSourceRange::getTokenRange(PtrResultExpr->getSourceRange()), SM, CharSourceRange::getTokenRange(PtrResultExpr->getSourceRange()), SM,
getLangOpts()); getLangOpts());
diag(Call->getBeginLoc(), "'%0' may be set to null if 'realloc' fails, which " diag(Call->getBeginLoc(), "'%0' may be set to null if 'realloc' fails, which "
"may result in a leak of the original buffer") "may result in a leak of the original buffer")
<< CodeOfAssignedExpr << PtrInputExpr->getSourceRange() << CodeOfAssignedExpr << PtrInputExpr->getSourceRange()
<< PtrResultExpr->getSourceRange(); << PtrResultExpr->getSourceRange();
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SuspiciousSemicolonCheck.cpp - clang-tidy-------------------------===// //===--- SuspiciousSemicolonCheck.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SuspiciousSemicolonCheck.h" #include "SuspiciousSemicolonCheck.h"
#include "../utils/LexerUtils.h" #include "../utils/LexerUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void SuspiciousSemicolonCheck::registerMatchers(MatchFinder *Finder) { void SuspiciousSemicolonCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
stmt(anyOf(ifStmt(hasThen(nullStmt().bind("semi")), stmt(anyOf(ifStmt(hasThen(nullStmt().bind("semi")),
unless(hasElse(stmt())), unless(hasElse(stmt())),
unless(isConstexpr())), unless(isConstexpr())),
forStmt(hasBody(nullStmt().bind("semi"))), forStmt(hasBody(nullStmt().bind("semi"))),
cxxForRangeStmt(hasBody(nullStmt().bind("semi"))), cxxForRangeStmt(hasBody(nullStmt().bind("semi"))),
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Linesvoid SuspiciousSemicolonCheck::check(const MatchFinder::MatchResult &Result) {
if (!IsIfStmt && NewTokenIndent <= BaseIndent && if (!IsIfStmt && NewTokenIndent <= BaseIndent &&
Token.getKind() != tok::l_brace && NewTokenLine != SemicolonLine) Token.getKind() != tok::l_brace && NewTokenLine != SemicolonLine)
return; return;
diag(LocStart, "potentially unintended semicolon") diag(LocStart, "potentially unintended semicolon")
<< FixItHint::CreateRemoval(SourceRange(LocStart, LocEnd)); << FixItHint::CreateRemoval(SourceRange(LocStart, LocEnd));
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
// Semicolon separated list of known string compare-like functions. The list // Semicolon separated list of known string compare-like functions. The list
// must ends with a semicolon. // must ends with a semicolon.
static const char KnownStringCompareFunctions[] = "__builtin_memcmp;" static const char KnownStringCompareFunctions[] = "__builtin_memcmp;"
"__builtin_strcasecmp;" "__builtin_strcasecmp;"
"__builtin_strcmp;" "__builtin_strcmp;"
"__builtin_strncasecmp;" "__builtin_strncasecmp;"
"__builtin_strncmp;" "__builtin_strncmp;"
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Linesvoid SuspiciousStringCompareCheck::check(
} }
if (Result.Nodes.getNodeAs<Stmt>("invalid-conversion")) { if (Result.Nodes.getNodeAs<Stmt>("invalid-conversion")) {
diag(Call->getBeginLoc(), "function %0 has suspicious implicit cast") diag(Call->getBeginLoc(), "function %0 has suspicious implicit cast")
<< Decl; << Decl;
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- SwappedArgumentsCheck.cpp - clang-tidy ---------------------------===// //===--- SwappedArgumentsCheck.cpp - clang-tidy ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SwappedArgumentsCheck.h" #include "SwappedArgumentsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void SwappedArgumentsCheck::registerMatchers(MatchFinder *Finder) { void SwappedArgumentsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(callExpr().bind("call"), this); Finder->addMatcher(callExpr().bind("call"), this);
} }
/// Look through lvalue to rvalue and nop casts. This filters out /// Look through lvalue to rvalue and nop casts. This filters out
/// implicit conversions that have no effect on the input but block our view for /// implicit conversions that have no effect on the input but block our view for
/// other implicit casts. /// other implicit casts.
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines diag(Call->getBeginLoc(), "argument with implicit conversion from %0 "
<< tooling::fixit::createReplacement(*LHS, *RHS, Ctx) << tooling::fixit::createReplacement(*LHS, *RHS, Ctx)
<< tooling::fixit::createReplacement(*RHS, *LHS, Ctx); << tooling::fixit::createReplacement(*RHS, *LHS, Ctx);
// Remember that we emitted a warning for this argument. // Remember that we emitted a warning for this argument.
UsedArgs.insert(RHSCast); UsedArgs.insert(RHSCast);
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- TerminatingContinueCheck.cpp - clang-tidy-------------------------===// //===--- TerminatingContinueCheck.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TerminatingContinueCheck.h" #include "TerminatingContinueCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void TerminatingContinueCheck::registerMatchers(MatchFinder *Finder) { void TerminatingContinueCheck::registerMatchers(MatchFinder *Finder) {
const auto DoWithFalse = const auto DoWithFalse =
doStmt(hasCondition(ignoringImpCasts( doStmt(hasCondition(ignoringImpCasts(
anyOf(cxxBoolLiteral(equals(false)), integerLiteral(equals(0)), anyOf(cxxBoolLiteral(equals(false)), integerLiteral(equals(0)),
cxxNullPtrLiteralExpr(), gnuNullExpr()))), cxxNullPtrLiteralExpr(), gnuNullExpr()))),
equalsBoundNode("closestLoop")); equalsBoundNode("closestLoop"));
Show All 11 Linesvoid TerminatingContinueCheck::check(const MatchFinder::MatchResult &Result) {
const auto *ContStmt = Result.Nodes.getNodeAs<ContinueStmt>("continue"); const auto *ContStmt = Result.Nodes.getNodeAs<ContinueStmt>("continue");
auto Diag = auto Diag =
diag(ContStmt->getBeginLoc(), diag(ContStmt->getBeginLoc(),
"'continue' in loop with false condition is equivalent to 'break'") "'continue' in loop with false condition is equivalent to 'break'")
<< tooling::fixit::createReplacement(*ContStmt, "break"); << tooling::fixit::createReplacement(*ContStmt, "break");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- ThrowKeywordMissingCheck.cpp - clang-tidy-------------------------===// //===--- ThrowKeywordMissingCheck.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ThrowKeywordMissingCheck.h" #include "ThrowKeywordMissingCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
void ThrowKeywordMissingCheck::registerMatchers(MatchFinder *Finder) { void ThrowKeywordMissingCheck::registerMatchers(MatchFinder *Finder) {
auto CtorInitializerList = auto CtorInitializerList =
cxxConstructorDecl(hasAnyConstructorInitializer(anything())); cxxConstructorDecl(hasAnyConstructorInitializer(anything()));
Finder->addMatcher( Finder->addMatcher(
cxxConstructExpr( cxxConstructExpr(
hasType(cxxRecordDecl( hasType(cxxRecordDecl(
Show All 13 Linesvoid ThrowKeywordMissingCheck::check(const MatchFinder::MatchResult &Result) {
const auto *TemporaryExpr = const auto *TemporaryExpr =
Result.Nodes.getNodeAs<Expr>("temporary-exception-not-thrown"); Result.Nodes.getNodeAs<Expr>("temporary-exception-not-thrown");
diag(TemporaryExpr->getBeginLoc(), "suspicious exception object created but " diag(TemporaryExpr->getBeginLoc(), "suspicious exception object created but "
"not thrown; did you mean 'throw %0'?") "not thrown; did you mean 'throw %0'?")
<< TemporaryExpr->getType().getBaseTypeIdentifier()->getName(); << TemporaryExpr->getType().getBaseTypeIdentifier()->getName();
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- TooSmallLoopVariableCheck.cpp - clang-tidy -----------------------===// //===--- TooSmallLoopVariableCheck.cpp - clang-tidy -----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TooSmallLoopVariableCheck.h" #include "TooSmallLoopVariableCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
static constexpr llvm::StringLiteral LoopName = static constexpr llvm::StringLiteral LoopName =
llvm::StringLiteral("forLoopName"); llvm::StringLiteral("forLoopName");
static constexpr llvm::StringLiteral LoopVarName = static constexpr llvm::StringLiteral LoopVarName =
llvm::StringLiteral("loopVar"); llvm::StringLiteral("loopVar");
static constexpr llvm::StringLiteral LoopVarCastName = static constexpr llvm::StringLiteral LoopVarCastName =
llvm::StringLiteral("loopVarCast"); llvm::StringLiteral("loopVarCast");
static constexpr llvm::StringLiteral LoopUpperBoundName = static constexpr llvm::StringLiteral LoopUpperBoundName =
▲ Show 20 Lines • Show All 144 Lines • ▼ Show 20 Lines if (LoopVarMagnitudeBits > MagnitudeBitsUpperLimit)
return; return;
if (LoopVarMagnitudeBits < UpperBoundMagnitudeBits) if (LoopVarMagnitudeBits < UpperBoundMagnitudeBits)
diag(LoopVar->getBeginLoc(), "loop variable has narrower type %0 than " diag(LoopVar->getBeginLoc(), "loop variable has narrower type %0 than "
"iteration's upper bound %1") "iteration's upper bound %1")
<< LoopVarType << UpperBoundType; << LoopVarType << UpperBoundType;
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 18 Lines
#include "clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h" #include "clang/Analysis/FlowSensitive/WatchedLiteralsSolver.h"
#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.h"
#include <memory> #include <memory>
#include <optional> #include <optional>
#include <vector> #include <vector>
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
using ast_matchers::MatchFinder; using ast_matchers::MatchFinder;
using dataflow::UncheckedOptionalAccessDiagnoser; using dataflow::UncheckedOptionalAccessDiagnoser;
using dataflow::UncheckedOptionalAccessModel; using dataflow::UncheckedOptionalAccessModel;
using dataflow::UncheckedOptionalAccessModelOptions; using dataflow::UncheckedOptionalAccessModelOptions;
static constexpr llvm::StringLiteral FuncID("fun"); static constexpr llvm::StringLiteral FuncID("fun");
static std::optional<std::vector<SourceLocation>> static std::optional<std::vector<SourceLocation>>
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines if (FuncDecl->isTemplated())
return; return;
if (std::optional<std::vector<SourceLocation>> Errors = if (std::optional<std::vector<SourceLocation>> Errors =
analyzeFunction(*FuncDecl, *Result.Context, ModelOptions)) analyzeFunction(*FuncDecl, *Result.Context, ModelOptions))
for (const SourceLocation &Loc : *Errors) for (const SourceLocation &Loc : *Errors)
diag(Loc, "unchecked access to optional value"); diag(Loc, "unchecked access to optional value");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- UndefinedMemoryManipulationCheck.cpp - clang-tidy-----------------===// //===--- UndefinedMemoryManipulationCheck.cpp - clang-tidy-----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UndefinedMemoryManipulationCheck.h" #include "UndefinedMemoryManipulationCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER(CXXRecordDecl, isNotTriviallyCopyable) { AST_MATCHER(CXXRecordDecl, isNotTriviallyCopyable) {
// For incomplete types, assume they are TriviallyCopyable. // For incomplete types, assume they are TriviallyCopyable.
return Node.hasDefinition() ? !Node.isTriviallyCopyable() : false; return Node.hasDefinition() ? !Node.isTriviallyCopyable() : false;
} }
} // namespace } // namespace
Show All 34 Lines if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("src")) {
if (!SourceType->getPointeeType().isNull()) if (!SourceType->getPointeeType().isNull())
SourceType = SourceType->getPointeeType(); SourceType = SourceType->getPointeeType();
diag(Call->getBeginLoc(), diag(Call->getBeginLoc(),
"undefined behavior, source object type %0 is not TriviallyCopyable") "undefined behavior, source object type %0 is not TriviallyCopyable")
<< SourceType; << SourceType;
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- UndelegatedConstructorCheck.cpp - clang-tidy --------------------------===// //===--- UndelegatedConstructorCheck.cpp - clang-tidy --------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UndelegatedConstructorCheck.h" #include "UndelegatedConstructorCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER_P(Stmt, ignoringTemporaryExpr, AST_MATCHER_P(Stmt, ignoringTemporaryExpr,
ast_matchers::internal::Matcher<Stmt>, InnerMatcher) { ast_matchers::internal::Matcher<Stmt>, InnerMatcher) {
const Stmt *E = &Node; const Stmt *E = &Node;
for (;;) { for (;;) {
// Temporaries with non-trivial dtors. // Temporaries with non-trivial dtors.
if (const auto *EWC = dyn_cast<ExprWithCleanups>(E)) if (const auto *EWC = dyn_cast<ExprWithCleanups>(E))
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
void UndelegatedConstructorCheck::check( void UndelegatedConstructorCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("construct"); const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("construct");
diag(E->getBeginLoc(), "did you intend to call a delegated constructor? " diag(E->getBeginLoc(), "did you intend to call a delegated constructor? "
"A temporary object is created here instead"); "A temporary object is created here instead");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- UnhandledExceptionAtNewCheck.cpp - clang-tidy --------------------===// //===--- UnhandledExceptionAtNewCheck.cpp - clang-tidy --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnhandledExceptionAtNewCheck.h" #include "UnhandledExceptionAtNewCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
AST_MATCHER_P(CXXTryStmt, hasHandlerFor, AST_MATCHER_P(CXXTryStmt, hasHandlerFor,
ast_matchers::internal::Matcher<QualType>, InnerMatcher) { ast_matchers::internal::Matcher<QualType>, InnerMatcher) {
for (unsigned NH = Node.getNumHandlers(), I = 0; I < NH; ++I) { for (unsigned NH = Node.getNumHandlers(), I = 0; I < NH; ++I) {
const CXXCatchStmt *CatchS = Node.getHandler(I); const CXXCatchStmt *CatchS = Node.getHandler(I);
// Check for generic catch handler (match anything). // Check for generic catch handler (match anything).
if (CatchS->getCaughtType().isNull()) if (CatchS->getCaughtType().isNull())
return true; return true;
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
void UnhandledExceptionAtNewCheck::check( void UnhandledExceptionAtNewCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *MatchedExpr = Result.Nodes.getNodeAs<CXXNewExpr>("new-expr"); const auto *MatchedExpr = Result.Nodes.getNodeAs<CXXNewExpr>("new-expr");
if (MatchedExpr) if (MatchedExpr)
diag(MatchedExpr->getBeginLoc(), diag(MatchedExpr->getBeginLoc(),
"missing exception handler for allocation failure at 'new'"); "missing exception handler for allocation failure at 'new'");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- UnhandledSelfAssignmentCheck.cpp - clang-tidy --------------------===// //===--- UnhandledSelfAssignmentCheck.cpp - clang-tidy --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnhandledSelfAssignmentCheck.h" #include "UnhandledSelfAssignmentCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
UnhandledSelfAssignmentCheck::UnhandledSelfAssignmentCheck( UnhandledSelfAssignmentCheck::UnhandledSelfAssignmentCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
WarnOnlyIfThisHasSuspiciousField( WarnOnlyIfThisHasSuspiciousField(
Options.get("WarnOnlyIfThisHasSuspiciousField", true)) {} Options.get("WarnOnlyIfThisHasSuspiciousField", true)) {}
void UnhandledSelfAssignmentCheck::storeOptions( void UnhandledSelfAssignmentCheck::storeOptions(
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines
void UnhandledSelfAssignmentCheck::check( void UnhandledSelfAssignmentCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *MatchedDecl = const auto *MatchedDecl =
Result.Nodes.getNodeAs<CXXMethodDecl>("copyAssignmentOperator"); Result.Nodes.getNodeAs<CXXMethodDecl>("copyAssignmentOperator");
diag(MatchedDecl->getLocation(), diag(MatchedDecl->getLocation(),
"operator=() does not handle self-assignment properly"); "operator=() does not handle self-assignment properly");
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- UnusedRaiiCheck.cpp - clang-tidy ---------------------------------===// //===--- UnusedRaiiCheck.cpp - clang-tidy ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnusedRaiiCheck.h" #include "UnusedRaiiCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER(CXXRecordDecl, hasNonTrivialDestructor) { AST_MATCHER(CXXRecordDecl, hasNonTrivialDestructor) {
// TODO: If the dtor is there but empty we don't want to warn either. // TODO: If the dtor is there but empty we don't want to warn either.
return Node.hasDefinition() && Node.hasNonTrivialDestructor(); return Node.hasDefinition() && Node.hasNonTrivialDestructor();
} }
} // namespace } // namespace
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines if (!DefaultConstruction) {
DefaultConstruction = ILE->getNumInits() == 0; DefaultConstruction = ILE->getNumInits() == 0;
SR = SourceRange(ILE->getLBraceLoc(), ILE->getRBraceLoc()); SR = SourceRange(ILE->getLBraceLoc(), ILE->getRBraceLoc());
} }
} }
reportDiagnostic(D, Node, SR, DefaultConstruction); reportDiagnostic(D, Node, SR, DefaultConstruction);
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- UnusedReturnValueCheck.cpp - clang-tidy---------------------------===// //===--- UnusedReturnValueCheck.cpp - clang-tidy---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnusedReturnValueCheck.h" #include "UnusedReturnValueCheck.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::ast_matchers::internal; using namespace clang::ast_matchers::internal;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
// Matches functions that are instantiated from a class template member function // Matches functions that are instantiated from a class template member function
// matching InnerMatcher. Functions not instantiated from a class template // matching InnerMatcher. Functions not instantiated from a class template
// member function are matched directly with InnerMatcher. // member function are matched directly with InnerMatcher.
AST_MATCHER_P(FunctionDecl, isInstantiatedFrom, Matcher<FunctionDecl>, AST_MATCHER_P(FunctionDecl, isInstantiatedFrom, Matcher<FunctionDecl>,
InnerMatcher) { InnerMatcher) {
▲ Show 20 Lines • Show All 143 Lines • ▼ Show 20 Lines diag(Matched->getBeginLoc(),
"the value returned by this function should be used") "the value returned by this function should be used")
<< Matched->getSourceRange(); << Matched->getSourceRange();
diag(Matched->getBeginLoc(), diag(Matched->getBeginLoc(),
"cast the expression to void to silence this warning", "cast the expression to void to silence this warning",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show All 16 Lines
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "../utils/ExprSequence.h" #include "../utils/ExprSequence.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::tidy::utils; using namespace clang::tidy::utils;
namespace clang::tidy::bugprone {
namespace clang {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER(Expr, hasUnevaluatedContext) { AST_MATCHER(Expr, hasUnevaluatedContext) {
if (isa<CXXNoexceptExpr>(Node) || isa<RequiresExpr>(Node)) if (isa<CXXNoexceptExpr>(Node) || isa<RequiresExpr>(Node))
return true; return true;
if (const auto *UnaryExpr = dyn_cast<UnaryExprOrTypeTraitExpr>(&Node)) { if (const auto *UnaryExpr = dyn_cast<UnaryExprOrTypeTraitExpr>(&Node)) {
switch (UnaryExpr->getKind()) { switch (UnaryExpr->getKind()) {
▲ Show 20 Lines • Show All 425 Lines • ▼ Show 20 Lines if (!Arg->getDecl()->getDeclContext()->isFunctionOrMethod())
return; return;
UseAfterMoveFinder Finder(Result.Context); UseAfterMoveFinder Finder(Result.Context);
UseAfterMove Use; UseAfterMove Use;
if (Finder.find(FunctionBody, MovingCall, Arg->getDecl(), &Use)) if (Finder.find(FunctionBody, MovingCall, Arg->getDecl(), &Use))
emitDiagnostic(MovingCall, Arg, Use, this, Result.Context); emitDiagnostic(MovingCall, Arg, Use, this, Result.Context);
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

//===--- VirtualNearMissCheck.cpp - clang-tidy-----------------------------===// //===--- VirtualNearMissCheck.cpp - clang-tidy-----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "VirtualNearMissCheck.h" #include "VirtualNearMissCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/CXXInheritance.h" #include "clang/AST/CXXInheritance.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::bugprone {
namespace tidy {
namespace bugprone {
namespace { namespace {
AST_MATCHER(CXXMethodDecl, isStatic) { return Node.isStatic(); } AST_MATCHER(CXXMethodDecl, isStatic) { return Node.isStatic(); }
AST_MATCHER(CXXMethodDecl, isOverloadedOperator) { AST_MATCHER(CXXMethodDecl, isOverloadedOperator) {
return Node.isOverloadedOperator(); return Node.isOverloadedOperator();
} }
} // namespace } // namespace
▲ Show 20 Lines • Show All 234 Lines • ▼ Show 20 Lines if (const auto *BaseRD = BaseSpec.getType()->getAsCXXRecordDecl()) {
Diag << FixItHint::CreateReplacement(Range, BaseMD->getName()); Diag << FixItHint::CreateReplacement(Range, BaseMD->getName());
} }
} }
} }
} }
} }
} }
} // namespace bugprone } // namespace clang::tidy::bugprone
} // namespace tidy
} // namespace clang

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

Show First 20 Lines • Show All 221 Lines • ▼ Show 20 Linesconst llvm::StringRef CertErr33CCheckedFunctions = "::aligned_alloc;"
"::wctype;" "::wctype;"
"::wmemchr;" "::wmemchr;"
"::wprintf_s;" "::wprintf_s;"
"::wscanf;" "::wscanf;"
"::wscanf_s;"; "::wscanf_s;";
} // namespace } // namespace
namespace clang { namespace clang::tidy {
namespace tidy {
namespace cert { namespace cert {
class CERTModule : public ClangTidyModule { class CERTModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
// C++ checkers // C++ checkers
// CON // CON
CheckFactories.registerCheck<bugprone::SpuriouslyWakeUpFunctionsCheck>( CheckFactories.registerCheck<bugprone::SpuriouslyWakeUpFunctionsCheck>(
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
static ClangTidyModuleRegistry::Add<cert::CERTModule> static ClangTidyModuleRegistry::Add<cert::CERTModule>
X("cert-module", X("cert-module",
"Adds lint checks corresponding to CERT secure coding guidelines."); "Adds lint checks corresponding to CERT secure coding guidelines.");
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the CERTModule. // and thus register the CERTModule.
volatile int CERTModuleAnchorSource = 0; volatile int CERTModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

//===-- CommandProcessorCheck.cpp - clang-tidy ----------------------------===// //===-- CommandProcessorCheck.cpp - clang-tidy ----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CommandProcessorCheck.h" #include "CommandProcessorCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void CommandProcessorCheck::registerMatchers(MatchFinder *Finder) { void CommandProcessorCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
callExpr( callExpr(
callee(functionDecl(hasAnyName("::system", "::popen", "::_popen")) callee(functionDecl(hasAnyName("::system", "::popen", "::_popen"))
.bind("func")), .bind("func")),
// Do not diagnose when the call expression passes a null pointer // Do not diagnose when the call expression passes a null pointer
// constant to system(); that only checks for the presence of a // constant to system(); that only checks for the presence of a
// command processor, which is not a security risk by itself. // command processor, which is not a security risk by itself.
unless(callExpr(callee(functionDecl(hasName("::system"))), unless(callExpr(callee(functionDecl(hasName("::system"))),
argumentCountIs(1), argumentCountIs(1),
hasArgument(0, nullPointerConstant())))) hasArgument(0, nullPointerConstant()))))
.bind("expr"), .bind("expr"),
this); this);
} }
void CommandProcessorCheck::check(const MatchFinder::MatchResult &Result) { void CommandProcessorCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Fn = Result.Nodes.getNodeAs<FunctionDecl>("func"); const auto *Fn = Result.Nodes.getNodeAs<FunctionDecl>("func");
const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr"); const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr");
diag(E->getExprLoc(), "calling %0 uses a command processor") << Fn; diag(E->getExprLoc(), "calling %0 uses a command processor") << Fn;
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

//===--- DefaultOperatorNewCheck.cpp - clang-tidy --------------------===// //===--- DefaultOperatorNewCheck.cpp - clang-tidy --------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DefaultOperatorNewAlignmentCheck.h" #include "DefaultOperatorNewAlignmentCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetInfo.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void DefaultOperatorNewAlignmentCheck::registerMatchers(MatchFinder *Finder) { void DefaultOperatorNewAlignmentCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
cxxNewExpr(unless(hasAnyPlacementArg(anything()))).bind("new"), this); cxxNewExpr(unless(hasAnyPlacementArg(anything()))).bind("new"), this);
} }
void DefaultOperatorNewAlignmentCheck::check( void DefaultOperatorNewAlignmentCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
Show All 31 Linesvoid DefaultOperatorNewAlignmentCheck::check(
if (HasDefaultOperatorNew && OverAligned) if (HasDefaultOperatorNew && OverAligned)
diag(NewExpr->getBeginLoc(), diag(NewExpr->getBeginLoc(),
"allocation function returns a pointer with alignment %0 but the " "allocation function returns a pointer with alignment %0 but the "
"over-aligned type being allocated requires alignment %1") "over-aligned type being allocated requires alignment %1")
<< (DefaultNewAlignment / CharWidth) << (DefaultNewAlignment / CharWidth)
<< (SpecifiedAlignment / CharWidth); << (SpecifiedAlignment / CharWidth);
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

Show All 31 Lines if (matchesFirstInRange(InnerMatcher, PackArgs.begin(), PackArgs.end(),
return true; return true;
} }
return matchesFirstInRange(InnerMatcher, Args.begin(), Args.end(), Finder, return matchesFirstInRange(InnerMatcher, Args.begin(), Args.end(), Finder,
Builder) != Args.end(); Builder) != Args.end();
} }
} // namespace } // namespace
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void DontModifyStdNamespaceCheck::registerMatchers(MatchFinder *Finder) { void DontModifyStdNamespaceCheck::registerMatchers(MatchFinder *Finder) {
auto HasStdParent = auto HasStdParent =
hasDeclContext(namespaceDecl(hasAnyName("std", "posix"), hasDeclContext(namespaceDecl(hasAnyName("std", "posix"),
unless(hasParent(namespaceDecl()))) unless(hasParent(namespaceDecl())))
.bind("nmspc")); .bind("nmspc"));
auto UserDefinedType = qualType( auto UserDefinedType = qualType(
hasUnqualifiedDesugaredType(tagType(unless(hasDeclaration(tagDecl( hasUnqualifiedDesugaredType(tagType(unless(hasDeclaration(tagDecl(
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesvoid DontModifyStdNamespaceCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(decl(anyOf(BadNonTemplateSpecializationDecl, Finder->addMatcher(decl(anyOf(BadNonTemplateSpecializationDecl,
BadClassTemplateSpec, BadInnerClassTemplateSpec, BadClassTemplateSpec, BadInnerClassTemplateSpec,
BadFunctionTemplateSpec, BadMemberFunctionSpec), BadFunctionTemplateSpec, BadMemberFunctionSpec),
unless(isExpansionInSystemHeader())) unless(isExpansionInSystemHeader()))
.bind("decl"), .bind("decl"),
this); this);
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang
static const NamespaceDecl *getTopLevelLexicalNamespaceDecl(const Decl *D) { static const NamespaceDecl *getTopLevelLexicalNamespaceDecl(const Decl *D) {
const NamespaceDecl *LastNS = nullptr; const NamespaceDecl *LastNS = nullptr;
while (D) { while (D) {
if (const auto *NS = dyn_cast<NamespaceDecl>(D)) if (const auto *NS = dyn_cast<NamespaceDecl>(D))
LastNS = NS; LastNS = NS;
D = dyn_cast_or_null<Decl>(D->getLexicalDeclContext()); D = dyn_cast_or_null<Decl>(D->getLexicalDeclContext());
} }
Show All 22 Lines

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

//===--- FloatLoopCounter.cpp - clang-tidy---------------------------------===// //===--- FloatLoopCounter.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FloatLoopCounter.h" #include "FloatLoopCounter.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void FloatLoopCounter::registerMatchers(MatchFinder *Finder) { void FloatLoopCounter::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
forStmt(hasIncrement(expr(hasType(realFloatingPointType())))).bind("for"), forStmt(hasIncrement(expr(hasType(realFloatingPointType())))).bind("for"),
this); this);
} }
void FloatLoopCounter::check(const MatchFinder::MatchResult &Result) { void FloatLoopCounter::check(const MatchFinder::MatchResult &Result) {
const auto *FS = Result.Nodes.getNodeAs<ForStmt>("for"); const auto *FS = Result.Nodes.getNodeAs<ForStmt>("for");
diag(FS->getInc()->getExprLoc(), "loop induction expression should not have " diag(FS->getInc()->getExprLoc(), "loop induction expression should not have "
"floating-point type"); "floating-point type");
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

//===--- LimitedRandomnessCheck.cpp - clang-tidy---------------------------===// //===--- LimitedRandomnessCheck.cpp - clang-tidy---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "LimitedRandomnessCheck.h" #include "LimitedRandomnessCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void LimitedRandomnessCheck::registerMatchers(MatchFinder *Finder) { void LimitedRandomnessCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(callExpr(callee(functionDecl(namedDecl(hasName("::rand")), Finder->addMatcher(callExpr(callee(functionDecl(namedDecl(hasName("::rand")),
parameterCountIs(0)))) parameterCountIs(0))))
.bind("randomGenerator"), .bind("randomGenerator"),
this); this);
} }
void LimitedRandomnessCheck::check(const MatchFinder::MatchResult &Result) { void LimitedRandomnessCheck::check(const MatchFinder::MatchResult &Result) {
std::string Msg; std::string Msg;
if (getLangOpts().CPlusPlus) if (getLangOpts().CPlusPlus)
Msg = "; use C++11 random library instead"; Msg = "; use C++11 random library instead";
const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator"); const auto *MatchedDecl = Result.Nodes.getNodeAs<CallExpr>("randomGenerator");
diag(MatchedDecl->getBeginLoc(), "rand() has limited randomness" + Msg); diag(MatchedDecl->getBeginLoc(), "rand() has limited randomness" + Msg);
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

//===--- MutatingCopyCheck.cpp - clang-tidy -------------------------------===// //===--- MutatingCopyCheck.cpp - clang-tidy -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MutatingCopyCheck.h" #include "MutatingCopyCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
static constexpr llvm::StringLiteral SourceDeclName = "ChangedPVD"; static constexpr llvm::StringLiteral SourceDeclName = "ChangedPVD";
static constexpr llvm::StringLiteral MutatingOperatorName = "MutatingOp"; static constexpr llvm::StringLiteral MutatingOperatorName = "MutatingOp";
static constexpr llvm::StringLiteral MutatingCallName = "MutatingCall"; static constexpr llvm::StringLiteral MutatingCallName = "MutatingCall";
void MutatingCopyCheck::registerMatchers(MatchFinder *Finder) { void MutatingCopyCheck::registerMatchers(MatchFinder *Finder) {
const auto MemberExprOrSourceObject = anyOf( const auto MemberExprOrSourceObject = anyOf(
memberExpr(), memberExpr(),
Show All 40 Linesvoid MutatingCopyCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *MemberCall = if (const auto *MemberCall =
Result.Nodes.getNodeAs<CXXMemberCallExpr>(MutatingCallName)) Result.Nodes.getNodeAs<CXXMemberCallExpr>(MutatingCallName))
diag(MemberCall->getBeginLoc(), "call mutates copied object"); diag(MemberCall->getBeginLoc(), "call mutates copied object");
else if (const auto *Assignment = else if (const auto *Assignment =
Result.Nodes.getNodeAs<Expr>(MutatingOperatorName)) Result.Nodes.getNodeAs<Expr>(MutatingOperatorName))
diag(Assignment->getBeginLoc(), "mutating copied object"); diag(Assignment->getBeginLoc(), "mutating copied object");
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

Show All 13 Lines
#include "clang/ASTMatchers/ASTMatchersInternal.h" #include "clang/ASTMatchers/ASTMatchersInternal.h"
#include "clang/ASTMatchers/ASTMatchersMacros.h" #include "clang/ASTMatchers/ASTMatchersMacros.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
namespace { namespace {
AST_MATCHER(CXXRecordDecl, isTriviallyDefaultConstructible) { AST_MATCHER(CXXRecordDecl, isTriviallyDefaultConstructible) {
return Node.hasTrivialDefaultConstructor(); return Node.hasTrivialDefaultConstructor();
} }
AST_MATCHER(CXXRecordDecl, isTriviallyCopyable) { AST_MATCHER(CXXRecordDecl, isTriviallyCopyable) {
return Node.hasTrivialCopyAssignment() && Node.hasTrivialCopyConstructor(); return Node.hasTrivialCopyAssignment() && Node.hasTrivialCopyConstructor();
} }
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Linesvoid NonTrivialTypesLibcMemoryCallsCheck::check(
} }
if (const auto *Caller = Result.Nodes.getNodeAs<CallExpr>("lazyCompare")) { if (const auto *Caller = Result.Nodes.getNodeAs<CallExpr>("lazyCompare")) {
diag(Caller->getBeginLoc(), diag(Caller->getBeginLoc(),
"consider using comparison operators instead of calling %0") "consider using comparison operators instead of calling %0")
<< cast<NamedDecl>(Caller->getCalleeDecl()); << cast<NamedDecl>(Caller->getCalleeDecl());
} }
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

//===--- PostfixOperatorCheck.cpp - clang-tidy-----------------------------===// //===--- PostfixOperatorCheck.cpp - clang-tidy-----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PostfixOperatorCheck.h" #include "PostfixOperatorCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void PostfixOperatorCheck::registerMatchers(MatchFinder *Finder) { void PostfixOperatorCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(functionDecl(hasAnyOverloadedOperatorName("++", "--"), Finder->addMatcher(functionDecl(hasAnyOverloadedOperatorName("++", "--"),
unless(isInstantiated())) unless(isInstantiated()))
.bind("decl"), .bind("decl"),
this); this);
} }
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines auto Diag =
diag(Location, "overloaded %0 returns a non-constant object instead of a " diag(Location, "overloaded %0 returns a non-constant object instead of a "
"constant object type") "constant object type")
<< FuncDecl; << FuncDecl;
if (!Location.isMacroID() && !ReturnType->getAs<TypedefType>()) if (!Location.isMacroID() && !ReturnType->getAs<TypedefType>())
Diag << FixItHint::CreateInsertion(Location, "const "); Diag << FixItHint::CreateInsertion(Location, "const ");
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

//===--- ProperlySeededRandomGeneratorCheck.cpp - clang-tidy---------------===// //===--- ProperlySeededRandomGeneratorCheck.cpp - clang-tidy---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ProperlySeededRandomGeneratorCheck.h" #include "ProperlySeededRandomGeneratorCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
ProperlySeededRandomGeneratorCheck::ProperlySeededRandomGeneratorCheck( ProperlySeededRandomGeneratorCheck::ProperlySeededRandomGeneratorCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
RawDisallowedSeedTypes( RawDisallowedSeedTypes(
Options.get("DisallowedSeedTypes", "time_t,std::time_t")) { Options.get("DisallowedSeedTypes", "time_t,std::time_t")) {
StringRef(RawDisallowedSeedTypes).split(DisallowedSeedTypes, ','); StringRef(RawDisallowedSeedTypes).split(DisallowedSeedTypes, ',');
} }
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Linesvoid ProperlySeededRandomGeneratorCheck::checkSeed(
if (llvm::is_contained(DisallowedSeedTypes, SeedType)) { if (llvm::is_contained(DisallowedSeedTypes, SeedType)) {
diag(Func->getExprLoc(), diag(Func->getExprLoc(),
"random number generator seeded with a disallowed source of seed " "random number generator seeded with a disallowed source of seed "
"value will generate a predictable sequence of values"); "value will generate a predictable sequence of values");
return; return;
} }
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
namespace { namespace {
const char DiagWording[] = const char DiagWording[] =
"do not call %0; consider using exception handling instead"; "do not call %0; consider using exception handling instead";
class SetJmpMacroCallbacks : public PPCallbacks { class SetJmpMacroCallbacks : public PPCallbacks {
SetLongJmpCheck &Check; SetLongJmpCheck &Check;
Show All 30 Lines Finder->addMatcher(
this); this);
} }
void SetLongJmpCheck::check(const MatchFinder::MatchResult &Result) { void SetLongJmpCheck::check(const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr"); const auto *E = Result.Nodes.getNodeAs<CallExpr>("expr");
diag(E->getExprLoc(), DiagWording) << cast<NamedDecl>(E->getCalleeDecl()); diag(E->getExprLoc(), DiagWording) << cast<NamedDecl>(E->getCalleeDecl());
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

//===--- StaticObjectExceptionCheck.cpp - clang-tidy-----------------------===// //===--- StaticObjectExceptionCheck.cpp - clang-tidy-----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StaticObjectExceptionCheck.h" #include "StaticObjectExceptionCheck.h"
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void StaticObjectExceptionCheck::registerMatchers(MatchFinder *Finder) { void StaticObjectExceptionCheck::registerMatchers(MatchFinder *Finder) {
// Match any static or thread_local variable declaration that has an // Match any static or thread_local variable declaration that has an
// initializer that can throw. // initializer that can throw.
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
TK_AsIs, TK_AsIs,
varDecl( varDecl(
Show All 23 Linesvoid StaticObjectExceptionCheck::check(const MatchFinder::MatchResult &Result) {
if (FuncLocation.isValid()) { if (FuncLocation.isValid()) {
diag(FuncLocation, diag(FuncLocation,
"possibly throwing %select{constructor|function}0 declared here", "possibly throwing %select{constructor|function}0 declared here",
DiagnosticIDs::Note) DiagnosticIDs::Note)
<< (isa<CXXConstructorDecl>(Func) ? 0 : 1); << (isa<CXXConstructorDecl>(Func) ? 0 : 1);
} }
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/FormatString.h" #include "clang/AST/FormatString.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/StringSwitch.h"
#include <cassert> #include <cassert>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void StrToNumCheck::registerMatchers(MatchFinder *Finder) { void StrToNumCheck::registerMatchers(MatchFinder *Finder) {
// Match any function call to the C standard library string conversion // Match any function call to the C standard library string conversion
// functions that do no error checking. // functions that do no error checking.
Finder->addMatcher( Finder->addMatcher(
callExpr( callExpr(
callee(functionDecl(anyOf( callee(functionDecl(anyOf(
functionDecl(hasAnyName("::atoi", "::atof", "::atol", "::atoll")) functionDecl(hasAnyName("::atoi", "::atof", "::atol", "::atoll"))
▲ Show 20 Lines • Show All 195 Lines • ▼ Show 20 Linesvoid StrToNumCheck::check(const MatchFinder::MatchResult &Result) {
diag(Call->getExprLoc(), diag(Call->getExprLoc(),
"%0 used to convert a string to %1, but function will not report " "%0 used to convert a string to %1, but function will not report "
"conversion errors; consider using '%2' instead") "conversion errors; consider using '%2' instead")
<< FuncDecl << classifyConversionType(Conversion) << FuncDecl << classifyConversionType(Conversion)
<< classifyReplacement(Conversion); << classifyReplacement(Conversion);
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

//===--- ThrownExceptionTypeCheck.cpp - clang-tidy-------------------------===// //===--- ThrownExceptionTypeCheck.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ThrownExceptionTypeCheck.h" #include "ThrownExceptionTypeCheck.h"
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) { void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse( traverse(
TK_AsIs, TK_AsIs,
cxxThrowExpr(has(ignoringParenImpCasts( cxxThrowExpr(has(ignoringParenImpCasts(
cxxConstructExpr(hasDeclaration(cxxConstructorDecl( cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
isCopyConstructor(), unless(isNoThrow())))) isCopyConstructor(), unless(isNoThrow()))))
.bind("expr"))))), .bind("expr"))))),
this); this);
} }
void ThrownExceptionTypeCheck::check(const MatchFinder::MatchResult &Result) { void ThrownExceptionTypeCheck::check(const MatchFinder::MatchResult &Result) {
const auto *E = Result.Nodes.getNodeAs<Expr>("expr"); const auto *E = Result.Nodes.getNodeAs<Expr>("expr");
diag(E->getExprLoc(), diag(E->getExprLoc(),
"thrown exception type is not nothrow copy constructible"); "thrown exception type is not nothrow copy constructible");
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

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

//===-- VariadicFunctionDefCheck.cpp - clang-tidy -------------------------===// //===-- VariadicFunctionDefCheck.cpp - clang-tidy -------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "VariadicFunctionDefCheck.h" #include "VariadicFunctionDefCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cert {
namespace tidy {
namespace cert {
void VariadicFunctionDefCheck::registerMatchers(MatchFinder *Finder) { void VariadicFunctionDefCheck::registerMatchers(MatchFinder *Finder) {
// We only care about function *definitions* that are variadic, and do not // We only care about function *definitions* that are variadic, and do not
// have extern "C" language linkage. // have extern "C" language linkage.
Finder->addMatcher( Finder->addMatcher(
functionDecl(isDefinition(), isVariadic(), unless(isExternC())) functionDecl(isDefinition(), isVariadic(), unless(isExternC()))
.bind("func"), .bind("func"),
this); this);
} }
void VariadicFunctionDefCheck::check(const MatchFinder::MatchResult &Result) { void VariadicFunctionDefCheck::check(const MatchFinder::MatchResult &Result) {
const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("func"); const auto *FD = Result.Nodes.getNodeAs<FunctionDecl>("func");
diag(FD->getLocation(), diag(FD->getLocation(),
"do not define a C-style variadic function; consider using a function " "do not define a C-style variadic function; consider using a function "
"parameter pack or currying instead"); "parameter pack or currying instead");
} }
} // namespace cert } // namespace clang::tidy::cert
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/concurrency/ConcurrencyTidyModule.cpp

//===--- ConcurrencyTidyModule.cpp - clang-tidy ---------------------------===// //===--- ConcurrencyTidyModule.cpp - clang-tidy ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "MtUnsafeCheck.h" #include "MtUnsafeCheck.h"
#include "ThreadCanceltypeAsynchronousCheck.h" #include "ThreadCanceltypeAsynchronousCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace concurrency { namespace concurrency {
class ConcurrencyModule : public ClangTidyModule { class ConcurrencyModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<concurrency::MtUnsafeCheck>( CheckFactories.registerCheck<concurrency::MtUnsafeCheck>(
"concurrency-mt-unsafe"); "concurrency-mt-unsafe");
CheckFactories.registerCheck<ThreadCanceltypeAsynchronousCheck>( CheckFactories.registerCheck<ThreadCanceltypeAsynchronousCheck>(
"concurrency-thread-canceltype-asynchronous"); "concurrency-thread-canceltype-asynchronous");
} }
}; };
} // namespace concurrency } // namespace concurrency
// Register the ConcurrencyTidyModule using this statically initialized variable. // Register the ConcurrencyTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<concurrency::ConcurrencyModule> static ClangTidyModuleRegistry::Add<concurrency::ConcurrencyModule>
X("concurrency-module", "Adds concurrency checks."); X("concurrency-module", "Adds concurrency checks.");
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the ConcurrencyModule. // and thus register the ConcurrencyModule.
volatile int ConcurrencyModuleAnchorSource = 0; volatile int ConcurrencyModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/concurrency/MtUnsafeCheck.cpp

Show First 20 Lines • Show All 252 Lines • ▼ Show 20 Linesstatic const clang::StringRef PosixFunctions[] = {
"::strtok", "::strtok",
"::system", "::system",
"::ttyname", "::ttyname",
"::unsetenv", "::unsetenv",
"::wcstombs", "::wcstombs",
"::wctomb", "::wctomb",
}; };
namespace clang { namespace clang::tidy {
namespace tidy {
template <> struct OptionEnumMapping<concurrency::MtUnsafeCheck::FunctionSet> { template <> struct OptionEnumMapping<concurrency::MtUnsafeCheck::FunctionSet> {
static llvm::ArrayRef< static llvm::ArrayRef<
std::pair<concurrency::MtUnsafeCheck::FunctionSet, StringRef>> std::pair<concurrency::MtUnsafeCheck::FunctionSet, StringRef>>
getEnumMapping() { getEnumMapping() {
static constexpr std::pair<concurrency::MtUnsafeCheck::FunctionSet, static constexpr std::pair<concurrency::MtUnsafeCheck::FunctionSet,
StringRef> StringRef>
Mapping[] = {{concurrency::MtUnsafeCheck::FunctionSet::Posix, "posix"}, Mapping[] = {{concurrency::MtUnsafeCheck::FunctionSet::Posix, "posix"},
Show All 36 Lines
void MtUnsafeCheck::check(const MatchFinder::MatchResult &Result) { void MtUnsafeCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Call = Result.Nodes.getNodeAs<CallExpr>("mt-unsafe"); const auto *Call = Result.Nodes.getNodeAs<CallExpr>("mt-unsafe");
assert(Call && "Unhandled binding in the Matcher"); assert(Call && "Unhandled binding in the Matcher");
diag(Call->getBeginLoc(), "function is not thread safe"); diag(Call->getBeginLoc(), "function is not thread safe");
} }
} // namespace concurrency } // namespace concurrency
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/concurrency/ThreadCanceltypeAsynchronousCheck.cpp

//===--- ThreadCanceltypeAsynchronousCheck.cpp - clang-tidy ---------------===// //===--- ThreadCanceltypeAsynchronousCheck.cpp - clang-tidy ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ThreadCanceltypeAsynchronousCheck.h" #include "ThreadCanceltypeAsynchronousCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::concurrency {
namespace tidy {
namespace concurrency {
void ThreadCanceltypeAsynchronousCheck::registerMatchers(MatchFinder *Finder) { void ThreadCanceltypeAsynchronousCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
callExpr( callExpr(
allOf(callee(functionDecl(hasName("::pthread_setcanceltype"))), allOf(callee(functionDecl(hasName("::pthread_setcanceltype"))),
argumentCountIs(2)), argumentCountIs(2)),
hasArgument(0, isExpandedFromMacro("PTHREAD_CANCEL_ASYNCHRONOUS"))) hasArgument(0, isExpandedFromMacro("PTHREAD_CANCEL_ASYNCHRONOUS")))
.bind("setcanceltype"), .bind("setcanceltype"),
this); this);
} }
void ThreadCanceltypeAsynchronousCheck::check( void ThreadCanceltypeAsynchronousCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("setcanceltype"); const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("setcanceltype");
diag(MatchedExpr->getBeginLoc(), "the cancel type for a pthread should not " diag(MatchedExpr->getBeginLoc(), "the cancel type for a pthread should not "
"be 'PTHREAD_CANCEL_ASYNCHRONOUS'"); "be 'PTHREAD_CANCEL_ASYNCHRONOUS'");
} }
} // namespace concurrency } // namespace clang::tidy::concurrency
} // namespace tidy
} // namespace clang

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

//===--- AvoidConstOrRefDataMembersCheck.cpp - clang-tidy -----------------===// //===--- AvoidConstOrRefDataMembersCheck.cpp - clang-tidy -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidConstOrRefDataMembersCheck.h" #include "AvoidConstOrRefDataMembersCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
namespace { namespace {
AST_MATCHER(FieldDecl, isMemberOfLambda) { AST_MATCHER(FieldDecl, isMemberOfLambda) {
return Node.getParent()->isLambda(); return Node.getParent()->isLambda();
} }
} // namespace } // namespace
Show All 13 Linesvoid AvoidConstOrRefDataMembersCheck::check(
if (const auto *MatchedDecl = Result.Nodes.getNodeAs<FieldDecl>("ref")) if (const auto *MatchedDecl = Result.Nodes.getNodeAs<FieldDecl>("ref"))
diag(MatchedDecl->getLocation(), "member %0 of type %1 is a reference") diag(MatchedDecl->getLocation(), "member %0 of type %1 is a reference")
<< MatchedDecl << MatchedDecl->getType(); << MatchedDecl << MatchedDecl->getType();
if (const auto *MatchedDecl = Result.Nodes.getNodeAs<FieldDecl>("const")) if (const auto *MatchedDecl = Result.Nodes.getNodeAs<FieldDecl>("const"))
diag(MatchedDecl->getLocation(), "member %0 of type %1 is const qualified") diag(MatchedDecl->getLocation(), "member %0 of type %1 is const qualified")
<< MatchedDecl << MatchedDecl->getType(); << MatchedDecl << MatchedDecl->getType();
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- AvoidDoWhileCheck.cpp - clang-tidy -------------------------------===// //===--- AvoidDoWhileCheck.cpp - clang-tidy -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidDoWhileCheck.h" #include "AvoidDoWhileCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
AvoidDoWhileCheck::AvoidDoWhileCheck(StringRef Name, ClangTidyContext *Context) AvoidDoWhileCheck::AvoidDoWhileCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", false)) {} IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", false)) {}
void AvoidDoWhileCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void AvoidDoWhileCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IgnoreMacros", IgnoreMacros); Options.store(Opts, "IgnoreMacros", IgnoreMacros);
} }
void AvoidDoWhileCheck::registerMatchers(MatchFinder *Finder) { void AvoidDoWhileCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(doStmt().bind("x"), this); Finder->addMatcher(doStmt().bind("x"), this);
} }
void AvoidDoWhileCheck::check(const MatchFinder::MatchResult &Result) { void AvoidDoWhileCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *MatchedDecl = Result.Nodes.getNodeAs<DoStmt>("x")) { if (const auto *MatchedDecl = Result.Nodes.getNodeAs<DoStmt>("x")) {
if (IgnoreMacros && MatchedDecl->getBeginLoc().isMacroID()) if (IgnoreMacros && MatchedDecl->getBeginLoc().isMacroID())
return; return;
diag(MatchedDecl->getBeginLoc(), "avoid do-while loops"); diag(MatchedDecl->getBeginLoc(), "avoid do-while loops");
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- AvoidGotoCheck.cpp - clang-tidy-----------------------------------===// //===--- AvoidGotoCheck.cpp - clang-tidy-----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidGotoCheck.h" #include "AvoidGotoCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
namespace { namespace {
AST_MATCHER(GotoStmt, isForwardJumping) { AST_MATCHER(GotoStmt, isForwardJumping) {
return Node.getBeginLoc() < Node.getLabel()->getBeginLoc(); return Node.getBeginLoc() < Node.getLabel()->getBeginLoc();
} }
} // namespace } // namespace
void AvoidGotoCheck::registerMatchers(MatchFinder *Finder) { void AvoidGotoCheck::registerMatchers(MatchFinder *Finder) {
Show All 15 Lines
void AvoidGotoCheck::check(const MatchFinder::MatchResult &Result) { void AvoidGotoCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Goto = Result.Nodes.getNodeAs<GotoStmt>("goto"); const auto *Goto = Result.Nodes.getNodeAs<GotoStmt>("goto");
diag(Goto->getGotoLoc(), "avoid using 'goto' for flow control") diag(Goto->getGotoLoc(), "avoid using 'goto' for flow control")
<< Goto->getSourceRange(); << Goto->getSourceRange();
diag(Goto->getLabel()->getBeginLoc(), "label defined here", diag(Goto->getLabel()->getBeginLoc(), "label defined here",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- AvoidNonConstGlobalVariablesCheck.cpp - clang-tidy ---------------===// //===--- AvoidNonConstGlobalVariablesCheck.cpp - clang-tidy ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidNonConstGlobalVariablesCheck.h" #include "AvoidNonConstGlobalVariablesCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
namespace { namespace {
AST_MATCHER(VarDecl, isLocalVarDecl) { return Node.isLocalVarDecl(); } AST_MATCHER(VarDecl, isLocalVarDecl) { return Node.isLocalVarDecl(); }
} // namespace } // namespace
void AvoidNonConstGlobalVariablesCheck::registerMatchers(MatchFinder *Finder) { void AvoidNonConstGlobalVariablesCheck::registerMatchers(MatchFinder *Finder) {
auto GlobalVariable = varDecl( auto GlobalVariable = varDecl(
hasGlobalStorage(), hasGlobalStorage(),
Show All 34 Lines if (const auto *VD =
diag(VD->getLocation(), diag(VD->getLocation(),
"variable %0 provides global access to a non-const object; consider " "variable %0 provides global access to a non-const object; consider "
"making the %select{referenced|pointed-to}1 data 'const'") "making the %select{referenced|pointed-to}1 data 'const'")
<< VD << VD
<< VD->getType()->isPointerType(); // FIXME: Add fix-it hint to Variable << VD->getType()->isPointerType(); // FIXME: Add fix-it hint to Variable
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- AvoidReferenceCoroutineParametersCheck.cpp - clang-tidy ----------===// //===--- AvoidReferenceCoroutineParametersCheck.cpp - clang-tidy ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidReferenceCoroutineParametersCheck.h" #include "AvoidReferenceCoroutineParametersCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void AvoidReferenceCoroutineParametersCheck::registerMatchers( void AvoidReferenceCoroutineParametersCheck::registerMatchers(
MatchFinder *Finder) { MatchFinder *Finder) {
auto IsCoroMatcher = auto IsCoroMatcher =
hasDescendant(expr(anyOf(coyieldExpr(), coreturnStmt(), coawaitExpr()))); hasDescendant(expr(anyOf(coyieldExpr(), coreturnStmt(), coawaitExpr())));
Finder->addMatcher(parmVarDecl(hasType(type(referenceType())), Finder->addMatcher(parmVarDecl(hasType(type(referenceType())),
hasAncestor(functionDecl(IsCoroMatcher))) hasAncestor(functionDecl(IsCoroMatcher)))
.bind("param"), .bind("param"),
this); this);
} }
void AvoidReferenceCoroutineParametersCheck::check( void AvoidReferenceCoroutineParametersCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
if (const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param")) { if (const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param")) {
diag(Param->getBeginLoc(), "coroutine parameters should not be references"); diag(Param->getBeginLoc(), "coroutine parameters should not be references");
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 34 Lines
#include "ProTypeReinterpretCastCheck.h" #include "ProTypeReinterpretCastCheck.h"
#include "ProTypeStaticCastDowncastCheck.h" #include "ProTypeStaticCastDowncastCheck.h"
#include "ProTypeUnionAccessCheck.h" #include "ProTypeUnionAccessCheck.h"
#include "ProTypeVarargCheck.h" #include "ProTypeVarargCheck.h"
#include "SlicingCheck.h" #include "SlicingCheck.h"
#include "SpecialMemberFunctionsCheck.h" #include "SpecialMemberFunctionsCheck.h"
#include "VirtualClassDestructorCheck.h" #include "VirtualClassDestructorCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// A module containing checks of the C++ Core Guidelines /// A module containing checks of the C++ Core Guidelines
class CppCoreGuidelinesModule : public ClangTidyModule { class CppCoreGuidelinesModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<modernize::AvoidCArraysCheck>( CheckFactories.registerCheck<modernize::AvoidCArraysCheck>(
"cppcoreguidelines-avoid-c-arrays"); "cppcoreguidelines-avoid-c-arrays");
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Linesstatic ClangTidyModuleRegistry::Add<CppCoreGuidelinesModule>
X("cppcoreguidelines-module", "Adds checks for the C++ Core Guidelines."); X("cppcoreguidelines-module", "Adds checks for the C++ Core Guidelines.");
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the CppCoreGuidelinesModule. // and thus register the CppCoreGuidelinesModule.
volatile int CppCoreGuidelinesModuleAnchorSource = 0; volatile int CppCoreGuidelinesModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
namespace { namespace {
AST_MATCHER(VarDecl, isLocalVarDecl) { return Node.isLocalVarDecl(); } AST_MATCHER(VarDecl, isLocalVarDecl) { return Node.isLocalVarDecl(); }
} // namespace } // namespace
InitVariablesCheck::InitVariablesCheck(StringRef Name, InitVariablesCheck::InitVariablesCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines if (*InitializationString != nullptr)
MatchedDecl->getName().size()), MatchedDecl->getName().size()),
*InitializationString); *InitializationString);
if (AddMathInclude) { if (AddMathInclude) {
Diagnostic << IncludeInserter.createIncludeInsertion( Diagnostic << IncludeInserter.createIncludeInsertion(
Source.getFileID(MatchedDecl->getBeginLoc()), MathHeader); Source.getFileID(MatchedDecl->getBeginLoc()), MathHeader);
} }
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- InterfacesGlobalInitCheck.cpp - clang-tidy------------------------===// //===--- InterfacesGlobalInitCheck.cpp - clang-tidy------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "InterfacesGlobalInitCheck.h" #include "InterfacesGlobalInitCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void InterfacesGlobalInitCheck::registerMatchers(MatchFinder *Finder) { void InterfacesGlobalInitCheck::registerMatchers(MatchFinder *Finder) {
const auto GlobalVarDecl = const auto GlobalVarDecl =
varDecl(hasGlobalStorage(), varDecl(hasGlobalStorage(),
hasDeclContext(anyOf(translationUnitDecl(), // Global scope. hasDeclContext(anyOf(translationUnitDecl(), // Global scope.
namespaceDecl(), // Namespace scope. namespaceDecl(), // Namespace scope.
recordDecl())), // Class scope. recordDecl())), // Class scope.
unless(isConstexpr())); unless(isConstexpr()));
Show All 23 Lines if (ReferenceeDef != nullptr &&
return; return;
} }
diag(Var->getLocation(), diag(Var->getLocation(),
"initializing non-local variable with non-const expression depending on " "initializing non-local variable with non-const expression depending on "
"uninitialized non-local variable %0") "uninitialized non-local variable %0")
<< Referencee; << Referencee;
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Regex.h" #include "llvm/Support/Regex.h"
#include <algorithm> #include <algorithm>
#include <cctype> #include <cctype>
#include <functional> #include <functional>
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
static bool isCapsOnly(StringRef Name) { static bool isCapsOnly(StringRef Name) {
return llvm::all_of(Name, [](const char C) { return llvm::all_of(Name, [](const char C) {
return std::isupper(C) || std::isdigit(C) || C == '_'; return std::isupper(C) || std::isdigit(C) || C == '_';
}); });
} }
namespace { namespace {
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
void MacroUsageCheck::warnNaming(const MacroDirective *MD, void MacroUsageCheck::warnNaming(const MacroDirective *MD,
StringRef MacroName) { StringRef MacroName) {
diag(MD->getLocation(), "macro definition does not define the macro name " diag(MD->getLocation(), "macro definition does not define the macro name "
"'%0' using all uppercase characters") "'%0' using all uppercase characters")
<< MacroName; << MacroName;
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 15 Lines
#include "llvm/ADT/APSInt.h" #include "llvm/ADT/APSInt.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include <cstdint> #include <cstdint>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
NarrowingConversionsCheck::NarrowingConversionsCheck(StringRef Name, NarrowingConversionsCheck::NarrowingConversionsCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
WarnOnIntegerNarrowingConversion( WarnOnIntegerNarrowingConversion(
Options.get("WarnOnIntegerNarrowingConversion", true)), Options.get("WarnOnIntegerNarrowingConversion", true)),
WarnOnIntegerToFloatingPointNarrowingConversion( WarnOnIntegerToFloatingPointNarrowingConversion(
Options.get("WarnOnIntegerToFloatingPointNarrowingConversion", true)), Options.get("WarnOnIntegerToFloatingPointNarrowingConversion", true)),
▲ Show 20 Lines • Show All 554 Lines • ▼ Show 20 Lines
void NarrowingConversionsCheck::check(const MatchFinder::MatchResult &Result) { void NarrowingConversionsCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("binary_op")) if (const auto *Op = Result.Nodes.getNodeAs<BinaryOperator>("binary_op"))
return handleBinaryOperator(*Result.Context, *Op); return handleBinaryOperator(*Result.Context, *Op);
if (const auto *Cast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast")) if (const auto *Cast = Result.Nodes.getNodeAs<ImplicitCastExpr>("cast"))
return handleImplicitCast(*Result.Context, *Cast); return handleImplicitCast(*Result.Context, *Cast);
llvm_unreachable("must be binary operator or cast expression"); llvm_unreachable("must be binary operator or cast expression");
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 12 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <algorithm> #include <algorithm>
#include <string> #include <string>
#include <vector> #include <vector>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::ast_matchers::internal; using namespace clang::ast_matchers::internal;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void NoMallocCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void NoMallocCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "Allocations", AllocList); Options.store(Opts, "Allocations", AllocList);
Options.store(Opts, "Reallocations", ReallocList); Options.store(Opts, "Reallocations", ReallocList);
Options.store(Opts, "Deallocations", DeallocList); Options.store(Opts, "Deallocations", DeallocList);
} }
void NoMallocCheck::registerMatchers(MatchFinder *Finder) { void NoMallocCheck::registerMatchers(MatchFinder *Finder) {
Show All 30 Lines else if ((Call = Result.Nodes.getNodeAs<CallExpr>("free")))
Recommendation = "use RAII"; Recommendation = "use RAII";
assert(Call && "Unhandled binding in the Matcher"); assert(Call && "Unhandled binding in the Matcher");
diag(Call->getBeginLoc(), "do not manage memory manually; %0") diag(Call->getBeginLoc(), "do not manage memory manually; %0")
<< Recommendation << SourceRange(Call->getBeginLoc(), Call->getEndLoc()); << Recommendation << SourceRange(Call->getBeginLoc(), Call->getEndLoc());
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 11 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <string> #include <string>
#include <vector> #include <vector>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::ast_matchers::internal; using namespace clang::ast_matchers::internal;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void OwningMemoryCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void OwningMemoryCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "LegacyResourceProducers", LegacyResourceProducers); Options.store(Opts, "LegacyResourceProducers", LegacyResourceProducers);
Options.store(Opts, "LegacyResourceConsumers", LegacyResourceConsumers); Options.store(Opts, "LegacyResourceConsumers", LegacyResourceConsumers);
} }
/// Match common cases, where the owner semantic is relevant, like function /// Match common cases, where the owner semantic is relevant, like function
/// calls, delete expressions and others. /// calls, delete expressions and others.
▲ Show 20 Lines • Show All 334 Lines • ▼ Show 20 Lines diag(DeclaredOwnerMember->getBeginLoc(),
"member variable of type 'gsl::owner<>' requires the class %0 to " "member variable of type 'gsl::owner<>' requires the class %0 to "
"implement a destructor to release the owned resource") "implement a destructor to release the owned resource")
<< BadClass; << BadClass;
return true; return true;
} }
return false; return false;
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- PreferMemberInitializerCheck.cpp - clang-tidy -------------------===// //===--- PreferMemberInitializerCheck.cpp - clang-tidy -------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PreferMemberInitializerCheck.h" #include "PreferMemberInitializerCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
static bool isControlStatement(const Stmt *S) { static bool isControlStatement(const Stmt *S) {
return isa<IfStmt, SwitchStmt, ForStmt, WhileStmt, DoStmt, ReturnStmt, return isa<IfStmt, SwitchStmt, ForStmt, WhileStmt, DoStmt, ReturnStmt,
GotoStmt, CXXTryStmt, CXXThrowExpr>(S); GotoStmt, CXXTryStmt, CXXThrowExpr>(S);
} }
static bool isNoReturnCallStatement(const Stmt *S) { static bool isNoReturnCallStatement(const Stmt *S) {
const auto *Call = dyn_cast<CallExpr>(S); const auto *Call = dyn_cast<CallExpr>(S);
▲ Show 20 Lines • Show All 283 Lines • ▼ Show 20 Lines if (Field) {
} }
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd)); CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd));
} }
} }
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- ProBoundsArrayToPointerDecayCheck.cpp - clang-tidy----------------===// //===--- ProBoundsArrayToPointerDecayCheck.cpp - clang-tidy----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ProBoundsArrayToPointerDecayCheck.h" #include "ProBoundsArrayToPointerDecayCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/ParentMapContext.h" #include "clang/AST/ParentMapContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
namespace { namespace {
AST_MATCHER_P(CXXForRangeStmt, hasRangeBeginEndStmt, AST_MATCHER_P(CXXForRangeStmt, hasRangeBeginEndStmt,
ast_matchers::internal::Matcher<DeclStmt>, InnerMatcher) { ast_matchers::internal::Matcher<DeclStmt>, InnerMatcher) {
for (const DeclStmt *Stmt : {Node.getBeginStmt(), Node.getEndStmt()}) for (const DeclStmt *Stmt : {Node.getBeginStmt(), Node.getEndStmt()})
if (Stmt != nullptr && InnerMatcher.matches(*Stmt, Finder, Builder)) if (Stmt != nullptr && InnerMatcher.matches(*Stmt, Finder, Builder))
return true; return true;
return false; return false;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Linesvoid ProBoundsArrayToPointerDecayCheck::check(
if (MatchedCast->getCastKind() != CK_ArrayToPointerDecay) if (MatchedCast->getCastKind() != CK_ArrayToPointerDecay)
return; return;
diag(MatchedCast->getExprLoc(), "do not implicitly decay an array into a " diag(MatchedCast->getExprLoc(), "do not implicitly decay an array into a "
"pointer; consider using gsl::array_view or " "pointer; consider using gsl::array_view or "
"an explicit cast instead"); "an explicit cast instead");
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
ProBoundsConstantArrayIndexCheck::ProBoundsConstantArrayIndexCheck( ProBoundsConstantArrayIndexCheck::ProBoundsConstantArrayIndexCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")), : ClangTidyCheck(Name, Context), GslHeader(Options.get("GslHeader", "")),
Inserter(Options.getLocalOrGlobal("IncludeStyle", Inserter(Options.getLocalOrGlobal("IncludeStyle",
utils::IncludeSorter::IS_LLVM), utils::IncludeSorter::IS_LLVM),
areDiagsSelfContained()) {} areDiagsSelfContained()) {}
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Linesvoid ProBoundsConstantArrayIndexCheck::check(
if (Index->getZExtValue() >= ArraySize.getZExtValue()) { if (Index->getZExtValue() >= ArraySize.getZExtValue()) {
diag(Matched->getExprLoc(), diag(Matched->getExprLoc(),
"std::array<> index %0 is past the end of the array " "std::array<> index %0 is past the end of the array "
"(which contains %1 elements)") "(which contains %1 elements)")
<< toString(*Index, 10) << toString(ArraySize, 10, false); << toString(*Index, 10) << toString(ArraySize, 10, false);
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- ProBoundsPointerArithmeticCheck.cpp - clang-tidy------------------===// //===--- ProBoundsPointerArithmeticCheck.cpp - clang-tidy------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ProBoundsPointerArithmeticCheck.h" #include "ProBoundsPointerArithmeticCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void ProBoundsPointerArithmeticCheck::registerMatchers(MatchFinder *Finder) { void ProBoundsPointerArithmeticCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
const auto AllPointerTypes = const auto AllPointerTypes =
anyOf(hasType(pointerType()), anyOf(hasType(pointerType()),
hasType(autoType( hasType(autoType(
Show All 25 Lines
void ProBoundsPointerArithmeticCheck::check( void ProBoundsPointerArithmeticCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr"); const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr");
diag(MatchedExpr->getExprLoc(), "do not use pointer arithmetic"); diag(MatchedExpr->getExprLoc(), "do not use pointer arithmetic");
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- ProTypeConstCastCheck.cpp - clang-tidy----------------------------===// //===--- ProTypeConstCastCheck.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ProTypeConstCastCheck.h" #include "ProTypeConstCastCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void ProTypeConstCastCheck::registerMatchers(MatchFinder *Finder) { void ProTypeConstCastCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(cxxConstCastExpr().bind("cast"), this); Finder->addMatcher(cxxConstCastExpr().bind("cast"), this);
} }
void ProTypeConstCastCheck::check(const MatchFinder::MatchResult &Result) { void ProTypeConstCastCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedCast = Result.Nodes.getNodeAs<CXXConstCastExpr>("cast"); const auto *MatchedCast = Result.Nodes.getNodeAs<CXXConstCastExpr>("cast");
diag(MatchedCast->getOperatorLoc(), "do not use const_cast"); diag(MatchedCast->getOperatorLoc(), "do not use const_cast");
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- ProTypeCstyleCastCheck.cpp - clang-tidy---------------------------===// //===--- ProTypeCstyleCastCheck.cpp - clang-tidy---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ProTypeCstyleCastCheck.h" #include "ProTypeCstyleCastCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
static bool needsConstCast(QualType SourceType, QualType DestType) { static bool needsConstCast(QualType SourceType, QualType DestType) {
SourceType = SourceType.getNonReferenceType(); SourceType = SourceType.getNonReferenceType();
DestType = DestType.getNonReferenceType(); DestType = DestType.getNonReferenceType();
while (SourceType->isPointerType() && DestType->isPointerType()) { while (SourceType->isPointerType() && DestType->isPointerType()) {
SourceType = SourceType->getPointeeType(); SourceType = SourceType->getPointeeType();
DestType = DestType->getPointeeType(); DestType = DestType->getPointeeType();
if (SourceType.isConstQualified() && !DestType.isConstQualified()) if (SourceType.isConstQualified() && !DestType.isConstQualified())
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Linesvoid ProTypeCstyleCastCheck::check(const MatchFinder::MatchResult &Result) {
if (MatchedCast->getCastKind() == CK_NoOp && if (MatchedCast->getCastKind() == CK_NoOp &&
needsConstCast(SourceType, MatchedCast->getType())) { needsConstCast(SourceType, MatchedCast->getType())) {
diag(MatchedCast->getBeginLoc(), diag(MatchedCast->getBeginLoc(),
"do not use C-style cast to cast away constness"); "do not use C-style cast to cast away constness");
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 14 Lines
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::tidy::matchers; using namespace clang::tidy::matchers;
using llvm::SmallPtrSet; using llvm::SmallPtrSet;
using llvm::SmallPtrSetImpl; using llvm::SmallPtrSetImpl;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
namespace { namespace {
AST_MATCHER(CXXRecordDecl, hasDefaultConstructor) { AST_MATCHER(CXXRecordDecl, hasDefaultConstructor) {
return Node.hasDefaultConstructor(); return Node.hasDefaultConstructor();
} }
// Iterate over all the fields in a record type, both direct and indirect (e.g. // Iterate over all the fields in a record type, both direct and indirect (e.g.
▲ Show 20 Lines • Show All 540 Lines • ▼ Show 20 Linesvoid ProTypeMemberInitCheck::checkUninitializedTrivialType(
DiagnosticBuilder Diag = DiagnosticBuilder Diag =
diag(Var->getBeginLoc(), "uninitialized record type: %0") << Var; diag(Var->getBeginLoc(), "uninitialized record type: %0") << Var;
Diag << FixItHint::CreateInsertion( Diag << FixItHint::CreateInsertion(
getLocationForEndOfToken(Context, Var->getSourceRange().getEnd()), getLocationForEndOfToken(Context, Var->getSourceRange().getEnd()),
Context.getLangOpts().CPlusPlus11 ? "{}" : " = {}"); Context.getLangOpts().CPlusPlus11 ? "{}" : " = {}");
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- ProTypeReinterpretCastCheck.cpp - clang-tidy----------------------===// //===--- ProTypeReinterpretCastCheck.cpp - clang-tidy----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ProTypeReinterpretCastCheck.h" #include "ProTypeReinterpretCastCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void ProTypeReinterpretCastCheck::registerMatchers(MatchFinder *Finder) { void ProTypeReinterpretCastCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(cxxReinterpretCastExpr().bind("cast"), this); Finder->addMatcher(cxxReinterpretCastExpr().bind("cast"), this);
} }
void ProTypeReinterpretCastCheck::check( void ProTypeReinterpretCastCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *MatchedCast = const auto *MatchedCast =
Result.Nodes.getNodeAs<CXXReinterpretCastExpr>("cast"); Result.Nodes.getNodeAs<CXXReinterpretCastExpr>("cast");
diag(MatchedCast->getOperatorLoc(), "do not use reinterpret_cast"); diag(MatchedCast->getOperatorLoc(), "do not use reinterpret_cast");
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- ProTypeStaticCastDowncastCheck.cpp - clang-tidy-------------------===// //===--- ProTypeStaticCastDowncastCheck.cpp - clang-tidy-------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ProTypeStaticCastDowncastCheck.h" #include "ProTypeStaticCastDowncastCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void ProTypeStaticCastDowncastCheck::registerMatchers(MatchFinder *Finder) { void ProTypeStaticCastDowncastCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
cxxStaticCastExpr(unless(isInTemplateInstantiation())).bind("cast"), cxxStaticCastExpr(unless(isInTemplateInstantiation())).bind("cast"),
this); this);
} }
void ProTypeStaticCastDowncastCheck::check( void ProTypeStaticCastDowncastCheck::check(
Show All 15 Lines diag(MatchedCast->getOperatorLoc(),
"use dynamic_cast instead") "use dynamic_cast instead")
<< FixItHint::CreateReplacement(MatchedCast->getOperatorLoc(), << FixItHint::CreateReplacement(MatchedCast->getOperatorLoc(),
"dynamic_cast"); "dynamic_cast");
else else
diag(MatchedCast->getOperatorLoc(), diag(MatchedCast->getOperatorLoc(),
"do not use static_cast to downcast from a base to a derived class"); "do not use static_cast to downcast from a base to a derived class");
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- ProTypeUnionAccessCheck.cpp - clang-tidy--------------------------===// //===--- ProTypeUnionAccessCheck.cpp - clang-tidy--------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ProTypeUnionAccessCheck.h" #include "ProTypeUnionAccessCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void ProTypeUnionAccessCheck::registerMatchers(MatchFinder *Finder) { void ProTypeUnionAccessCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
memberExpr(hasObjectExpression(hasType(recordDecl(isUnion())))) memberExpr(hasObjectExpression(hasType(recordDecl(isUnion()))))
.bind("expr"), .bind("expr"),
this); this);
} }
void ProTypeUnionAccessCheck::check(const MatchFinder::MatchResult &Result) { void ProTypeUnionAccessCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Matched = Result.Nodes.getNodeAs<MemberExpr>("expr"); const auto *Matched = Result.Nodes.getNodeAs<MemberExpr>("expr");
diag(Matched->getMemberLoc(), diag(Matched->getMemberLoc(),
"do not access members of unions; use (boost::)variant instead"); "do not access members of unions; use (boost::)variant instead");
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 11 Lines
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetInfo.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "clang/Lex/Token.h" #include "clang/Lex/Token.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
const internal::VariadicDynCastAllOfMatcher<Stmt, VAArgExpr> VAArgExpr; const internal::VariadicDynCastAllOfMatcher<Stmt, VAArgExpr> VAArgExpr;
static constexpr StringRef AllowedVariadics[] = { static constexpr StringRef AllowedVariadics[] = {
// clang-format off // clang-format off
"__builtin_isgreater", "__builtin_isgreater",
"__builtin_isgreaterequal", "__builtin_isgreaterequal",
"__builtin_isless", "__builtin_isless",
▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines if (const auto *Matched = Result.Nodes.getNodeAs<VarDecl>("va_list")) {
auto SR = Matched->getSourceRange(); auto SR = Matched->getSourceRange();
if (SR.isInvalid()) if (SR.isInvalid())
return; // some implicitly generated builtins take va_list return; // some implicitly generated builtins take va_list
diag(SR.getBegin(), "do not declare variables of type va_list; " diag(SR.getBegin(), "do not declare variables of type va_list; "
"use variadic templates instead"); "use variadic templates instead");
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

//===--- SlicingCheck.cpp - clang-tidy-------------------------------------===// //===--- SlicingCheck.cpp - clang-tidy-------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SlicingCheck.h" #include "SlicingCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/RecordLayout.h" #include "clang/AST/RecordLayout.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
void SlicingCheck::registerMatchers(MatchFinder *Finder) { void SlicingCheck::registerMatchers(MatchFinder *Finder) {
// When we see: // When we see:
// class B : public A { ... }; // class B : public A { ... };
// A a; // A a;
// B b; // B b;
// a = b; // a = b;
// The assignment is OK if: // The assignment is OK if:
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines const CharUnits StateSize =
DerivedLayout.getDataSize() - BaseLayout.getDataSize(); DerivedLayout.getDataSize() - BaseLayout.getDataSize();
if (StateSize.isPositive()) { if (StateSize.isPositive()) {
diag(Call->getExprLoc(), "slicing object from type %0 to %1 discards " diag(Call->getExprLoc(), "slicing object from type %0 to %1 discards "
"%2 bytes of state") "%2 bytes of state")
<< DerivedDecl << BaseDecl << static_cast<int>(StateSize.getQuantity()); << DerivedDecl << BaseDecl << static_cast<int>(StateSize.getQuantity());
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 11 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/DenseMapInfo.h" #include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#define DEBUG_TYPE "clang-tidy" #define DEBUG_TYPE "clang-tidy"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
SpecialMemberFunctionsCheck::SpecialMemberFunctionsCheck( SpecialMemberFunctionsCheck::SpecialMemberFunctionsCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), AllowMissingMoveFunctions(Options.get( : ClangTidyCheck(Name, Context), AllowMissingMoveFunctions(Options.get(
"AllowMissingMoveFunctions", false)), "AllowMissingMoveFunctions", false)),
AllowSoleDefaultDtor(Options.get("AllowSoleDefaultDtor", false)), AllowSoleDefaultDtor(Options.get("AllowSoleDefaultDtor", false)),
AllowMissingMoveFunctionsWhenCopyIsDeleted( AllowMissingMoveFunctionsWhenCopyIsDeleted(
Options.get("AllowMissingMoveFunctionsWhenCopyIsDeleted", false)) {} Options.get("AllowMissingMoveFunctionsWhenCopyIsDeleted", false)) {}
▲ Show 20 Lines • Show All 163 Lines • ▼ Show 20 Lines if (!MissingMembers.empty()) {
llvm::transform(DefinedMembers, std::back_inserter(DefinedMemberKinds), llvm::transform(DefinedMembers, std::back_inserter(DefinedMemberKinds),
[](const auto &Data) { return Data.FunctionKind; }); [](const auto &Data) { return Data.FunctionKind; });
diag(ID.first, "class '%0' defines %1 but does not define %2") diag(ID.first, "class '%0' defines %1 but does not define %2")
<< ID.second << cppcoreguidelines::join(DefinedMemberKinds, " and ") << ID.second << cppcoreguidelines::join(DefinedMemberKinds, " and ")
<< cppcoreguidelines::join(MissingMembers, " or "); << cppcoreguidelines::join(MissingMembers, " or ");
} }
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include <optional> #include <optional>
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::cppcoreguidelines {
namespace tidy {
namespace cppcoreguidelines {
AST_MATCHER(CXXRecordDecl, hasPublicVirtualOrProtectedNonVirtualDestructor) { AST_MATCHER(CXXRecordDecl, hasPublicVirtualOrProtectedNonVirtualDestructor) {
// We need to call Node.getDestructor() instead of matching a // We need to call Node.getDestructor() instead of matching a
// CXXDestructorDecl. Otherwise, tests will fail for class templates, since // CXXDestructorDecl. Otherwise, tests will fail for class templates, since
// the primary template (not the specialization) always gets a non-virtual // the primary template (not the specialization) always gets a non-virtual
// CXXDestructorDecl in the AST. https://bugs.llvm.org/show_bug.cgi?id=51912 // CXXDestructorDecl in the AST. https://bugs.llvm.org/show_bug.cgi?id=51912
const CXXDestructorDecl *Destructor = Node.getDestructor(); const CXXDestructorDecl *Destructor = Node.getDestructor();
if (!Destructor) if (!Destructor)
▲ Show 20 Lines • Show All 183 Lines • ▼ Show 20 Lines diag(MatchedClassOrStruct->getLocation(),
"virtual}1") "virtual}1")
<< MatchedClassOrStruct << ProtectedAndVirtual; << MatchedClassOrStruct << ProtectedAndVirtual;
diag(MatchedClassOrStruct->getLocation(), diag(MatchedClassOrStruct->getLocation(),
"make it %select{public and virtual|protected and non-virtual}0", "make it %select{public and virtual|protected and non-virtual}0",
DiagnosticIDs::Note) DiagnosticIDs::Note)
<< ProtectedAndVirtual << Fix; << ProtectedAndVirtual << Fix;
} }
} // namespace cppcoreguidelines } // namespace clang::tidy::cppcoreguidelines
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/darwin/AvoidSpinlockCheck.cpp

//===--- AvoidSpinlockCheck.cpp - clang-tidy-------------------------------===// //===--- AvoidSpinlockCheck.cpp - clang-tidy-------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidSpinlockCheck.h" #include "AvoidSpinlockCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::darwin {
namespace tidy {
namespace darwin {
void AvoidSpinlockCheck::registerMatchers(MatchFinder *Finder) { void AvoidSpinlockCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
callExpr(callee((functionDecl(hasAnyName( callExpr(callee((functionDecl(hasAnyName(
"OSSpinlockLock", "OSSpinlockUnlock", "OSSpinlockTry"))))) "OSSpinlockLock", "OSSpinlockUnlock", "OSSpinlockTry")))))
.bind("spinlock"), .bind("spinlock"),
this); this);
} }
void AvoidSpinlockCheck::check(const MatchFinder::MatchResult &Result) { void AvoidSpinlockCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedExpr = Result.Nodes.getNodeAs<CallExpr>("spinlock"); const auto *MatchedExpr = Result.Nodes.getNodeAs<CallExpr>("spinlock");
diag(MatchedExpr->getBeginLoc(), diag(MatchedExpr->getBeginLoc(),
"use os_unfair_lock_lock() or dispatch queue APIs instead of the " "use os_unfair_lock_lock() or dispatch queue APIs instead of the "
"deprecated OSSpinLock"); "deprecated OSSpinLock");
} }
} // namespace darwin } // namespace clang::tidy::darwin
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/darwin/DarwinTidyModule.cpp

//===--- MiscTidyModule.cpp - clang-tidy ----------------------------------===// //===--- MiscTidyModule.cpp - clang-tidy ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "AvoidSpinlockCheck.h" #include "AvoidSpinlockCheck.h"
#include "DispatchOnceNonstaticCheck.h" #include "DispatchOnceNonstaticCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace darwin { namespace darwin {
class DarwinModule : public ClangTidyModule { class DarwinModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<AvoidSpinlockCheck>( CheckFactories.registerCheck<AvoidSpinlockCheck>(
"darwin-avoid-spinlock"); "darwin-avoid-spinlock");
CheckFactories.registerCheck<DispatchOnceNonstaticCheck>( CheckFactories.registerCheck<DispatchOnceNonstaticCheck>(
"darwin-dispatch-once-nonstatic"); "darwin-dispatch-once-nonstatic");
} }
}; };
} // namespace darwin } // namespace darwin
// Register the DarwinTidyModule using this statically initialized variable. // Register the DarwinTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<darwin::DarwinModule> static ClangTidyModuleRegistry::Add<darwin::DarwinModule>
X("darwin-module", "Adds Darwin-specific lint checks."); X("darwin-module", "Adds Darwin-specific lint checks.");
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the DarwinModule. // and thus register the DarwinModule.
volatile int DarwinModuleAnchorSource = 0; volatile int DarwinModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/darwin/DispatchOnceNonstaticCheck.cpp

Show All 10 Lines
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
#include "clang/AST/DeclObjC.h" #include "clang/AST/DeclObjC.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Basic/Diagnostic.h" #include "clang/Basic/Diagnostic.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::darwin {
namespace tidy {
namespace darwin {
void DispatchOnceNonstaticCheck::registerMatchers(MatchFinder *Finder) { void DispatchOnceNonstaticCheck::registerMatchers(MatchFinder *Finder) {
// Find variables without static or global storage. VarDecls do not include // Find variables without static or global storage. VarDecls do not include
// struct/class members, which are FieldDecls. // struct/class members, which are FieldDecls.
Finder->addMatcher( Finder->addMatcher(
varDecl(hasLocalStorage(), hasType(asString("dispatch_once_t"))) varDecl(hasLocalStorage(), hasType(asString("dispatch_once_t")))
.bind("non-static-var"), .bind("non-static-var"),
this); this);
Show All 22 Linesvoid DispatchOnceNonstaticCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *D = Result.Nodes.getNodeAs<ObjCIvarDecl>("ivar")) { if (const auto *D = Result.Nodes.getNodeAs<ObjCIvarDecl>("ivar")) {
diag(D->getTypeSpecStartLoc(), diag(D->getTypeSpecStartLoc(),
"dispatch_once_t variables must have static or global storage " "dispatch_once_t variables must have static or global storage "
"duration and cannot be Objective-C instance variables"); "duration and cannot be Objective-C instance variables");
} }
} }
} // namespace darwin } // namespace clang::tidy::darwin
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/fuchsia/DefaultArgumentsCallsCheck.cpp

//===--- DefaultArgumentsCallsCheck.cpp - clang-tidy-----------------------===// //===--- DefaultArgumentsCallsCheck.cpp - clang-tidy-----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DefaultArgumentsCallsCheck.h" #include "DefaultArgumentsCallsCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::fuchsia {
namespace tidy {
namespace fuchsia {
void DefaultArgumentsCallsCheck::registerMatchers(MatchFinder *Finder) { void DefaultArgumentsCallsCheck::registerMatchers(MatchFinder *Finder) {
// Calling a function which uses default arguments is disallowed. // Calling a function which uses default arguments is disallowed.
Finder->addMatcher(cxxDefaultArgExpr().bind("stmt"), this); Finder->addMatcher(cxxDefaultArgExpr().bind("stmt"), this);
} }
void DefaultArgumentsCallsCheck::check(const MatchFinder::MatchResult &Result) { void DefaultArgumentsCallsCheck::check(const MatchFinder::MatchResult &Result) {
const auto *S = Result.Nodes.getNodeAs<CXXDefaultArgExpr>("stmt"); const auto *S = Result.Nodes.getNodeAs<CXXDefaultArgExpr>("stmt");
if (!S) if (!S)
return; return;
diag(S->getUsedLocation(), diag(S->getUsedLocation(),
"calling a function that uses a default argument is disallowed"); "calling a function that uses a default argument is disallowed");
diag(S->getParam()->getBeginLoc(), "default parameter was declared here", diag(S->getParam()->getBeginLoc(), "default parameter was declared here",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} }
} // namespace fuchsia } // namespace clang::tidy::fuchsia
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/fuchsia/DefaultArgumentsDeclarationsCheck.cpp

//===--- DefaultArgumentsDeclarationsCheck.cpp - clang-tidy ---------------===// //===--- DefaultArgumentsDeclarationsCheck.cpp - clang-tidy ---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DefaultArgumentsDeclarationsCheck.h" #include "DefaultArgumentsDeclarationsCheck.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::fuchsia {
namespace tidy {
namespace fuchsia {
void DefaultArgumentsDeclarationsCheck::registerMatchers(MatchFinder *Finder) { void DefaultArgumentsDeclarationsCheck::registerMatchers(MatchFinder *Finder) {
// Declaring default parameters is disallowed. // Declaring default parameters is disallowed.
Finder->addMatcher(parmVarDecl(hasDefaultArgument()).bind("decl"), this); Finder->addMatcher(parmVarDecl(hasDefaultArgument()).bind("decl"), this);
} }
void DefaultArgumentsDeclarationsCheck::check( void DefaultArgumentsDeclarationsCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
Show All 20 Lines SourceRange RemovalRange(
Result.Context->getLangOpts()), Result.Context->getLangOpts()),
DefaultArgRange.getEnd()); DefaultArgRange.getEnd());
diag(D->getBeginLoc(), diag(D->getBeginLoc(),
"declaring a parameter with a default argument is disallowed") "declaring a parameter with a default argument is disallowed")
<< D << FixItHint::CreateRemoval(RemovalRange); << D << FixItHint::CreateRemoval(RemovalRange);
} }
} // namespace fuchsia } // namespace clang::tidy::fuchsia
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/fuchsia/FuchsiaTidyModule.cpp

Show All 14 Lines
#include "MultipleInheritanceCheck.h" #include "MultipleInheritanceCheck.h"
#include "OverloadedOperatorCheck.h" #include "OverloadedOperatorCheck.h"
#include "StaticallyConstructedObjectsCheck.h" #include "StaticallyConstructedObjectsCheck.h"
#include "TrailingReturnCheck.h" #include "TrailingReturnCheck.h"
#include "VirtualInheritanceCheck.h" #include "VirtualInheritanceCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
namespace fuchsia { namespace fuchsia {
/// This module is for Fuchsia-specific checks. /// This module is for Fuchsia-specific checks.
class FuchsiaModule : public ClangTidyModule { class FuchsiaModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<DefaultArgumentsCallsCheck>( CheckFactories.registerCheck<DefaultArgumentsCallsCheck>(
"fuchsia-default-arguments-calls"); "fuchsia-default-arguments-calls");
Show All 17 Lines
static ClangTidyModuleRegistry::Add<FuchsiaModule> static ClangTidyModuleRegistry::Add<FuchsiaModule>
X("fuchsia-module", "Adds Fuchsia platform checks."); X("fuchsia-module", "Adds Fuchsia platform checks.");
} // namespace fuchsia } // namespace fuchsia
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the FuchsiaModule. // and thus register the FuchsiaModule.
volatile int FuchsiaModuleAnchorSource = 0; volatile int FuchsiaModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/fuchsia/MultipleInheritanceCheck.cpp

//===--- MultipleInheritanceCheck.cpp - clang-tidy-------------------------===// //===--- MultipleInheritanceCheck.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MultipleInheritanceCheck.h" #include "MultipleInheritanceCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang; using namespace clang;
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::fuchsia {
namespace tidy {
namespace fuchsia {
namespace { namespace {
AST_MATCHER(CXXRecordDecl, hasBases) { AST_MATCHER(CXXRecordDecl, hasBases) {
if (Node.hasDefinition()) if (Node.hasDefinition())
return Node.getNumBases() > 0; return Node.getNumBases() > 0;
return false; return false;
} }
} // namespace } // namespace
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines if (const auto *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl")) {
if (NumConcrete > 1) { if (NumConcrete > 1) {
diag(D->getBeginLoc(), "inheriting multiple classes that aren't " diag(D->getBeginLoc(), "inheriting multiple classes that aren't "
"pure virtual is discouraged"); "pure virtual is discouraged");
} }
} }
} }
} // namespace fuchsia } // namespace clang::tidy::fuchsia
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/fuchsia/OverloadedOperatorCheck.cpp

//===--- OverloadedOperatorCheck.cpp - clang-tidy--------------------------===// //===--- OverloadedOperatorCheck.cpp - clang-tidy--------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "OverloadedOperatorCheck.h" #include "OverloadedOperatorCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::fuchsia {
namespace tidy {
namespace fuchsia {
namespace { namespace {
AST_MATCHER(FunctionDecl, isFuchsiaOverloadedOperator) { AST_MATCHER(FunctionDecl, isFuchsiaOverloadedOperator) {
if (const auto *CXXMethodNode = dyn_cast<CXXMethodDecl>(&Node)) { if (const auto *CXXMethodNode = dyn_cast<CXXMethodDecl>(&Node)) {
if (CXXMethodNode->isCopyAssignmentOperator() || if (CXXMethodNode->isCopyAssignmentOperator() ||
CXXMethodNode->isMoveAssignmentOperator()) CXXMethodNode->isMoveAssignmentOperator())
return false; return false;
if (CXXMethodNode->getParent()->isLambda()) if (CXXMethodNode->getParent()->isLambda())
Show All 12 Linesvoid OverloadedOperatorCheck::check(const MatchFinder::MatchResult &Result) {
const auto *D = Result.Nodes.getNodeAs<FunctionDecl>("decl"); const auto *D = Result.Nodes.getNodeAs<FunctionDecl>("decl");
assert(D && "No FunctionDecl captured!"); assert(D && "No FunctionDecl captured!");
SourceLocation Loc = D->getBeginLoc(); SourceLocation Loc = D->getBeginLoc();
if (Loc.isValid()) if (Loc.isValid())
diag(Loc, "overloading %0 is disallowed") << D; diag(Loc, "overloading %0 is disallowed") << D;
} }
} // namespace fuchsia } // namespace clang::tidy::fuchsia
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/fuchsia/StaticallyConstructedObjectsCheck.cpp

//===--- StaticallyConstructedObjectsCheck.cpp - clang-tidy----------------===// //===--- StaticallyConstructedObjectsCheck.cpp - clang-tidy----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StaticallyConstructedObjectsCheck.h" #include "StaticallyConstructedObjectsCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::fuchsia {
namespace tidy {
namespace fuchsia {
namespace { namespace {
AST_MATCHER(Expr, isConstantInitializer) { AST_MATCHER(Expr, isConstantInitializer) {
return Node.isConstantInitializer(Finder->getASTContext(), false); return Node.isConstantInitializer(Finder->getASTContext(), false);
} }
AST_MATCHER(VarDecl, isGlobalStatic) { AST_MATCHER(VarDecl, isGlobalStatic) {
return Node.getStorageDuration() == SD_Static && !Node.isLocalVarDecl(); return Node.getStorageDuration() == SD_Static && !Node.isLocalVarDecl();
Show All 21 Lines
void StaticallyConstructedObjectsCheck::check( void StaticallyConstructedObjectsCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
if (const auto *D = Result.Nodes.getNodeAs<VarDecl>("decl")) if (const auto *D = Result.Nodes.getNodeAs<VarDecl>("decl"))
diag(D->getBeginLoc(), "static objects are disallowed; if possible, use a " diag(D->getBeginLoc(), "static objects are disallowed; if possible, use a "
"constexpr constructor instead"); "constexpr constructor instead");
} }
} // namespace fuchsia } // namespace clang::tidy::fuchsia
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/fuchsia/TrailingReturnCheck.cpp

//===--- TrailingReturnCheck.cpp - clang-tidy------------------------------===// //===--- TrailingReturnCheck.cpp - clang-tidy------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TrailingReturnCheck.h" #include "TrailingReturnCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchersInternal.h" #include "clang/ASTMatchers/ASTMatchersInternal.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::fuchsia {
namespace tidy {
namespace fuchsia {
void TrailingReturnCheck::registerMatchers(MatchFinder *Finder) { void TrailingReturnCheck::registerMatchers(MatchFinder *Finder) {
// Functions that have trailing returns are disallowed, except for those // Functions that have trailing returns are disallowed, except for those
// using decltype specifiers and lambda with otherwise unutterable // using decltype specifiers and lambda with otherwise unutterable
// return types. // return types.
Finder->addMatcher( Finder->addMatcher(
functionDecl(hasTrailingReturn(), functionDecl(hasTrailingReturn(),
unless(anyOf(returns(decltypeType()), unless(anyOf(returns(decltypeType()),
hasParent(cxxRecordDecl(isLambda())), hasParent(cxxRecordDecl(isLambda())),
cxxDeductionGuideDecl()))) cxxDeductionGuideDecl())))
.bind("decl"), .bind("decl"),
this); this);
} }
void TrailingReturnCheck::check(const MatchFinder::MatchResult &Result) { void TrailingReturnCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *D = Result.Nodes.getNodeAs<FunctionDecl>("decl")) if (const auto *D = Result.Nodes.getNodeAs<FunctionDecl>("decl"))
diag(D->getBeginLoc(), diag(D->getBeginLoc(),
"a trailing return type is disallowed for this function declaration"); "a trailing return type is disallowed for this function declaration");
} }
} // namespace fuchsia } // namespace clang::tidy::fuchsia
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/fuchsia/VirtualInheritanceCheck.cpp

//===--- VirtualInheritanceCheck.cpp - clang-tidy--------------------------===// //===--- VirtualInheritanceCheck.cpp - clang-tidy--------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "VirtualInheritanceCheck.h" #include "VirtualInheritanceCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::fuchsia {
namespace tidy {
namespace fuchsia {
namespace { namespace {
AST_MATCHER(CXXRecordDecl, hasDirectVirtualBaseClass) { AST_MATCHER(CXXRecordDecl, hasDirectVirtualBaseClass) {
if (!Node.hasDefinition()) return false; if (!Node.hasDefinition()) return false;
if (!Node.getNumVBases()) return false; if (!Node.getNumVBases()) return false;
for (const CXXBaseSpecifier &Base : Node.bases()) for (const CXXBaseSpecifier &Base : Node.bases())
if (Base.isVirtual()) return true; if (Base.isVirtual()) return true;
return false; return false;
} }
} // namespace } // namespace
void VirtualInheritanceCheck::registerMatchers(MatchFinder *Finder) { void VirtualInheritanceCheck::registerMatchers(MatchFinder *Finder) {
// Defining classes using direct virtual inheritance is disallowed. // Defining classes using direct virtual inheritance is disallowed.
Finder->addMatcher(cxxRecordDecl(hasDirectVirtualBaseClass()).bind("decl"), Finder->addMatcher(cxxRecordDecl(hasDirectVirtualBaseClass()).bind("decl"),
this); this);
} }
void VirtualInheritanceCheck::check(const MatchFinder::MatchResult &Result) { void VirtualInheritanceCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl")) if (const auto *D = Result.Nodes.getNodeAs<CXXRecordDecl>("decl"))
diag(D->getBeginLoc(), "direct virtual inheritance is disallowed"); diag(D->getBeginLoc(), "direct virtual inheritance is disallowed");
} }
} // namespace fuchsia } // namespace clang::tidy::fuchsia
} // namespace tidy
} // namespace clang

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

//===--- AvoidCStyleCastsCheck.cpp - clang-tidy -----------------*- C++ -*-===// //===--- AvoidCStyleCastsCheck.cpp - clang-tidy -----------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidCStyleCastsCheck.h" #include "AvoidCStyleCastsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google::readability {
namespace tidy {
namespace google {
namespace readability {
void AvoidCStyleCastsCheck::registerMatchers( void AvoidCStyleCastsCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
cStyleCastExpr( cStyleCastExpr(
// Filter out (EnumType)IntegerLiteral construct, which is generated // Filter out (EnumType)IntegerLiteral construct, which is generated
// for non-type template arguments of enum types. // for non-type template arguments of enum types.
// FIXME: Remove this once this is fixed in the AST. // FIXME: Remove this once this is fixed in the AST.
▲ Show 20 Lines • Show All 224 Lines • ▼ Show 20 Lines case CK_BitCast:
break; break;
default: default:
break; break;
} }
Diag << "static_cast/const_cast/reinterpret_cast"; Diag << "static_cast/const_cast/reinterpret_cast";
} }
} // namespace readability } // namespace clang::tidy::google::readability
} // namespace google
} // namespace tidy
} // namespace clang

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

Show All 13 Lines
#include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManager.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
#include <map> #include <map>
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google::objc {
namespace tidy {
namespace google {
namespace objc {
static bool isMessageExpressionInsideMacro(const ObjCMessageExpr *Expr) { static bool isMessageExpressionInsideMacro(const ObjCMessageExpr *Expr) {
SourceLocation ReceiverLocation = Expr->getReceiverRange().getBegin(); SourceLocation ReceiverLocation = Expr->getReceiverRange().getBegin();
if (ReceiverLocation.isMacroID()) if (ReceiverLocation.isMacroID())
return true; return true;
SourceLocation SelectorLocation = Expr->getSelectorStartLoc(); SourceLocation SelectorLocation = Expr->getSelectorStartLoc();
if (SelectorLocation.isMacroID()) if (SelectorLocation.isMacroID())
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Linesvoid AvoidNSObjectNewCheck::check(const MatchFinder::MatchResult &Result) {
} }
if (const auto *DeclExpr = if (const auto *DeclExpr =
Result.Nodes.getNodeAs<ObjCMethodDecl>("new_override")) { Result.Nodes.getNodeAs<ObjCMethodDecl>("new_override")) {
diag(DeclExpr->getBeginLoc(), "classes should not override +new"); diag(DeclExpr->getBeginLoc(), "classes should not override +new");
} }
} }
} // namespace objc } // namespace clang::tidy::google::objc
} // namespace google
} // namespace tidy
} // namespace clang

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

//===--- AvoidThrowingObjCExceptionCheck.cpp - clang-tidy------------------===// //===--- AvoidThrowingObjCExceptionCheck.cpp - clang-tidy------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidThrowingObjCExceptionCheck.h" #include "AvoidThrowingObjCExceptionCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google::objc {
namespace tidy {
namespace google {
namespace objc {
void AvoidThrowingObjCExceptionCheck::registerMatchers(MatchFinder *Finder) { void AvoidThrowingObjCExceptionCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(objcThrowStmt().bind("throwStmt"), this); Finder->addMatcher(objcThrowStmt().bind("throwStmt"), this);
Finder->addMatcher( Finder->addMatcher(
objcMessageExpr(anyOf(hasSelector("raise:format:"), objcMessageExpr(anyOf(hasSelector("raise:format:"),
hasSelector("raise:format:arguments:")), hasSelector("raise:format:arguments:")),
hasReceiverType(asString("NSException"))) hasReceiverType(asString("NSException")))
Show All 25 Lines if (SM.isInSystemHeader(MacroLoc))
return; return;
} }
diag(SourceLoc, diag(SourceLoc,
"pass in NSError ** instead of throwing exception to indicate " "pass in NSError ** instead of throwing exception to indicate "
"Objective-C errors"); "Objective-C errors");
} }
} // namespace objc } // namespace clang::tidy::google::objc
} // namespace google
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "AvoidUnderscoreInGoogletestNameCheck.h" #include "AvoidUnderscoreInGoogletestNameCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/MacroArgs.h" #include "clang/Lex/MacroArgs.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
namespace clang { namespace clang::tidy::google::readability {
namespace tidy {
namespace google {
namespace readability {
constexpr llvm::StringLiteral KDisabledTestPrefix = "DISABLED_"; constexpr llvm::StringLiteral KDisabledTestPrefix = "DISABLED_";
// Determines whether the macro is a Googletest test macro. // Determines whether the macro is a Googletest test macro.
static bool isGoogletestTestMacro(StringRef MacroName) { static bool isGoogletestTestMacro(StringRef MacroName) {
static const llvm::StringSet<> MacroNames = {"TEST", "TEST_F", "TEST_P", static const llvm::StringSet<> MacroNames = {"TEST", "TEST_F", "TEST_P",
"TYPED_TEST", "TYPED_TEST_P"}; "TYPED_TEST", "TYPED_TEST_P"};
return MacroNames.find(MacroName) != MacroNames.end(); return MacroNames.find(MacroName) != MacroNames.end();
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void AvoidUnderscoreInGoogletestNameCheck::registerPPCallbacks( void AvoidUnderscoreInGoogletestNameCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
PP->addPPCallbacks( PP->addPPCallbacks(
std::make_unique<AvoidUnderscoreInGoogletestNameCallback>(PP, this)); std::make_unique<AvoidUnderscoreInGoogletestNameCallback>(PP, this));
} }
} // namespace readability } // namespace clang::tidy::google::readability
} // namespace google
} // namespace tidy
} // namespace clang

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

//===--- DefaultArgumentsCheck.cpp - clang-tidy----------------------------===// //===--- DefaultArgumentsCheck.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DefaultArgumentsCheck.h" #include "DefaultArgumentsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google {
namespace tidy {
namespace google {
void DefaultArgumentsCheck::registerMatchers(MatchFinder *Finder) { void DefaultArgumentsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
cxxMethodDecl(anyOf(isOverride(), isVirtual()), cxxMethodDecl(anyOf(isOverride(), isVirtual()),
hasAnyParameter(parmVarDecl(hasInitializer(expr())))) hasAnyParameter(parmVarDecl(hasInitializer(expr()))))
.bind("Decl"), .bind("Decl"),
this); this);
} }
void DefaultArgumentsCheck::check(const MatchFinder::MatchResult &Result) { void DefaultArgumentsCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedDecl = Result.Nodes.getNodeAs<CXXMethodDecl>("Decl"); const auto *MatchedDecl = Result.Nodes.getNodeAs<CXXMethodDecl>("Decl");
diag(MatchedDecl->getLocation(), diag(MatchedDecl->getLocation(),
"default arguments on virtual or override methods are prohibited"); "default arguments on virtual or override methods are prohibited");
} }
} // namespace google } // namespace clang::tidy::google
} // namespace tidy
} // namespace clang

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

//===--- ExplicitConstructorCheck.cpp - clang-tidy ------------------------===// //===--- ExplicitConstructorCheck.cpp - clang-tidy ------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ExplicitConstructorCheck.h" #include "ExplicitConstructorCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google {
namespace tidy {
namespace google {
void ExplicitConstructorCheck::registerMatchers(MatchFinder *Finder) { void ExplicitConstructorCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
cxxConstructorDecl(unless(anyOf(isImplicit(), // Compiler-generated. cxxConstructorDecl(unless(anyOf(isImplicit(), // Compiler-generated.
isDeleted(), isInstantiated()))) isDeleted(), isInstantiated())))
.bind("ctor"), .bind("ctor"),
this); this);
Finder->addMatcher( Finder->addMatcher(
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Linesvoid ExplicitConstructorCheck::check(const MatchFinder::MatchResult &Result) {
SourceLocation Loc = Ctor->getLocation(); SourceLocation Loc = Ctor->getLocation();
diag(Loc, WarningMessage) diag(Loc, WarningMessage)
<< (SingleArgument << (SingleArgument
? "single-argument constructors" ? "single-argument constructors"
: "constructors that are callable with a single argument") : "constructors that are callable with a single argument")
<< FixItHint::CreateInsertion(Loc, "explicit "); << FixItHint::CreateInsertion(Loc, "explicit ");
} }
} // namespace google } // namespace clang::tidy::google
} // namespace tidy
} // namespace clang

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

Show All 14 Lines
namespace clang { namespace clang {
namespace { namespace {
AST_MATCHER(DeclRefExpr, hasExplicitTemplateArgs) { AST_MATCHER(DeclRefExpr, hasExplicitTemplateArgs) {
return Node.hasExplicitTemplateArgs(); return Node.hasExplicitTemplateArgs();
} }
} // namespace } // namespace
namespace tidy { namespace tidy::google::build {
namespace google {
namespace build {
void ExplicitMakePairCheck::registerMatchers( void ExplicitMakePairCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
// Look for std::make_pair with explicit template args. Ignore calls in // Look for std::make_pair with explicit template args. Ignore calls in
// templates. // templates.
Finder->addMatcher( Finder->addMatcher(
callExpr(unless(isInTemplateInstantiation()), callExpr(unless(isInTemplateInstantiation()),
callee(expr(ignoringParenImpCasts( callee(expr(ignoringParenImpCasts(
Show All 27 Linesvoid ExplicitMakePairCheck::check(const MatchFinder::MatchResult &Result) {
} else { } else {
diag(Call->getBeginLoc(), diag(Call->getBeginLoc(),
"for C++11-compatibility, omit template arguments from make_pair") "for C++11-compatibility, omit template arguments from make_pair")
<< FixItHint::CreateRemoval( << FixItHint::CreateRemoval(
SourceRange(DeclRef->getLAngleLoc(), DeclRef->getRAngleLoc())); SourceRange(DeclRef->getLAngleLoc(), DeclRef->getRAngleLoc()));
} }
} }
} // namespace build } // namespace tidy::google::build
} // namespace google
} // namespace tidy
} // namespace clang } // namespace clang

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

//===--- FunctionNamingCheck.cpp - clang-tidy -----------------------------===// //===--- FunctionNamingCheck.cpp - clang-tidy -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FunctionNamingCheck.h" #include "FunctionNamingCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/Support/Regex.h" #include "llvm/Support/Regex.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google::objc {
namespace tidy {
namespace google {
namespace objc {
namespace { namespace {
std::string validFunctionNameRegex(bool RequirePrefix) { std::string validFunctionNameRegex(bool RequirePrefix) {
// Allow the following name patterns for all functions: // Allow the following name patterns for all functions:
// • ABFoo (prefix + UpperCamelCase) // • ABFoo (prefix + UpperCamelCase)
// • ABURL (prefix + capitalized acronym/initialism) // • ABURL (prefix + capitalized acronym/initialism)
// //
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Linesvoid FunctionNamingCheck::check(const MatchFinder::MatchResult &Result) {
bool IsGlobal = MatchedDecl->getStorageClass() != SC_Static; bool IsGlobal = MatchedDecl->getStorageClass() != SC_Static;
diag(MatchedDecl->getLocation(), diag(MatchedDecl->getLocation(),
"%select{static function|function in global namespace}1 named %0 must " "%select{static function|function in global namespace}1 named %0 must "
"%select{be in|have an appropriate prefix followed by}1 Pascal case as " "%select{be in|have an appropriate prefix followed by}1 Pascal case as "
"required by Google Objective-C style guide") "required by Google Objective-C style guide")
<< MatchedDecl << IsGlobal << generateFixItHint(MatchedDecl); << MatchedDecl << IsGlobal << generateFixItHint(MatchedDecl);
} }
} // namespace objc } // namespace clang::tidy::google::objc
} // namespace google
} // namespace tidy
} // namespace clang

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

//===--- GlobalNamesInHeadersCheck.cpp - clang-tidy -----------------*- C++ -*-===// //===--- GlobalNamesInHeadersCheck.cpp - clang-tidy -----------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "GlobalNamesInHeadersCheck.h" #include "GlobalNamesInHeadersCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google::readability {
namespace tidy {
namespace google {
namespace readability {
GlobalNamesInHeadersCheck::GlobalNamesInHeadersCheck(StringRef Name, GlobalNamesInHeadersCheck::GlobalNamesInHeadersCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
RawStringHeaderFileExtensions(Options.getLocalOrGlobal( RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
"HeaderFileExtensions", utils::defaultHeaderFileExtensions())) { "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
if (!utils::parseFileExtensions(RawStringHeaderFileExtensions, if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
HeaderFileExtensions, HeaderFileExtensions,
Show All 40 Lines if (UsingDirective->getNominatedNamespace()->isAnonymousNamespace()) {
return; return;
} }
} }
diag(D->getBeginLoc(), diag(D->getBeginLoc(),
"using declarations in the global namespace in headers are prohibited"); "using declarations in the global namespace in headers are prohibited");
} }
} // namespace readability } // namespace clang::tidy::google::readability
} // namespace google
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google::objc {
namespace tidy {
namespace google {
namespace objc {
namespace { namespace {
AST_MATCHER(VarDecl, isLocalVariable) { return Node.isLocalVarDecl(); } AST_MATCHER(VarDecl, isLocalVariable) { return Node.isLocalVarDecl(); }
FixItHint generateFixItHint(const VarDecl *Decl, bool IsConst) { FixItHint generateFixItHint(const VarDecl *Decl, bool IsConst) {
if (IsConst && (Decl->getStorageClass() != SC_Static)) { if (IsConst && (Decl->getStorageClass() != SC_Static)) {
// No fix available if it is not a static constant, since it is difficult // No fix available if it is not a static constant, since it is difficult
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines if (Decl->isStaticDataMember())
return; return;
diag(Decl->getLocation(), diag(Decl->getLocation(),
"const global variable '%0' must have a name which starts with " "const global variable '%0' must have a name which starts with "
"an appropriate prefix") "an appropriate prefix")
<< Decl->getName() << generateFixItHint(Decl, true); << Decl->getName() << generateFixItHint(Decl, true);
} }
} }
} // namespace objc } // namespace clang::tidy::google::objc
} // namespace google
} // namespace tidy
} // namespace clang

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

Show All 25 Lines
#include "OverloadedUnaryAndCheck.h" #include "OverloadedUnaryAndCheck.h"
#include "TodoCommentCheck.h" #include "TodoCommentCheck.h"
#include "UnnamedNamespaceInHeaderCheck.h" #include "UnnamedNamespaceInHeaderCheck.h"
#include "UpgradeGoogletestCaseCheck.h" #include "UpgradeGoogletestCaseCheck.h"
#include "UsingNamespaceDirectiveCheck.h" #include "UsingNamespaceDirectiveCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
namespace google { namespace google {
class GoogleModule : public ClangTidyModule { class GoogleModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<build::ExplicitMakePairCheck>( CheckFactories.registerCheck<build::ExplicitMakePairCheck>(
"google-build-explicit-make-pair"); "google-build-explicit-make-pair");
CheckFactories.registerCheck<build::UnnamedNamespaceInHeaderCheck>( CheckFactories.registerCheck<build::UnnamedNamespaceInHeaderCheck>(
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesstatic ClangTidyModuleRegistry::Add<GoogleModule> X("google-module",
"Adds Google lint checks."); "Adds Google lint checks.");
} // namespace google } // namespace google
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the GoogleModule. // and thus register the GoogleModule.
volatile int GoogleModuleAnchorSource = 0; volatile int GoogleModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

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

Show All 30 Linesstatic Token getTokenAtLoc(SourceLocation Loc,
if (Tok.is(tok::raw_identifier)) { if (Tok.is(tok::raw_identifier)) {
IdentifierInfo &Info = IdentTable.get(Tok.getRawIdentifier()); IdentifierInfo &Info = IdentTable.get(Tok.getRawIdentifier());
Tok.setIdentifierInfo(&Info); Tok.setIdentifierInfo(&Info);
Tok.setKind(Info.getTokenID()); Tok.setKind(Info.getTokenID());
} }
return Tok; return Tok;
} }
namespace tidy { namespace tidy::google::runtime {
namespace google {
namespace runtime {
IntegerTypesCheck::IntegerTypesCheck(StringRef Name, ClangTidyContext *Context) IntegerTypesCheck::IntegerTypesCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
UnsignedTypePrefix(Options.get("UnsignedTypePrefix", "uint")), UnsignedTypePrefix(Options.get("UnsignedTypePrefix", "uint")),
SignedTypePrefix(Options.get("SignedTypePrefix", "int")), SignedTypePrefix(Options.get("SignedTypePrefix", "int")),
TypeSuffix(Options.get("TypeSuffix", "")) {} TypeSuffix(Options.get("TypeSuffix", "")) {}
void IntegerTypesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void IntegerTypesCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Linesvoid IntegerTypesCheck::check(const MatchFinder::MatchResult &Result) {
// We don't add a fix-it as changing the type can easily break code, // We don't add a fix-it as changing the type can easily break code,
// e.g. when a function requires a 'long' argument on all platforms. // e.g. when a function requires a 'long' argument on all platforms.
// QualTypes are printed with implicit quotes. // QualTypes are printed with implicit quotes.
diag(Loc, "consider replacing %0 with '%1'") << BuiltinLoc.getType() diag(Loc, "consider replacing %0 with '%1'") << BuiltinLoc.getType()
<< Replacement; << Replacement;
} }
} // namespace runtime } // namespace tidy::google::runtime
} // namespace google
} // namespace tidy
} // namespace clang } // namespace clang

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

//===--- OverloadedUnaryAndCheck.cpp - clang-tidy ---------------*- C++ -*-===// //===--- OverloadedUnaryAndCheck.cpp - clang-tidy ---------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "OverloadedUnaryAndCheck.h" #include "OverloadedUnaryAndCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google::runtime {
namespace tidy {
namespace google {
namespace runtime {
void OverloadedUnaryAndCheck::registerMatchers( void OverloadedUnaryAndCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
// Match unary methods that overload operator&. // Match unary methods that overload operator&.
Finder->addMatcher( Finder->addMatcher(
cxxMethodDecl(parameterCountIs(0), hasOverloadedOperatorName("&")) cxxMethodDecl(parameterCountIs(0), hasOverloadedOperatorName("&"))
.bind("overload"), .bind("overload"),
this); this);
// Also match freestanding unary operator& overloads. Be careful not to match // Also match freestanding unary operator& overloads. Be careful not to match
// binary methods. // binary methods.
Finder->addMatcher(functionDecl(unless(cxxMethodDecl()), parameterCountIs(1), Finder->addMatcher(functionDecl(unless(cxxMethodDecl()), parameterCountIs(1),
hasOverloadedOperatorName("&")) hasOverloadedOperatorName("&"))
.bind("overload"), .bind("overload"),
this); this);
} }
void OverloadedUnaryAndCheck::check(const MatchFinder::MatchResult &Result) { void OverloadedUnaryAndCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Decl = Result.Nodes.getNodeAs<FunctionDecl>("overload"); const auto *Decl = Result.Nodes.getNodeAs<FunctionDecl>("overload");
diag(Decl->getBeginLoc(), diag(Decl->getBeginLoc(),
"do not overload unary operator&, it is dangerous."); "do not overload unary operator&, it is dangerous.");
} }
} // namespace runtime } // namespace clang::tidy::google::runtime
} // namespace google
} // namespace tidy
} // namespace clang

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

//===--- TodoCommentCheck.cpp - clang-tidy --------------------------------===// //===--- TodoCommentCheck.cpp - clang-tidy --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TodoCommentCheck.h" #include "TodoCommentCheck.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::google::readability {
namespace tidy {
namespace google {
namespace readability {
class TodoCommentCheck::TodoCommentHandler : public CommentHandler { class TodoCommentCheck::TodoCommentHandler : public CommentHandler {
public: public:
TodoCommentHandler(TodoCommentCheck &Check, std::optional<std::string> User) TodoCommentHandler(TodoCommentCheck &Check, std::optional<std::string> User)
: Check(Check), User(User ? *User : "unknown"), : Check(Check), User(User ? *User : "unknown"),
TodoMatch("^// *TODO *(\\(.*\\))?:?( )?(.*)$") {} TodoMatch("^// *TODO *(\\(.*\\))?:?( )?(.*)$") {}
bool HandleComment(Preprocessor &PP, SourceRange Range) override { bool HandleComment(Preprocessor &PP, SourceRange Range) override {
Show All 33 Lines
TodoCommentCheck::~TodoCommentCheck() = default; TodoCommentCheck::~TodoCommentCheck() = default;
void TodoCommentCheck::registerPPCallbacks(const SourceManager &SM, void TodoCommentCheck::registerPPCallbacks(const SourceManager &SM,
Preprocessor *PP, Preprocessor *PP,
Preprocessor *ModuleExpanderPP) { Preprocessor *ModuleExpanderPP) {
PP->addCommentHandler(Handler.get()); PP->addCommentHandler(Handler.get());
} }
} // namespace readability } // namespace clang::tidy::google::readability
} // namespace google
} // namespace tidy
} // namespace clang

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

//===--- UnnamedNamespaceInHeaderCheck.cpp - clang-tidy ---------*- C++ -*-===// //===--- UnnamedNamespaceInHeaderCheck.cpp - clang-tidy ---------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnnamedNamespaceInHeaderCheck.h" #include "UnnamedNamespaceInHeaderCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google::build {
namespace tidy {
namespace google {
namespace build {
UnnamedNamespaceInHeaderCheck::UnnamedNamespaceInHeaderCheck( UnnamedNamespaceInHeaderCheck::UnnamedNamespaceInHeaderCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
RawStringHeaderFileExtensions(Options.getLocalOrGlobal( RawStringHeaderFileExtensions(Options.getLocalOrGlobal(
"HeaderFileExtensions", utils::defaultHeaderFileExtensions())) { "HeaderFileExtensions", utils::defaultHeaderFileExtensions())) {
if (!utils::parseFileExtensions(RawStringHeaderFileExtensions, if (!utils::parseFileExtensions(RawStringHeaderFileExtensions,
HeaderFileExtensions, HeaderFileExtensions,
Show All 21 Linesvoid UnnamedNamespaceInHeaderCheck::check(
if (!Loc.isValid()) if (!Loc.isValid())
return; return;
if (utils::isPresumedLocInHeaderFile(Loc, *Result.SourceManager, if (utils::isPresumedLocInHeaderFile(Loc, *Result.SourceManager,
HeaderFileExtensions)) HeaderFileExtensions))
diag(Loc, "do not use unnamed namespaces in header files"); diag(Loc, "do not use unnamed namespaces in header files");
} }
} // namespace build } // namespace clang::tidy::google::build
} // namespace google
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google {
namespace tidy {
namespace google {
static const llvm::StringRef RenameCaseToSuiteMessage = static const llvm::StringRef RenameCaseToSuiteMessage =
"Google Test APIs named with 'case' are deprecated; use equivalent APIs " "Google Test APIs named with 'case' are deprecated; use equivalent APIs "
"named with 'suite'"; "named with 'suite'";
static std::optional<llvm::StringRef> static std::optional<llvm::StringRef>
getNewMacroName(llvm::StringRef MacroName) { getNewMacroName(llvm::StringRef MacroName) {
std::pair<llvm::StringRef, llvm::StringRef> ReplacementMap[] = { std::pair<llvm::StringRef, llvm::StringRef> ReplacementMap[] = {
▲ Show 20 Lines • Show All 316 Lines • ▼ Show 20 Linesvoid UpgradeGoogletestCaseCheck::check(const MatchFinder::MatchResult &Result) {
if (ReplacementRange.isInvalid()) if (ReplacementRange.isInvalid())
// An invalid source range likely means we are inside a macro body. A manual // An invalid source range likely means we are inside a macro body. A manual
// fix is likely needed so we do not create a fix-it hint. // fix is likely needed so we do not create a fix-it hint.
return; return;
Diag << FixItHint::CreateReplacement(ReplacementRange, ReplacementText); Diag << FixItHint::CreateReplacement(ReplacementRange, ReplacementText);
} }
} // namespace google } // namespace clang::tidy::google
} // namespace tidy
} // namespace clang

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

//===--- UsingNamespaceDirectiveCheck.cpp - clang-tidy ----------*- C++ -*-===// //===--- UsingNamespaceDirectiveCheck.cpp - clang-tidy ----------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UsingNamespaceDirectiveCheck.h" #include "UsingNamespaceDirectiveCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::google::build {
namespace tidy {
namespace google {
namespace build {
void UsingNamespaceDirectiveCheck::registerMatchers( void UsingNamespaceDirectiveCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
Finder->addMatcher(usingDirectiveDecl().bind("usingNamespace"), this); Finder->addMatcher(usingDirectiveDecl().bind("usingNamespace"), this);
} }
void UsingNamespaceDirectiveCheck::check( void UsingNamespaceDirectiveCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
Show All 23 Lines if (!Parent)
return false; return false;
if (Parent->isStdNamespace()) if (Parent->isStdNamespace())
return true; return true;
return Parent->getName() == "literals" && Parent->getParent() && return Parent->getName() == "literals" && Parent->getParent() &&
Parent->getParent()->isStdNamespace(); Parent->getParent()->isStdNamespace();
} }
} // namespace build } // namespace clang::tidy::google::build
} // namespace google
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/hicpp/ExceptionBaseclassCheck.cpp

//===--- ExceptionBaseclassCheck.cpp - clang-tidy--------------------------===// //===--- ExceptionBaseclassCheck.cpp - clang-tidy--------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ExceptionBaseclassCheck.h" #include "ExceptionBaseclassCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::hicpp {
namespace tidy {
namespace hicpp {
void ExceptionBaseclassCheck::registerMatchers(MatchFinder *Finder) { void ExceptionBaseclassCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
cxxThrowExpr( cxxThrowExpr(
unless(has(expr(anyOf(isTypeDependent(), isValueDependent())))), unless(has(expr(anyOf(isTypeDependent(), isValueDependent())))),
// The thrown value is not derived from 'std::exception'. // The thrown value is not derived from 'std::exception'.
has(expr(unless( has(expr(unless(
hasType(qualType(hasCanonicalType(hasDeclaration(cxxRecordDecl( hasType(qualType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
Show All 27 Lines diag(BadThrow->getSubExpr()->getBeginLoc(),
"type %0 is a template instantiation of %1", DiagnosticIDs::Note) "type %0 is a template instantiation of %1", DiagnosticIDs::Note)
<< BadThrow->getSubExpr()->getType() << BadThrow->getSubExpr()->getType()
<< Template->getReplacedParameter(); << Template->getReplacedParameter();
if (const auto *TypeDecl = Result.Nodes.getNodeAs<NamedDecl>("decl")) if (const auto *TypeDecl = Result.Nodes.getNodeAs<NamedDecl>("decl"))
diag(TypeDecl->getBeginLoc(), "type defined here", DiagnosticIDs::Note); diag(TypeDecl->getBeginLoc(), "type defined here", DiagnosticIDs::Note);
} }
} // namespace hicpp } // namespace clang::tidy::hicpp
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/hicpp/HICPPTidyModule.cpp

Show All 35 Lines
#include "../readability/FunctionSizeCheck.h" #include "../readability/FunctionSizeCheck.h"
#include "../readability/NamedParameterCheck.h" #include "../readability/NamedParameterCheck.h"
#include "../readability/UppercaseLiteralSuffixCheck.h" #include "../readability/UppercaseLiteralSuffixCheck.h"
#include "ExceptionBaseclassCheck.h" #include "ExceptionBaseclassCheck.h"
#include "MultiwayPathsCoveredCheck.h" #include "MultiwayPathsCoveredCheck.h"
#include "NoAssemblerCheck.h" #include "NoAssemblerCheck.h"
#include "SignedBitwiseCheck.h" #include "SignedBitwiseCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace hicpp { namespace hicpp {
class HICPPModule : public ClangTidyModule { class HICPPModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<modernize::AvoidCArraysCheck>( CheckFactories.registerCheck<modernize::AvoidCArraysCheck>(
"hicpp-avoid-c-arrays"); "hicpp-avoid-c-arrays");
CheckFactories.registerCheck<cppcoreguidelines::AvoidGotoCheck>( CheckFactories.registerCheck<cppcoreguidelines::AvoidGotoCheck>(
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesstatic ClangTidyModuleRegistry::Add<HICPPModule>
X("hicpp-module", "Adds High-Integrity C++ checks."); X("hicpp-module", "Adds High-Integrity C++ checks.");
} // namespace hicpp } // namespace hicpp
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the HICPPModule. // and thus register the HICPPModule.
volatile int HICPPModuleAnchorSource = 0; volatile int HICPPModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp

//===--- MultiwayPathsCoveredCheck.cpp - clang-tidy------------------------===// //===--- MultiwayPathsCoveredCheck.cpp - clang-tidy------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MultiwayPathsCoveredCheck.h" #include "MultiwayPathsCoveredCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include <limits> #include <limits>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::hicpp {
namespace tidy {
namespace hicpp {
void MultiwayPathsCoveredCheck::storeOptions( void MultiwayPathsCoveredCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "WarnOnMissingElse", WarnOnMissingElse); Options.store(Opts, "WarnOnMissingElse", WarnOnMissingElse);
} }
void MultiwayPathsCoveredCheck::registerMatchers(MatchFinder *Finder) { void MultiwayPathsCoveredCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Linesvoid MultiwayPathsCoveredCheck::handleSwitchWithoutDefault(
}(); }();
// FIXME: Transform the 'switch' into an 'if' for CaseCount == 1. // FIXME: Transform the 'switch' into an 'if' for CaseCount == 1.
if (CaseCount < MaxPathsPossible) if (CaseCount < MaxPathsPossible)
diag(Switch->getBeginLoc(), diag(Switch->getBeginLoc(),
CaseCount == 1 ? "switch with only one case; use an if statement" CaseCount == 1 ? "switch with only one case; use an if statement"
: "potential uncovered code path; add a default label"); : "potential uncovered code path; add a default label");
} }
} // namespace hicpp } // namespace clang::tidy::hicpp
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/hicpp/NoAssemblerCheck.cpp

//===--- NoAssemblerCheck.cpp - clang-tidy---------------------------------===// //===--- NoAssemblerCheck.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NoAssemblerCheck.h" #include "NoAssemblerCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::hicpp {
namespace tidy {
namespace hicpp {
namespace { namespace {
AST_MATCHER(VarDecl, isAsm) { return Node.hasAttr<clang::AsmLabelAttr>(); } AST_MATCHER(VarDecl, isAsm) { return Node.hasAttr<clang::AsmLabelAttr>(); }
const ast_matchers::internal::VariadicDynCastAllOfMatcher<Decl, const ast_matchers::internal::VariadicDynCastAllOfMatcher<Decl,
FileScopeAsmDecl> FileScopeAsmDecl>
fileScopeAsmDecl; fileScopeAsmDecl;
} // namespace } // namespace
Show All 13 Linesvoid NoAssemblerCheck::check(const MatchFinder::MatchResult &Result) {
else if (const auto *ASM = Result.Nodes.getNodeAs<VarDecl>("asm-var")) else if (const auto *ASM = Result.Nodes.getNodeAs<VarDecl>("asm-var"))
ASMLocation = ASM->getLocation(); ASMLocation = ASM->getLocation();
else else
llvm_unreachable("Unhandled case in matcher."); llvm_unreachable("Unhandled case in matcher.");
diag(ASMLocation, "do not use inline assembler in safety-critical code"); diag(ASMLocation, "do not use inline assembler in safety-critical code");
} }
} // namespace hicpp } // namespace clang::tidy::hicpp
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/hicpp/SignedBitwiseCheck.cpp

//===--- SignedBitwiseCheck.cpp - clang-tidy-------------------------------===// //===--- SignedBitwiseCheck.cpp - clang-tidy-------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SignedBitwiseCheck.h" #include "SignedBitwiseCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::ast_matchers::internal; using namespace clang::ast_matchers::internal;
namespace clang { namespace clang::tidy::hicpp {
namespace tidy {
namespace hicpp {
SignedBitwiseCheck::SignedBitwiseCheck(StringRef Name, SignedBitwiseCheck::SignedBitwiseCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnorePositiveIntegerLiterals( IgnorePositiveIntegerLiterals(
Options.get("IgnorePositiveIntegerLiterals", false)) {} Options.get("IgnorePositiveIntegerLiterals", false)) {}
void SignedBitwiseCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void SignedBitwiseCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines if (const auto *UnaryOp = N.getNodeAs<UnaryOperator>("unary-signed")) {
else else
llvm_unreachable("unexpected matcher result"); llvm_unreachable("unexpected matcher result");
} }
diag(SignedOperand->getBeginLoc(), "use of a signed integer operand with a " diag(SignedOperand->getBeginLoc(), "use of a signed integer operand with a "
"%select{binary|unary}0 bitwise operator") "%select{binary|unary}0 bitwise operator")
<< IsUnary << SignedOperand->getSourceRange() << OperatorLoc; << IsUnary << SignedOperand->getSourceRange() << OperatorLoc;
} }
} // namespace hicpp } // namespace clang::tidy::hicpp
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/linuxkernel/LinuxKernelTidyModule.cpp

//===--- LinuxKernelTidyModule.cpp - clang-tidy----------------------------===// //===--- LinuxKernelTidyModule.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "MustCheckErrsCheck.h" #include "MustCheckErrsCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace linuxkernel { namespace linuxkernel {
/// This module is for checks specific to the Linux kernel. /// This module is for checks specific to the Linux kernel.
class LinuxKernelModule : public ClangTidyModule { class LinuxKernelModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<MustCheckErrsCheck>( CheckFactories.registerCheck<MustCheckErrsCheck>(
"linuxkernel-must-check-errs"); "linuxkernel-must-check-errs");
} }
}; };
// Register the LinuxKernelTidyModule using this statically initialized // Register the LinuxKernelTidyModule using this statically initialized
// variable. // variable.
static ClangTidyModuleRegistry::Add<LinuxKernelModule> static ClangTidyModuleRegistry::Add<LinuxKernelModule>
X("linux-module", "Adds checks specific to the Linux kernel."); X("linux-module", "Adds checks specific to the Linux kernel.");
} // namespace linuxkernel } // namespace linuxkernel
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the LinuxKernelModule. // and thus register the LinuxKernelModule.
volatile int LinuxKernelModuleAnchorSource = 0; volatile int LinuxKernelModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/linuxkernel/MustCheckErrsCheck.cpp

//===--- MustCheckErrsCheck.cpp - clang-tidy ------------------------------===// //===--- MustCheckErrsCheck.cpp - clang-tidy ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MustCheckErrsCheck.h" #include "MustCheckErrsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::linuxkernel {
namespace tidy {
namespace linuxkernel {
void MustCheckErrsCheck::registerMatchers(MatchFinder *Finder) { void MustCheckErrsCheck::registerMatchers(MatchFinder *Finder) {
auto ErrFn = auto ErrFn =
functionDecl(hasAnyName("ERR_PTR", "PTR_ERR", "IS_ERR", "IS_ERR_OR_NULL", functionDecl(hasAnyName("ERR_PTR", "PTR_ERR", "IS_ERR", "IS_ERR_OR_NULL",
"ERR_CAST", "PTR_ERR_OR_ZERO")); "ERR_CAST", "PTR_ERR_OR_ZERO"));
auto NonCheckingStmts = stmt(anyOf(compoundStmt(), labelStmt())); auto NonCheckingStmts = stmt(anyOf(compoundStmt(), labelStmt()));
Finder->addMatcher( Finder->addMatcher(
callExpr(callee(ErrFn), hasParent(NonCheckingStmts)).bind("call"), callExpr(callee(ErrFn), hasParent(NonCheckingStmts)).bind("call"),
Show All 17 Lines const CallExpr *MatchedTransitiveCallExpr =
Result.Nodes.getNodeAs<CallExpr>("transitive_call"); Result.Nodes.getNodeAs<CallExpr>("transitive_call");
if (MatchedTransitiveCallExpr) { if (MatchedTransitiveCallExpr) {
diag(MatchedTransitiveCallExpr->getExprLoc(), diag(MatchedTransitiveCallExpr->getExprLoc(),
"result from function %0 is unused but represents an error value") "result from function %0 is unused but represents an error value")
<< MatchedTransitiveCallExpr->getDirectCallee(); << MatchedTransitiveCallExpr->getDirectCallee();
} }
} }
} // namespace linuxkernel } // namespace clang::tidy::linuxkernel
} // namespace tidy
} // namespace clang

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

//===--- HeaderGuardCheck.cpp - clang-tidy --------------------------------===// //===--- HeaderGuardCheck.cpp - clang-tidy --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "HeaderGuardCheck.h" #include "HeaderGuardCheck.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
namespace clang { namespace clang::tidy::llvm_check {
namespace tidy {
namespace llvm_check {
LLVMHeaderGuardCheck::LLVMHeaderGuardCheck(StringRef Name, LLVMHeaderGuardCheck::LLVMHeaderGuardCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: HeaderGuardCheck(Name, Context) {} : HeaderGuardCheck(Name, Context) {}
std::string LLVMHeaderGuardCheck::getHeaderGuard(StringRef Filename, std::string LLVMHeaderGuardCheck::getHeaderGuard(StringRef Filename,
StringRef OldGuard) { StringRef OldGuard) {
std::string Guard = tooling::getAbsolutePath(Filename); std::string Guard = tooling::getAbsolutePath(Filename);
Show All 37 Linesstd::string LLVMHeaderGuardCheck::getHeaderGuard(StringRef Filename,
// The prevalent style in flang is FORTRAN_FOO_BAR_H // The prevalent style in flang is FORTRAN_FOO_BAR_H
if (StringRef(Guard).startswith("flang")) if (StringRef(Guard).startswith("flang"))
Guard = "FORTRAN" + Guard.substr(sizeof("flang") - 1); Guard = "FORTRAN" + Guard.substr(sizeof("flang") - 1);
return StringRef(Guard).upper(); return StringRef(Guard).upper();
} }
} // namespace llvm_check } // namespace clang::tidy::llvm_check
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp

//===--- IncludeOrderCheck.cpp - clang-tidy -------------------------------===// //===--- IncludeOrderCheck.cpp - clang-tidy -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "IncludeOrderCheck.h" #include "IncludeOrderCheck.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include <map> #include <map>
namespace clang { namespace clang::tidy::llvm_check {
namespace tidy {
namespace llvm_check {
namespace { namespace {
class IncludeOrderPPCallbacks : public PPCallbacks { class IncludeOrderPPCallbacks : public PPCallbacks {
public: public:
explicit IncludeOrderPPCallbacks(ClangTidyCheck &Check, explicit IncludeOrderPPCallbacks(ClangTidyCheck &Check,
const SourceManager &SM) const SourceManager &SM)
: LookForMainModule(true), Check(Check), SM(SM) {} : LookForMainModule(true), Check(Check), SM(SM) {}
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Lines for (unsigned BI = 0, BE = Blocks.size() - 1; BI != BE; ++BI) {
D << FixItHint::CreateReplacement(ToRange, FixedName); D << FixItHint::CreateReplacement(ToRange, FixedName);
} }
} }
} }
IncludeDirectives.clear(); IncludeDirectives.clear();
} }
} // namespace llvm_check } // namespace clang::tidy::llvm_check
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/llvm/LLVMTidyModule.cpp

Show All 12 Lines
#include "../readability/NamespaceCommentCheck.h" #include "../readability/NamespaceCommentCheck.h"
#include "../readability/QualifiedAutoCheck.h" #include "../readability/QualifiedAutoCheck.h"
#include "HeaderGuardCheck.h" #include "HeaderGuardCheck.h"
#include "IncludeOrderCheck.h" #include "IncludeOrderCheck.h"
#include "PreferIsaOrDynCastInConditionalsCheck.h" #include "PreferIsaOrDynCastInConditionalsCheck.h"
#include "PreferRegisterOverUnsignedCheck.h" #include "PreferRegisterOverUnsignedCheck.h"
#include "TwineLocalCheck.h" #include "TwineLocalCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace llvm_check { namespace llvm_check {
class LLVMModule : public ClangTidyModule { class LLVMModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<readability::ElseAfterReturnCheck>( CheckFactories.registerCheck<readability::ElseAfterReturnCheck>(
"llvm-else-after-return"); "llvm-else-after-return");
CheckFactories.registerCheck<LLVMHeaderGuardCheck>("llvm-header-guard"); CheckFactories.registerCheck<LLVMHeaderGuardCheck>("llvm-header-guard");
Show All 24 Linesstatic ClangTidyModuleRegistry::Add<LLVMModule> X("llvm-module",
"Adds LLVM lint checks."); "Adds LLVM lint checks.");
} // namespace llvm_check } // namespace llvm_check
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the LLVMModule. // and thus register the LLVMModule.
volatile int LLVMModuleAnchorSource = 0; volatile int LLVMModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/llvm/PreferIsaOrDynCastInConditionalsCheck.cpp

Show All 13 Lines
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace ast_matchers { namespace ast_matchers {
AST_MATCHER(Expr, isMacroID) { return Node.getExprLoc().isMacroID(); } AST_MATCHER(Expr, isMacroID) { return Node.getExprLoc().isMacroID(); }
} // namespace ast_matchers } // namespace ast_matchers
namespace tidy { namespace tidy::llvm_check {
namespace llvm_check {
void PreferIsaOrDynCastInConditionalsCheck::registerMatchers( void PreferIsaOrDynCastInConditionalsCheck::registerMatchers(
MatchFinder *Finder) { MatchFinder *Finder) {
auto Condition = hasCondition(implicitCastExpr(has( auto Condition = hasCondition(implicitCastExpr(has(
callExpr( callExpr(
allOf(unless(isMacroID()), unless(cxxMemberCallExpr()), allOf(unless(isMacroID()), unless(cxxMemberCallExpr()),
anyOf(callee(namedDecl(hasName("cast"))), anyOf(callee(namedDecl(hasName("cast"))),
callee(namedDecl(hasName("dyn_cast")).bind("dyn_cast"))))) callee(namedDecl(hasName("dyn_cast")).bind("dyn_cast")))))
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Lines diag(MatchedDecl->getBeginLoc(),
"isa_and_nonnull<> is preferred over an explicit test for null " "isa_and_nonnull<> is preferred over an explicit test for null "
"followed by calling isa<>") "followed by calling isa<>")
<< FixItHint::CreateReplacement(SourceRange(MatchedDecl->getBeginLoc(), << FixItHint::CreateReplacement(SourceRange(MatchedDecl->getBeginLoc(),
MatchedDecl->getEndLoc()), MatchedDecl->getEndLoc()),
Replacement); Replacement);
} }
} }
} // namespace llvm_check } // namespace tidy::llvm_check
} // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/llvm/PreferRegisterOverUnsignedCheck.cpp

//===--- PreferRegisterOverUnsignedCheck.cpp - clang-tidy -----------------===// //===--- PreferRegisterOverUnsignedCheck.cpp - clang-tidy -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "PreferRegisterOverUnsignedCheck.h" #include "PreferRegisterOverUnsignedCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::llvm_check {
namespace tidy {
namespace llvm_check {
void PreferRegisterOverUnsignedCheck::registerMatchers(MatchFinder *Finder) { void PreferRegisterOverUnsignedCheck::registerMatchers(MatchFinder *Finder) {
auto RegisterClassMatch = hasType( auto RegisterClassMatch = hasType(
cxxRecordDecl(hasName("::llvm::Register")).bind("registerClassDecl")); cxxRecordDecl(hasName("::llvm::Register")).bind("registerClassDecl"));
Finder->addMatcher( Finder->addMatcher(
traverse(TK_AsIs, traverse(TK_AsIs,
valueDecl(allOf( valueDecl(allOf(
Show All 30 Linesvoid PreferRegisterOverUnsignedCheck::check(
diag(UserVarDecl->getLocation(), diag(UserVarDecl->getLocation(),
"variable %0 declared as %1; use '%select{|llvm::}2Register' instead") "variable %0 declared as %1; use '%select{|llvm::}2Register' instead")
<< UserVarDecl << *VarType << NeedsQualification << UserVarDecl << *VarType << NeedsQualification
<< FixItHint::CreateReplacement( << FixItHint::CreateReplacement(
UserVarDecl->getTypeSourceInfo()->getTypeLoc().getSourceRange(), UserVarDecl->getTypeSourceInfo()->getTypeLoc().getSourceRange(),
NeedsQualification ? "llvm::Register" : "Register"); NeedsQualification ? "llvm::Register" : "Register");
} }
} // namespace llvm_check } // namespace clang::tidy::llvm_check
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/llvm/TwineLocalCheck.cpp

//===--- TwineLocalCheck.cpp - clang-tidy ---------------------------------===// //===--- TwineLocalCheck.cpp - clang-tidy ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TwineLocalCheck.h" #include "TwineLocalCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::llvm_check {
namespace tidy {
namespace llvm_check {
void TwineLocalCheck::registerMatchers(MatchFinder *Finder) { void TwineLocalCheck::registerMatchers(MatchFinder *Finder) {
auto TwineType = auto TwineType =
qualType(hasDeclaration(cxxRecordDecl(hasName("::llvm::Twine")))); qualType(hasDeclaration(cxxRecordDecl(hasName("::llvm::Twine"))));
Finder->addMatcher( Finder->addMatcher(
varDecl(unless(parmVarDecl()), hasType(TwineType)).bind("variable"), varDecl(unless(parmVarDecl()), hasType(TwineType)).bind("variable"),
this); this);
} }
Show All 30 Lines if (VD->getType()->getCanonicalTypeUnqualified() ==
// Just an implicit conversion. Insert the real type. // Just an implicit conversion. Insert the real type.
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
TypeRange, TypeRange,
C->getType().getAsString(Result.Context->getPrintingPolicy())); C->getType().getAsString(Result.Context->getPrintingPolicy()));
} }
} }
} }
} // namespace llvm_check } // namespace clang::tidy::llvm_check
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/llvmlibc/CalleeNamespaceCheck.cpp

//===-- CalleeNamespaceCheck.cpp ------------------------------------------===// //===-- CalleeNamespaceCheck.cpp ------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "CalleeNamespaceCheck.h" #include "CalleeNamespaceCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/StringSet.h" #include "llvm/ADT/StringSet.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::llvm_libc {
namespace tidy {
namespace llvm_libc {
// Gets the outermost namespace of a DeclContext, right under the Translation // Gets the outermost namespace of a DeclContext, right under the Translation
// Unit. // Unit.
const DeclContext *getOutermostNamespace(const DeclContext *Decl) { const DeclContext *getOutermostNamespace(const DeclContext *Decl) {
const DeclContext *Parent = Decl->getParent(); const DeclContext *Parent = Decl->getParent();
if (Parent->isTranslationUnit()) if (Parent->isTranslationUnit())
return Decl; return Decl;
return getOutermostNamespace(Parent); return getOutermostNamespace(Parent);
Show All 32 Linesvoid CalleeNamespaceCheck::check(const MatchFinder::MatchResult &Result) {
diag(UsageSiteExpr->getBeginLoc(), "%0 must resolve to a function declared " diag(UsageSiteExpr->getBeginLoc(), "%0 must resolve to a function declared "
"within the '__llvm_libc' namespace") "within the '__llvm_libc' namespace")
<< FuncDecl; << FuncDecl;
diag(FuncDecl->getLocation(), "resolves to this declaration", diag(FuncDecl->getLocation(), "resolves to this declaration",
clang::DiagnosticIDs::Note); clang::DiagnosticIDs::Note);
} }
} // namespace llvm_libc } // namespace clang::tidy::llvm_libc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/llvmlibc/ImplementationInNamespaceCheck.cpp

//===--- ImplementationInNamespaceCheck.cpp - clang-tidy ------------------===// //===--- ImplementationInNamespaceCheck.cpp - clang-tidy ------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ImplementationInNamespaceCheck.h" #include "ImplementationInNamespaceCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::llvm_libc {
namespace tidy {
namespace llvm_libc {
const static StringRef RequiredNamespace = "__llvm_libc"; const static StringRef RequiredNamespace = "__llvm_libc";
void ImplementationInNamespaceCheck::registerMatchers(MatchFinder *Finder) { void ImplementationInNamespaceCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
decl(hasParent(translationUnitDecl()), unless(linkageSpecDecl())) decl(hasParent(translationUnitDecl()), unless(linkageSpecDecl()))
.bind("child_of_translation_unit"), .bind("child_of_translation_unit"),
this); this);
} }
Show All 12 Lines if (const auto *NS = dyn_cast<NamespaceDecl>(MatchedDecl)) {
} }
return; return;
} }
diag(MatchedDecl->getLocation(), diag(MatchedDecl->getLocation(),
"declaration must be declared within the '%0' namespace") "declaration must be declared within the '%0' namespace")
<< RequiredNamespace; << RequiredNamespace;
} }
} // namespace llvm_libc } // namespace clang::tidy::llvm_libc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/llvmlibc/LLVMLibcTidyModule.cpp

//===--- LLVMLibcTidyModule.cpp - clang-tidy ------------------------------===// //===--- LLVMLibcTidyModule.cpp - clang-tidy ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "CalleeNamespaceCheck.h" #include "CalleeNamespaceCheck.h"
#include "ImplementationInNamespaceCheck.h" #include "ImplementationInNamespaceCheck.h"
#include "RestrictSystemLibcHeadersCheck.h" #include "RestrictSystemLibcHeadersCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace llvm_libc { namespace llvm_libc {
class LLVMLibcModule : public ClangTidyModule { class LLVMLibcModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<CalleeNamespaceCheck>( CheckFactories.registerCheck<CalleeNamespaceCheck>(
"llvmlibc-callee-namespace"); "llvmlibc-callee-namespace");
CheckFactories.registerCheck<ImplementationInNamespaceCheck>( CheckFactories.registerCheck<ImplementationInNamespaceCheck>(
"llvmlibc-implementation-in-namespace"); "llvmlibc-implementation-in-namespace");
CheckFactories.registerCheck<RestrictSystemLibcHeadersCheck>( CheckFactories.registerCheck<RestrictSystemLibcHeadersCheck>(
"llvmlibc-restrict-system-libc-headers"); "llvmlibc-restrict-system-libc-headers");
} }
}; };
// Register the LLVMLibcTidyModule using this statically initialized variable. // Register the LLVMLibcTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<LLVMLibcModule> static ClangTidyModuleRegistry::Add<LLVMLibcModule>
X("llvmlibc-module", "Adds LLVM libc standards checks."); X("llvmlibc-module", "Adds LLVM libc standards checks.");
} // namespace llvm_libc } // namespace llvm_libc
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the LLVMLibcModule. // and thus register the LLVMLibcModule.
volatile int LLVMLibcModuleAnchorSource = 0; volatile int LLVMLibcModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/llvmlibc/RestrictSystemLibcHeadersCheck.cpp

Show All 10 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/HeaderSearch.h" #include "clang/Lex/HeaderSearch.h"
#include "clang/Lex/HeaderSearchOptions.h" #include "clang/Lex/HeaderSearchOptions.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
// FixItHint - Hint to check documentation script to mark this check as // FixItHint - Hint to check documentation script to mark this check as
// providing a FixIt. // providing a FixIt.
namespace clang { namespace clang::tidy::llvm_libc {
namespace tidy {
namespace llvm_libc {
namespace { namespace {
class RestrictedIncludesPPCallbacks class RestrictedIncludesPPCallbacks
: public portability::RestrictedIncludesPPCallbacks { : public portability::RestrictedIncludesPPCallbacks {
public: public:
explicit RestrictedIncludesPPCallbacks( explicit RestrictedIncludesPPCallbacks(
RestrictSystemLibcHeadersCheck &Check, const SourceManager &SM, RestrictSystemLibcHeadersCheck &Check, const SourceManager &SM,
Show All 31 Linesvoid RestrictSystemLibcHeadersCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
SmallString<128> CompilerIncudeDir = SmallString<128> CompilerIncudeDir =
StringRef(PP->getHeaderSearchInfo().getHeaderSearchOpts().ResourceDir); StringRef(PP->getHeaderSearchInfo().getHeaderSearchOpts().ResourceDir);
llvm::sys::path::append(CompilerIncudeDir, "include"); llvm::sys::path::append(CompilerIncudeDir, "include");
PP->addPPCallbacks(std::make_unique<RestrictedIncludesPPCallbacks>( PP->addPPCallbacks(std::make_unique<RestrictedIncludesPPCallbacks>(
*this, SM, CompilerIncudeDir)); *this, SM, CompilerIncudeDir));
} }
} // namespace llvm_libc } // namespace clang::tidy::llvm_libc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/ConfusableIdentifierCheck.cpp

Show All 15 Lines
namespace { namespace {
// Preprocessed version of // Preprocessed version of
// https://www.unicode.org/Public/security/latest/confusables.txt // https://www.unicode.org/Public/security/latest/confusables.txt
// //
// This contains a sorted array of { UTF32 codepoint; UTF32 values[N];} // This contains a sorted array of { UTF32 codepoint; UTF32 values[N];}
#include "Confusables.inc" #include "Confusables.inc"
} // namespace } // namespace
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
ConfusableIdentifierCheck::ConfusableIdentifierCheck(StringRef Name, ConfusableIdentifierCheck::ConfusableIdentifierCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
ConfusableIdentifierCheck::~ConfusableIdentifierCheck() = default; ConfusableIdentifierCheck::~ConfusableIdentifierCheck() = default;
// Build a skeleton out of the Original identifier, inspired by the algorithm // Build a skeleton out of the Original identifier, inspired by the algorithm
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Linesvoid ConfusableIdentifierCheck::check(
} }
} }
void ConfusableIdentifierCheck::registerMatchers( void ConfusableIdentifierCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
Finder->addMatcher(ast_matchers::namedDecl().bind("nameddecl"), this); Finder->addMatcher(ast_matchers::namedDecl().bind("nameddecl"), this);
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.cpp

//===--- ConstCorrectnessCheck.cpp - clang-tidy -----------------*- C++ -*-===// //===--- ConstCorrectnessCheck.cpp - clang-tidy -----------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ConstCorrectnessCheck.h" #include "ConstCorrectnessCheck.h"
#include "../utils/FixItHintUtils.h" #include "../utils/FixItHintUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
namespace { namespace {
// FIXME: This matcher exists in some other code-review as well. // FIXME: This matcher exists in some other code-review as well.
// It should probably move to ASTMatchers. // It should probably move to ASTMatchers.
AST_MATCHER(VarDecl, isLocal) { return Node.isLocalVarDecl(); } AST_MATCHER(VarDecl, isLocal) { return Node.isLocalVarDecl(); }
AST_MATCHER_P(DeclStmt, containsAnyDeclaration, AST_MATCHER_P(DeclStmt, containsAnyDeclaration,
ast_matchers::internal::Matcher<Decl>, InnerMatcher) { ast_matchers::internal::Matcher<Decl>, InnerMatcher) {
return ast_matchers::internal::matchesFirstInPointerRange( return ast_matchers::internal::matchesFirstInPointerRange(
▲ Show 20 Lines • Show All 174 Lines • ▼ Show 20 Lines
void ConstCorrectnessCheck::registerScope(const CompoundStmt *LocalScope, void ConstCorrectnessCheck::registerScope(const CompoundStmt *LocalScope,
ASTContext *Context) { ASTContext *Context) {
auto &Analyzer = ScopesCache[LocalScope]; auto &Analyzer = ScopesCache[LocalScope];
if (!Analyzer) if (!Analyzer)
Analyzer = std::make_unique<ExprMutationAnalyzer>(*LocalScope, *Context); Analyzer = std::make_unique<ExprMutationAnalyzer>(*LocalScope, *Context);
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

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

//===--- DefinitionsInHeadersCheck.cpp - clang-tidy------------------------===// //===--- DefinitionsInHeadersCheck.cpp - clang-tidy------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DefinitionsInHeadersCheck.h" #include "DefinitionsInHeadersCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
namespace { namespace {
AST_MATCHER_P(NamedDecl, usesHeaderFileExtension, utils::FileExtensionsSet, AST_MATCHER_P(NamedDecl, usesHeaderFileExtension, utils::FileExtensionsSet,
HeaderFileExtensions) { HeaderFileExtensions) {
return utils::isExpansionLocInHeaderFile( return utils::isExpansionLocInHeaderFile(
Node.getBeginLoc(), Finder->getASTContext().getSourceManager(), Node.getBeginLoc(), Finder->getASTContext().getSourceManager(),
HeaderFileExtensions); HeaderFileExtensions);
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines if (const auto *FD = dyn_cast<FunctionDecl>(ND)) {
diag(VD->getLocation(), diag(VD->getLocation(),
"variable %0 defined in a header file; " "variable %0 defined in a header file; "
"variable definitions in header files can lead to ODR violations") "variable definitions in header files can lead to ODR violations")
<< VD; << VD;
} }
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

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

Show All 23 Lines
#include "ThrowByValueCatchByReferenceCheck.h" #include "ThrowByValueCatchByReferenceCheck.h"
#include "UnconventionalAssignOperatorCheck.h" #include "UnconventionalAssignOperatorCheck.h"
#include "UniqueptrResetReleaseCheck.h" #include "UniqueptrResetReleaseCheck.h"
#include "UnusedAliasDeclsCheck.h" #include "UnusedAliasDeclsCheck.h"
#include "UnusedParametersCheck.h" #include "UnusedParametersCheck.h"
#include "UnusedUsingDeclsCheck.h" #include "UnusedUsingDeclsCheck.h"
#include "UseAnonymousNamespaceCheck.h" #include "UseAnonymousNamespaceCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace misc { namespace misc {
class MiscModule : public ClangTidyModule { class MiscModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<ConfusableIdentifierCheck>( CheckFactories.registerCheck<ConfusableIdentifierCheck>(
"misc-confusable-identifiers"); "misc-confusable-identifiers");
CheckFactories.registerCheck<ConstCorrectnessCheck>( CheckFactories.registerCheck<ConstCorrectnessCheck>(
Show All 37 Lines
// Register the MiscTidyModule using this statically initialized variable. // Register the MiscTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<misc::MiscModule> 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 // This anchor is used to force the linker to link in the generated object file
// and thus register the MiscModule. // and thus register the MiscModule.
volatile int MiscModuleAnchorSource = 0; volatile int MiscModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/MisleadingIdentifier.cpp

//===--- MisleadingIdentifier.cpp - clang-tidy-----------------------------===// //===--- MisleadingIdentifier.cpp - clang-tidy-----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MisleadingIdentifier.h" #include "MisleadingIdentifier.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "llvm/Support/ConvertUTF.h" #include "llvm/Support/ConvertUTF.h"
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
// See https://www.unicode.org/Public/14.0.0/ucd/extracted/DerivedBidiClass.txt // See https://www.unicode.org/Public/14.0.0/ucd/extracted/DerivedBidiClass.txt
static bool isUnassignedAL(llvm::UTF32 CP) { static bool isUnassignedAL(llvm::UTF32 CP) {
return (0x0600 <= CP && CP <= 0x07BF) || (0x0860 <= CP && CP <= 0x08FF) || return (0x0600 <= CP && CP <= 0x07BF) || (0x0860 <= CP && CP <= 0x08FF) ||
(0xFB50 <= CP && CP <= 0xFDCF) || (0xFDF0 <= CP && CP <= 0xFDFF) || (0xFB50 <= CP && CP <= 0xFDCF) || (0xFDF0 <= CP && CP <= 0xFDFF) ||
(0xFE70 <= CP && CP <= 0xFEFF) || (0xFE70 <= CP && CP <= 0xFEFF) ||
(0x00010D00 <= CP && CP <= 0x00010D3F) || (0x00010D00 <= CP && CP <= 0x00010D3F) ||
(0x00010F30 <= CP && CP <= 0x00010F6F) || (0x00010F30 <= CP && CP <= 0x00010F6F) ||
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Linesvoid MisleadingIdentifierCheck::check(
} }
} }
void MisleadingIdentifierCheck::registerMatchers( void MisleadingIdentifierCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
Finder->addMatcher(ast_matchers::namedDecl().bind("nameddecl"), this); Finder->addMatcher(ast_matchers::namedDecl().bind("nameddecl"), this);
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/MisplacedConstCheck.cpp

//===--- MisplacedConstCheck.cpp - clang-tidy------------------------------===// //===--- MisplacedConstCheck.cpp - clang-tidy------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MisplacedConstCheck.h" #include "MisplacedConstCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
void MisplacedConstCheck::registerMatchers(MatchFinder *Finder) { void MisplacedConstCheck::registerMatchers(MatchFinder *Finder) {
auto NonConstAndNonFunctionPointerType = hasType(pointerType(unless( auto NonConstAndNonFunctionPointerType = hasType(pointerType(unless(
pointee(anyOf(isConstQualified(), ignoringParens(functionType())))))); pointee(anyOf(isConstQualified(), ignoringParens(functionType()))))));
Finder->addMatcher( Finder->addMatcher(
valueDecl(hasType(qualType( valueDecl(hasType(qualType(
isConstQualified(), isConstQualified(),
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesvoid MisplacedConstCheck::check(const MatchFinder::MatchResult &Result) {
diag(Var->getLocation(), "%0 declared with a const-qualified %1; " diag(Var->getLocation(), "%0 declared with a const-qualified %1; "
"results in the type being '%2' instead of '%3'") "results in the type being '%2' instead of '%3'")
<< Var << AliasType << CanQT.getAsString(Ctx.getPrintingPolicy()) << Var << AliasType << CanQT.getAsString(Ctx.getPrintingPolicy())
<< guessAlternateQualification(Ctx, CanQT) << guessAlternateQualification(Ctx, CanQT)
.getAsString(Ctx.getPrintingPolicy()); .getAsString(Ctx.getPrintingPolicy());
diag(AliasLoc, "%0 declared here", DiagnosticIDs::Note) << AliasType; diag(AliasLoc, "%0 declared here", DiagnosticIDs::Note) << AliasType;
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

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

//===--- NewDeleteOverloadsCheck.cpp - clang-tidy--------------------------===// //===--- NewDeleteOverloadsCheck.cpp - clang-tidy--------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NewDeleteOverloadsCheck.h" #include "NewDeleteOverloadsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
namespace { namespace {
AST_MATCHER(FunctionDecl, isPlacementOverload) { AST_MATCHER(FunctionDecl, isPlacementOverload) {
bool New; bool New;
switch (Node.getOverloadedOperator()) { switch (Node.getOverloadedOperator()) {
default: default:
return false; return false;
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Linesvoid NewDeleteOverloadsCheck::onEndOfTranslationUnit() {
} }
for (const auto *FD : Diagnose) for (const auto *FD : Diagnose)
diag(FD->getLocation(), "declaration of %0 has no matching declaration " diag(FD->getLocation(), "declaration of %0 has no matching declaration "
"of '%1' at the same scope") "of '%1' at the same scope")
<< FD << getOperatorName(getCorrespondingOverload(FD)); << FD << getOperatorName(getCorrespondingOverload(FD));
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/NoRecursionCheck.cpp

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Analysis/CallGraph.h" #include "clang/Analysis/CallGraph.h"
#include "llvm/ADT/DenseMapInfo.h" #include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/SCCIterator.h" #include "llvm/ADT/SCCIterator.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
namespace { namespace {
/// Much like SmallSet, with two differences: /// Much like SmallSet, with two differences:
/// 1. It can *only* be constructed from an ArrayRef<>. If the element count /// 1. It can *only* be constructed from an ArrayRef<>. If the element count
/// is small, there is no copy and said storage *must* outlive us. /// is small, there is no copy and said storage *must* outlive us.
/// 2. it is immutable, the way it was constructed it will stay. /// 2. it is immutable, the way it was constructed it will stay.
template <typename T, unsigned SmallSize> class ImmutableSmallSet { template <typename T, unsigned SmallSize> class ImmutableSmallSet {
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines for (llvm::scc_iterator<CallGraph *> SCCI = llvm::scc_begin(&CG),
SCCE = llvm::scc_end(&CG); SCCE = llvm::scc_end(&CG);
SCCI != SCCE; ++SCCI) { SCCI != SCCE; ++SCCI) {
if (!SCCI.hasCycle()) // We only care about cycles, not standalone nodes. if (!SCCI.hasCycle()) // We only care about cycles, not standalone nodes.
continue; continue;
handleSCC(*SCCI); handleSCC(*SCCI);
} }
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/NonCopyableObjects.cpp

//===--- NonCopyableObjects.cpp - clang-tidy-------------------------------===// //===--- NonCopyableObjects.cpp - clang-tidy-------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NonCopyableObjects.h" #include "NonCopyableObjects.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <algorithm> #include <algorithm>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
void NonCopyableObjectsCheck::registerMatchers(MatchFinder *Finder) { void NonCopyableObjectsCheck::registerMatchers(MatchFinder *Finder) {
// There are two ways to get into trouble with objects like FILE *: // There are two ways to get into trouble with objects like FILE *:
// dereferencing the pointer type to be a non-pointer type, and declaring // dereferencing the pointer type to be a non-pointer type, and declaring
// the type as a non-pointer type in the first place. While the declaration // the type as a non-pointer type in the first place. While the declaration
// itself could technically be well-formed in the case where the type is not // itself could technically be well-formed in the case where the type is not
// an opaque type, it's highly suspicious behavior. // an opaque type, it's highly suspicious behavior.
// //
Show All 35 Lines diag(D->getLocation(), "%0 declared as type '%1', which is unsafe to copy"
<< D << BD->getName(); << D << BD->getName();
else if (E) else if (E)
diag(E->getExprLoc(), diag(E->getExprLoc(),
"expression has opaque data structure type %0; type should only be " "expression has opaque data structure type %0; type should only be "
"used as a pointer and not dereferenced") "used as a pointer and not dereferenced")
<< BD; << BD;
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/NonPrivateMemberVariablesInClassesCheck.cpp

//===--- NonPrivateMemberVariablesInClassesCheck.cpp - clang-tidy ---------===// //===--- NonPrivateMemberVariablesInClassesCheck.cpp - clang-tidy ---------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NonPrivateMemberVariablesInClassesCheck.h" #include "NonPrivateMemberVariablesInClassesCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
namespace { namespace {
AST_MATCHER(CXXRecordDecl, hasMethods) { AST_MATCHER(CXXRecordDecl, hasMethods) {
return std::distance(Node.method_begin(), Node.method_end()) != 0; return std::distance(Node.method_begin(), Node.method_end()) != 0;
} }
AST_MATCHER(CXXRecordDecl, hasNonStaticNonImplicitMethod) { AST_MATCHER(CXXRecordDecl, hasNonStaticNonImplicitMethod) {
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesvoid NonPrivateMemberVariablesInClassesCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *Field = Result.Nodes.getNodeAs<FieldDecl>("field"); const auto *Field = Result.Nodes.getNodeAs<FieldDecl>("field");
assert(Field && "We should have the field we are going to complain about"); assert(Field && "We should have the field we are going to complain about");
diag(Field->getLocation(), "member variable %0 has %1 visibility") diag(Field->getLocation(), "member variable %0 has %1 visibility")
<< Field << Field->getAccess(); << Field << Field->getAccess();
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/RedundantExpressionCheck.cpp

Show All 26 Lines
#include <cstdint> #include <cstdint>
#include <optional> #include <optional>
#include <string> #include <string>
#include <vector> #include <vector>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::tidy::matchers; using namespace clang::tidy::matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
namespace { namespace {
using llvm::APSInt; using llvm::APSInt;
static constexpr llvm::StringLiteral KnownBannedMacroNames[] = { static constexpr llvm::StringLiteral KnownBannedMacroNames[] = {
"EAGAIN", "EAGAIN",
"EWOULDBLOCK", "EWOULDBLOCK",
"SIGCLD", "SIGCLD",
"SIGCHLD", "SIGCHLD",
▲ Show 20 Lines • Show All 1,306 Lines • ▼ Show 20 Linesvoid RedundantExpressionCheck::check(const MatchFinder::MatchResult &Result) {
// - "comparisons-of-symbol-and-const", // - "comparisons-of-symbol-and-const",
// Produced messages: // Produced messages:
// -> "equivalent expression on both sides of logical operator", // -> "equivalent expression on both sides of logical operator",
// -> "logical expression is always false/true" // -> "logical expression is always false/true"
// -> "expression is redundant" // -> "expression is redundant"
checkRelationalExpr(Result); checkRelationalExpr(Result);
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp

Show All 14 Lines
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include <optional> #include <optional>
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
StaticAssertCheck::StaticAssertCheck(StringRef Name, ClangTidyContext *Context) StaticAssertCheck::StaticAssertCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void StaticAssertCheck::registerMatchers(MatchFinder *Finder) { void StaticAssertCheck::registerMatchers(MatchFinder *Finder) {
auto NegatedString = unaryOperator( auto NegatedString = unaryOperator(
hasOperatorName("!"), hasUnaryOperand(ignoringImpCasts(stringLiteral()))); hasOperatorName("!"), hasUnaryOperand(ignoringImpCasts(stringLiteral())));
auto IsAlwaysFalse = auto IsAlwaysFalse =
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines if (Token.is(tok::l_paren))
++ParenCount; ++ParenCount;
else if (Token.is(tok::r_paren)) else if (Token.is(tok::r_paren))
--ParenCount; --ParenCount;
} }
return Token.getLocation(); return Token.getLocation();
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

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

//===--- ThrowByValueCatchByReferenceCheck.cpp - clang-tidy----------------===// //===--- ThrowByValueCatchByReferenceCheck.cpp - clang-tidy----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ThrowByValueCatchByReferenceCheck.h" #include "ThrowByValueCatchByReferenceCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/OperationKinds.h" #include "clang/AST/OperationKinds.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
ThrowByValueCatchByReferenceCheck::ThrowByValueCatchByReferenceCheck( ThrowByValueCatchByReferenceCheck::ThrowByValueCatchByReferenceCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
CheckAnonymousTemporaries(Options.get("CheckThrowTemporaries", true)), CheckAnonymousTemporaries(Options.get("CheckThrowTemporaries", true)),
WarnOnLargeObject(Options.get("WarnOnLargeObject", false)), WarnOnLargeObject(Options.get("WarnOnLargeObject", false)),
// Cannot access `ASTContext` from here so set it to an extremal value. // Cannot access `ASTContext` from here so set it to an extremal value.
MaxSizeOptions( MaxSizeOptions(
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Lines if (!CaughtType.isTrivialType(Context)) {
if (MaxSize == std::numeric_limits<uint64_t>::max()) if (MaxSize == std::numeric_limits<uint64_t>::max())
MaxSize = Context.getTypeSize(Context.getSizeType()); MaxSize = Context.getTypeSize(Context.getSizeType());
if (Context.getTypeSize(CaughtType) > MaxSize) if (Context.getTypeSize(CaughtType) > MaxSize)
diag(VarDecl->getBeginLoc(), DiagMsgCatchReference); diag(VarDecl->getBeginLoc(), DiagMsgCatchReference);
} }
} }
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

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

//===--- UnconventionalAssignOperatorCheck.cpp - clang-tidy -----*- C++ -*-===// //===--- UnconventionalAssignOperatorCheck.cpp - clang-tidy -----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnconventionalAssignOperatorCheck.h" #include "UnconventionalAssignOperatorCheck.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
void UnconventionalAssignOperatorCheck::registerMatchers( void UnconventionalAssignOperatorCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
const auto HasGoodReturnType = const auto HasGoodReturnType =
cxxMethodDecl(returns(hasCanonicalType(lValueReferenceType(pointee( cxxMethodDecl(returns(hasCanonicalType(lValueReferenceType(pointee(
unless(isConstQualified()), unless(isConstQualified()),
anyOf(autoType(), hasDeclaration(equalsBoundNode("class")))))))); anyOf(autoType(), hasDeclaration(equalsBoundNode("class"))))))));
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines if (Result.Nodes.getNodeAs<CXXMethodDecl>("ArgumentType"))
<< Method->getParent()->getName() << getLangOpts().CPlusPlus11; << Method->getParent()->getName() << getLangOpts().CPlusPlus11;
if (Result.Nodes.getNodeAs<CXXMethodDecl>("cv")) if (Result.Nodes.getNodeAs<CXXMethodDecl>("cv"))
diag(Method->getBeginLoc(), diag(Method->getBeginLoc(),
"operator=() should not be marked '%select{const|virtual}0'") "operator=() should not be marked '%select{const|virtual}0'")
<< !Method->isConst(); << !Method->isConst();
} }
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

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

//===--- UniqueptrResetReleaseCheck.cpp - clang-tidy ----------------------===// //===--- UniqueptrResetReleaseCheck.cpp - clang-tidy ----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UniqueptrResetReleaseCheck.h" #include "UniqueptrResetReleaseCheck.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
UniqueptrResetReleaseCheck::UniqueptrResetReleaseCheck( UniqueptrResetReleaseCheck::UniqueptrResetReleaseCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
Inserter(Options.getLocalOrGlobal("IncludeStyle", Inserter(Options.getLocalOrGlobal("IncludeStyle",
utils::IncludeSorter::IS_LLVM), utils::IncludeSorter::IS_LLVM),
areDiagsSelfContained()) {} areDiagsSelfContained()) {}
▲ Show 20 Lines • Show All 117 Lines • ▼ Show 20 Lines << FixItHint::CreateReplacement(
CharSourceRange::getTokenRange(ReleaseMember->getOperatorLoc(), CharSourceRange::getTokenRange(ReleaseMember->getOperatorLoc(),
ResetCall->getEndLoc()), ResetCall->getEndLoc()),
TrailingText); TrailingText);
if (NeedsUtilityInclude) if (NeedsUtilityInclude)
D << Inserter.createIncludeInsertion( D << Inserter.createIncludeInsertion(
Result.SourceManager->getFileID(ResetMember->getBeginLoc()), Result.SourceManager->getFileID(ResetMember->getBeginLoc()),
"<utility>"); "<utility>");
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/UnusedAliasDeclsCheck.cpp

//===--- UnusedAliasDeclsCheck.cpp - clang-tidy----------------------------===// //===--- UnusedAliasDeclsCheck.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnusedAliasDeclsCheck.h" #include "UnusedAliasDeclsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
void UnusedAliasDeclsCheck::registerMatchers(MatchFinder *Finder) { void UnusedAliasDeclsCheck::registerMatchers(MatchFinder *Finder) {
// We cannot do anything about headers (yet), as the alias declarations // We cannot do anything about headers (yet), as the alias declarations
// used in one header could be used by some other translation unit. // used in one header could be used by some other translation unit.
Finder->addMatcher(namespaceAliasDecl(isExpansionInMainFile()).bind("alias"), Finder->addMatcher(namespaceAliasDecl(isExpansionInMainFile()).bind("alias"),
this); this);
Finder->addMatcher(nestedNameSpecifier().bind("nns"), this); Finder->addMatcher(nestedNameSpecifier().bind("nns"), this);
} }
Show All 21 Linesvoid UnusedAliasDeclsCheck::onEndOfTranslationUnit() {
for (const auto &FoundDecl : FoundDecls) { for (const auto &FoundDecl : FoundDecls) {
if (!FoundDecl.second.isValid()) if (!FoundDecl.second.isValid())
continue; continue;
diag(FoundDecl.first->getLocation(), "namespace alias decl %0 is unused") diag(FoundDecl.first->getLocation(), "namespace alias decl %0 is unused")
<< FoundDecl.first << FixItHint::CreateRemoval(FoundDecl.second); << FoundDecl.first << FixItHint::CreateRemoval(FoundDecl.second);
} }
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

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

Show All 12 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include <unordered_map> #include <unordered_map>
#include <unordered_set> #include <unordered_set>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
namespace { namespace {
bool isOverrideMethod(const FunctionDecl *Function) { bool isOverrideMethod(const FunctionDecl *Function) {
if (const auto *MD = dyn_cast<CXXMethodDecl>(Function)) if (const auto *MD = dyn_cast<CXXMethodDecl>(Function))
return MD->size_overridden_methods() > 0 || MD->hasAttr<OverrideAttr>(); return MD->size_overridden_methods() > 0 || MD->hasAttr<OverrideAttr>();
return false; return false;
} }
} // namespace } // namespace
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Lines if (StrictMode ||
(Function->getBody()->child_begin() != (Function->getBody()->child_begin() !=
Function->getBody()->child_end()) || Function->getBody()->child_end()) ||
(isa<CXXConstructorDecl>(Function) && (isa<CXXConstructorDecl>(Function) &&
cast<CXXConstructorDecl>(Function)->getNumCtorInitializers() > 0)) cast<CXXConstructorDecl>(Function)->getNumCtorInitializers() > 0))
warnOnUnusedParameter(Result, Function, I); warnOnUnusedParameter(Result, Function, I);
} }
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

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

//===--- UnusedUsingDeclsCheck.cpp - clang-tidy----------------------------===// //===--- UnusedUsingDeclsCheck.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnusedUsingDeclsCheck.h" #include "UnusedUsingDeclsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
namespace { namespace {
AST_MATCHER_P(DeducedTemplateSpecializationType, refsToTemplatedDecl, AST_MATCHER_P(DeducedTemplateSpecializationType, refsToTemplatedDecl,
clang::ast_matchers::internal::Matcher<NamedDecl>, DeclMatcher) { clang::ast_matchers::internal::Matcher<NamedDecl>, DeclMatcher) {
if (const auto *TD = Node.getTemplateName().getAsTemplateDecl()) if (const auto *TD = Node.getTemplateName().getAsTemplateDecl())
return DeclMatcher.matches(*TD, Finder, Builder); return DeclMatcher.matches(*TD, Finder, Builder);
return false; return false;
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines if (!Context.IsUsed) {
diag(Context.FoundUsingDecl->getLocation(), diag(Context.FoundUsingDecl->getLocation(),
/*Description=*/"remove the using", DiagnosticIDs::Note) /*Description=*/"remove the using", DiagnosticIDs::Note)
<< FixItHint::CreateRemoval(Context.UsingDeclRange); << FixItHint::CreateRemoval(Context.UsingDeclRange);
} }
} }
Contexts.clear(); Contexts.clear();
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/misc/UseAnonymousNamespaceCheck.cpp

//===--- UseAnonymousNamespaceCheck.cpp - clang-tidy ----------------------===// //===--- UseAnonymousNamespaceCheck.cpp - clang-tidy ----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseAnonymousNamespaceCheck.h" #include "UseAnonymousNamespaceCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::misc {
namespace tidy {
namespace misc {
namespace { namespace {
AST_POLYMORPHIC_MATCHER_P(isInHeaderFile, AST_POLYMORPHIC_MATCHER_P(isInHeaderFile,
AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl,
VarDecl), VarDecl),
utils::FileExtensionsSet, HeaderFileExtensions) { utils::FileExtensionsSet, HeaderFileExtensions) {
return utils::isExpansionLocInHeaderFile( return utils::isExpansionLocInHeaderFile(
Node.getBeginLoc(), Finder->getASTContext().getSourceManager(), Node.getBeginLoc(), Finder->getASTContext().getSourceManager(),
HeaderFileExtensions); HeaderFileExtensions);
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Linesvoid UseAnonymousNamespaceCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *MatchedDecl = Result.Nodes.getNodeAs<NamedDecl>("x")) { if (const auto *MatchedDecl = Result.Nodes.getNodeAs<NamedDecl>("x")) {
StringRef Type = llvm::isa<VarDecl>(MatchedDecl) ? "variable" : "function"; StringRef Type = llvm::isa<VarDecl>(MatchedDecl) ? "variable" : "function";
diag(MatchedDecl->getLocation(), diag(MatchedDecl->getLocation(),
"%0 %1 declared 'static', move to anonymous namespace instead") "%0 %1 declared 'static', move to anonymous namespace instead")
<< Type << MatchedDecl; << Type << MatchedDecl;
} }
} }
} // namespace misc } // namespace clang::tidy::misc
} // namespace tidy
} // namespace clang

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

Show All 23 Lines
#include "llvm/Support/Regex.h" #include "llvm/Support/Regex.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <algorithm> #include <algorithm>
#include <cstddef> #include <cstddef>
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
enum BindArgumentKind { BK_Temporary, BK_Placeholder, BK_CallExpr, BK_Other }; enum BindArgumentKind { BK_Temporary, BK_Placeholder, BK_CallExpr, BK_Other };
enum CaptureMode { CM_None, CM_ByRef, CM_ByValue }; enum CaptureMode { CM_None, CM_ByRef, CM_ByValue };
enum CaptureExpr { CE_None, CE_Var, CE_InitExpression }; enum CaptureExpr { CE_None, CE_Var, CE_InitExpression };
enum CallableType { enum CallableType {
▲ Show 20 Lines • Show All 669 Lines • ▼ Show 20 Linesvoid AvoidBindCheck::check(const MatchFinder::MatchResult &Result) {
addFunctionCallArgs(getForwardedArgumentList(LP), Stream); addFunctionCallArgs(getForwardedArgumentList(LP), Stream);
Stream << "); }"; Stream << "); }";
Diag << FixItHint::CreateReplacement(MatchedDecl->getSourceRange(), Diag << FixItHint::CreateReplacement(MatchedDecl->getSourceRange(),
Stream.str()); Stream.str());
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp

Show All 32 Lines
AST_MATCHER(clang::ParmVarDecl, isArgvOfMain) { AST_MATCHER(clang::ParmVarDecl, isArgvOfMain) {
const clang::DeclContext *DC = Node.getDeclContext(); const clang::DeclContext *DC = Node.getDeclContext();
const auto *FD = llvm::dyn_cast<clang::FunctionDecl>(DC); const auto *FD = llvm::dyn_cast<clang::FunctionDecl>(DC);
return FD ? FD->isMain() : false; return FD ? FD->isMain() : false;
} }
} // namespace } // namespace
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) { void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
typeLoc(hasValidBeginLoc(), hasType(arrayType()), typeLoc(hasValidBeginLoc(), hasType(arrayType()),
unless(anyOf(hasParent(parmVarDecl(isArgvOfMain())), unless(anyOf(hasParent(parmVarDecl(isArgvOfMain())),
hasParent(varDecl(isExternC())), hasParent(varDecl(isExternC())),
hasParent(fieldDecl( hasParent(fieldDecl(
hasParent(recordDecl(isExternCContext())))), hasParent(recordDecl(isExternCContext())))),
hasAncestor(functionDecl(isExternC()))))) hasAncestor(functionDecl(isExternC())))))
.bind("typeloc"), .bind("typeloc"),
this); this);
} }
void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) { void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc"); const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
diag(ArrayType->getBeginLoc(), diag(ArrayType->getBeginLoc(),
"do not declare %select{C-style|C VLA}0 arrays, use " "do not declare %select{C-style|C VLA}0 arrays, use "
"%select{std::array<>|std::vector<>}0 instead") "%select{std::array<>|std::vector<>}0 instead")
<< ArrayType->getTypePtr()->isVariableArrayType(); << ArrayType->getTypePtr()->isVariableArrayType();
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/ConcatNestedNamespacesCheck.cpp

//===--- ConcatNestedNamespacesCheck.cpp - clang-tidy----------------------===// //===--- ConcatNestedNamespacesCheck.cpp - clang-tidy----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ConcatNestedNamespacesCheck.h" #include "ConcatNestedNamespacesCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include <algorithm> #include <algorithm>
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
static bool locationsInSameFile(const SourceManager &Sources, static bool locationsInSameFile(const SourceManager &Sources,
SourceLocation Loc1, SourceLocation Loc2) { SourceLocation Loc1, SourceLocation Loc2) {
return Loc1.isFileID() && Loc2.isFileID() && return Loc1.isFileID() && Loc2.isFileID() &&
Sources.getFileID(Loc1) == Sources.getFileID(Loc2); Sources.getFileID(Loc1) == Sources.getFileID(Loc2);
} }
static bool anonymousOrInlineNamespace(const NamespaceDecl &ND) { static bool anonymousOrInlineNamespace(const NamespaceDecl &ND) {
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Linesvoid ConcatNestedNamespacesCheck::check(
if (!alreadyConcatenated(Namespaces.size(), FrontReplacement, Sources, if (!alreadyConcatenated(Namespaces.size(), FrontReplacement, Sources,
getLangOpts())) getLangOpts()))
reportDiagnostic(FrontReplacement, BackReplacement); reportDiagnostic(FrontReplacement, BackReplacement);
Namespaces.clear(); Namespaces.clear();
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/DeprecatedHeadersCheck.cpp

Show All 13 Lines
#include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringSet.h" #include "llvm/ADT/StringSet.h"
#include <algorithm> #include <algorithm>
#include <vector> #include <vector>
using IncludeMarker = using IncludeMarker =
clang::tidy::modernize::DeprecatedHeadersCheck::IncludeMarker; clang::tidy::modernize::DeprecatedHeadersCheck::IncludeMarker;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
class IncludeModernizePPCallbacks : public PPCallbacks { class IncludeModernizePPCallbacks : public PPCallbacks {
public: public:
explicit IncludeModernizePPCallbacks( explicit IncludeModernizePPCallbacks(
std::vector<IncludeMarker> &IncludesToBeProcessed, LangOptions LangOpts, std::vector<IncludeMarker> &IncludesToBeProcessed, LangOptions LangOpts,
const SourceManager &SM, bool CheckHeaderFile); const SourceManager &SM, bool CheckHeaderFile);
▲ Show 20 Lines • Show All 173 Lines • ▼ Show 20 Lines IncludesToBeProcessed.push_back(
FilenameRange.getAsRange(), DiagLoc}); FilenameRange.getAsRange(), DiagLoc});
} else if (DeleteHeaders.count(FileName) != 0) { } else if (DeleteHeaders.count(FileName) != 0) {
IncludesToBeProcessed.push_back( IncludesToBeProcessed.push_back(
IncludeMarker{std::string{}, FileName, IncludeMarker{std::string{}, FileName,
SourceRange{HashLoc, FilenameRange.getEnd()}, DiagLoc}); SourceRange{HashLoc, FilenameRange.getEnd()}, DiagLoc});
} }
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/DeprecatedIosBaseAliasesCheck.cpp

//===--- DeprecatedIosBaseAliasesCheck.cpp - clang-tidy--------------------===// //===--- DeprecatedIosBaseAliasesCheck.cpp - clang-tidy--------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DeprecatedIosBaseAliasesCheck.h" #include "DeprecatedIosBaseAliasesCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
static constexpr std::array<StringRef, 5> DeprecatedTypes = { static constexpr std::array<StringRef, 5> DeprecatedTypes = {
"::std::ios_base::io_state", "::std::ios_base::open_mode", "::std::ios_base::io_state", "::std::ios_base::open_mode",
"::std::ios_base::seek_dir", "::std::ios_base::streamoff", "::std::ios_base::seek_dir", "::std::ios_base::streamoff",
"::std::ios_base::streampos"}; "::std::ios_base::streampos"};
static std::optional<const char *> getReplacementType(StringRef Type) { static std::optional<const char *> getReplacementType(StringRef Type) {
return llvm::StringSwitch<std::optional<const char *>>(Type) return llvm::StringSwitch<std::optional<const char *>>(Type)
Show All 40 Lines if (Replacement) {
if (Fix) if (Fix)
Builder << FixItHint::CreateReplacement(SourceRange(IoStateLoc, EndLoc), Builder << FixItHint::CreateReplacement(SourceRange(IoStateLoc, EndLoc),
FixName); FixName);
} else } else
diag(IoStateLoc, "'std::ios_base::%0' is deprecated") << TypeName; diag(IoStateLoc, "'std::ios_base::%0' is deprecated") << TypeName;
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/IntegralLiteralExpressionMatcher.cpp

//===--- IntegralLiteralExpressionMatcher.cpp - clang-tidy ----------------===// //===--- IntegralLiteralExpressionMatcher.cpp - clang-tidy ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "IntegralLiteralExpressionMatcher.h" #include "IntegralLiteralExpressionMatcher.h"
#include <algorithm> #include <algorithm>
#include <cctype> #include <cctype>
#include <stdexcept> #include <stdexcept>
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
// Validate that this literal token is a valid integer literal. A literal token // Validate that this literal token is a valid integer literal. A literal token
// could be a floating-point token, which isn't acceptable as a value for an // could be a floating-point token, which isn't acceptable as a value for an
// enumeration. A floating-point token must either have a decimal point or an // enumeration. A floating-point token must either have a decimal point or an
// exponent ('E' or 'P'). // exponent ('E' or 'P').
static bool isIntegralConstant(const Token &Token) { static bool isIntegralConstant(const Token &Token) {
const char *Begin = Token.getLiteralData(); const char *Begin = Token.getLiteralData();
const char *End = Begin + Token.getLength(); const char *End = Begin + Token.getLength();
▲ Show 20 Lines • Show All 254 Lines • ▼ Show 20 Linesbool IntegralLiteralExpressionMatcher::match() {
// comma operators are only valid initializers when used inside parentheses. // comma operators are only valid initializers when used inside parentheses.
return conditionalExpr() && Current == End; return conditionalExpr() && Current == End;
} }
LiteralSize IntegralLiteralExpressionMatcher::largestLiteralSize() const { LiteralSize IntegralLiteralExpressionMatcher::largestLiteralSize() const {
return LargestSize; return LargestSize;
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp

Show All 21 Lines
#include <cassert> #include <cassert>
#include <cstring> #include <cstring>
#include <optional> #include <optional>
#include <utility> #include <utility>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace llvm; using namespace llvm;
namespace clang { namespace clang::tidy {
namespace tidy {
template <> struct OptionEnumMapping<modernize::Confidence::Level> { template <> struct OptionEnumMapping<modernize::Confidence::Level> {
static llvm::ArrayRef<std::pair<modernize::Confidence::Level, StringRef>> static llvm::ArrayRef<std::pair<modernize::Confidence::Level, StringRef>>
getEnumMapping() { getEnumMapping() {
static constexpr std::pair<modernize::Confidence::Level, StringRef> static constexpr std::pair<modernize::Confidence::Level, StringRef>
Mapping[] = {{modernize::Confidence::CL_Reasonable, "reasonable"}, Mapping[] = {{modernize::Confidence::CL_Reasonable, "reasonable"},
{modernize::Confidence::CL_Safe, "safe"}, {modernize::Confidence::CL_Safe, "safe"},
{modernize::Confidence::CL_Risky, "risky"}}; {modernize::Confidence::CL_Risky, "risky"}};
▲ Show 20 Lines • Show All 925 Lines • ▼ Show 20 Lines if (!ReverseHeader.empty())
return ReverseHeader; return ReverseHeader;
if (UseReverseRanges && ReverseFunction.empty()) { if (UseReverseRanges && ReverseFunction.empty()) {
return "<ranges>"; return "<ranges>";
} }
return ""; return "";
} }
} // namespace modernize } // namespace modernize
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/LoopConvertUtils.cpp

Show All 21 Lines
#include <cassert> #include <cassert>
#include <cstddef> #include <cstddef>
#include <optional> #include <optional>
#include <string> #include <string>
#include <utility> #include <utility>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
/// Tracks a stack of parent statements during traversal. /// Tracks a stack of parent statements during traversal.
/// ///
/// All this really does is inject push_back() before running /// All this really does is inject push_back() before running
/// RecursiveASTVisitor::TraverseStmt() and pop_back() afterwards. The Stmt atop /// RecursiveASTVisitor::TraverseStmt() and pop_back() afterwards. The Stmt atop
/// the stack is the parent of the current statement (NULL for the topmost /// the stack is the parent of the current statement (NULL for the topmost
/// statement). /// statement).
bool StmtAncestorASTVisitor::TraverseStmt(Stmt *Statement) { bool StmtAncestorASTVisitor::TraverseStmt(Stmt *Statement) {
▲ Show 20 Lines • Show All 865 Lines • ▼ Show 20 Linesbool VariableNamer::declarationExists(StringRef Symbol) {
// StoredDeclsMap is not initialized (i.e. LookupPtr.getInt() is false inside // StoredDeclsMap is not initialized (i.e. LookupPtr.getInt() is false inside
// of DeclContext::lookup()). Why is this? // of DeclContext::lookup()). Why is this?
// Finally, determine if the symbol was used in the loop or a child context. // Finally, determine if the symbol was used in the loop or a child context.
DeclFinderASTVisitor DeclFinder(std::string(Symbol), GeneratedDecls); DeclFinderASTVisitor DeclFinder(std::string(Symbol), GeneratedDecls);
return DeclFinder.findUsages(SourceStmt); return DeclFinder.findUsages(SourceStmt);
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/MacroToEnumCheck.cpp

Show All 12 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include <algorithm> #include <algorithm>
#include <cassert> #include <cassert>
#include <cctype> #include <cctype>
#include <string> #include <string>
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
static bool hasOnlyComments(SourceLocation Loc, const LangOptions &Options, static bool hasOnlyComments(SourceLocation Loc, const LangOptions &Options,
StringRef Text) { StringRef Text) {
// Use a lexer to look for tokens; if we find something other than a single // Use a lexer to look for tokens; if we find something other than a single
// hash, then there were intervening tokens between macro definitions. // hash, then there were intervening tokens between macro definitions.
std::string Buffer{Text}; std::string Buffer{Text};
Lexer Lex(Loc, Options, Buffer.c_str(), Buffer.c_str(), Lexer Lex(Loc, Options, Buffer.c_str(), Buffer.c_str(),
Buffer.c_str() + Buffer.size()); Buffer.c_str() + Buffer.size());
▲ Show 20 Lines • Show All 519 Lines • ▼ Show 20 Lines if (TemplateFn->isThisDeclarationADefinition() && TemplateFn->hasBody())
Range = SourceRange{TemplateFn->getBeginLoc(), Range = SourceRange{TemplateFn->getBeginLoc(),
TemplateFn->getUnderlyingDecl()->getBodyRBrace()}; TemplateFn->getUnderlyingDecl()->getBodyRBrace()};
} }
if (isValid(Range) && !empty(Range)) if (isValid(Range) && !empty(Range))
PPCallback->invalidateRange(Range); PPCallback->invalidateRange(Range);
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/MakeSharedCheck.cpp

//===--- MakeSharedCheck.cpp - clang-tidy----------------------------------===// //===--- MakeSharedCheck.cpp - clang-tidy----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MakeSharedCheck.h" #include "MakeSharedCheck.h"
// FixItHint - Hint to check documentation script to mark this check as // FixItHint - Hint to check documentation script to mark this check as
// providing a FixIt. // providing a FixIt.
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
MakeSharedCheck::MakeSharedCheck(StringRef Name, ClangTidyContext *Context) MakeSharedCheck::MakeSharedCheck(StringRef Name, ClangTidyContext *Context)
: MakeSmartPtrCheck(Name, Context, "std::make_shared") {} : MakeSmartPtrCheck(Name, Context, "std::make_shared") {}
MakeSharedCheck::SmartPtrTypeMatcher MakeSharedCheck::SmartPtrTypeMatcher
MakeSharedCheck::getSmartPointerTypeMatcher() const { MakeSharedCheck::getSmartPointerTypeMatcher() const {
return qualType(hasUnqualifiedDesugaredType( return qualType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(classTemplateSpecializationDecl( recordType(hasDeclaration(classTemplateSpecializationDecl(
hasName("::std::shared_ptr"), templateArgumentCountIs(1), hasName("::std::shared_ptr"), templateArgumentCountIs(1),
hasTemplateArgument(0, templateArgument(refersToType( hasTemplateArgument(0, templateArgument(refersToType(
qualType().bind(PointerType))))))))); qualType().bind(PointerType)))))))));
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp

//===--- MakeSmartPtrCheck.cpp - clang-tidy--------------------------------===// //===--- MakeSmartPtrCheck.cpp - clang-tidy--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../utils/TypeTraits.h" #include "../utils/TypeTraits.h"
#include "MakeSharedCheck.h" #include "MakeSharedCheck.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
constexpr char ConstructorCall[] = "constructorCall"; constexpr char ConstructorCall[] = "constructorCall";
constexpr char ResetCall[] = "resetCall"; constexpr char ResetCall[] = "resetCall";
constexpr char NewExpression[] = "newExpression"; constexpr char NewExpression[] = "newExpression";
std::string getNewExprName(const CXXNewExpr *NewExpr, const SourceManager &SM, std::string getNewExprName(const CXXNewExpr *NewExpr, const SourceManager &SM,
▲ Show 20 Lines • Show All 406 Lines • ▼ Show 20 Lines
void MakeSmartPtrCheck::insertHeader(DiagnosticBuilder &Diag, FileID FD) { void MakeSmartPtrCheck::insertHeader(DiagnosticBuilder &Diag, FileID FD) {
if (MakeSmartPtrFunctionHeader.empty()) { if (MakeSmartPtrFunctionHeader.empty()) {
return; return;
} }
Diag << Inserter.createIncludeInsertion(FD, MakeSmartPtrFunctionHeader); Diag << Inserter.createIncludeInsertion(FD, MakeSmartPtrFunctionHeader);
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/MakeUniqueCheck.cpp

//===--- MakeUniqueCheck.cpp - clang-tidy----------------------------------===// //===--- MakeUniqueCheck.cpp - clang-tidy----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MakeUniqueCheck.h" #include "MakeUniqueCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
MakeUniqueCheck::MakeUniqueCheck(StringRef Name, MakeUniqueCheck::MakeUniqueCheck(StringRef Name,
clang::tidy::ClangTidyContext *Context) clang::tidy::ClangTidyContext *Context)
: MakeSmartPtrCheck(Name, Context, "std::make_unique"), : MakeSmartPtrCheck(Name, Context, "std::make_unique"),
RequireCPlusPlus14(Options.get("MakeSmartPtrFunction", "").empty()) {} RequireCPlusPlus14(Options.get("MakeSmartPtrFunction", "").empty()) {}
MakeUniqueCheck::SmartPtrTypeMatcher MakeUniqueCheck::SmartPtrTypeMatcher
MakeUniqueCheck::getSmartPointerTypeMatcher() const { MakeUniqueCheck::getSmartPointerTypeMatcher() const {
Show All 14 Lines
bool MakeUniqueCheck::isLanguageVersionSupported( bool MakeUniqueCheck::isLanguageVersionSupported(
const LangOptions &LangOpts) const { const LangOptions &LangOpts) const {
return RequireCPlusPlus14 ? LangOpts.CPlusPlus14 : LangOpts.CPlusPlus11; return RequireCPlusPlus14 ? LangOpts.CPlusPlus14 : LangOpts.CPlusPlus11;
} }
// FixItHint is done by MakeSmartPtrCheck // FixItHint is done by MakeSmartPtrCheck
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

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

Show All 38 Lines
#include "UseOverrideCheck.h" #include "UseOverrideCheck.h"
#include "UseTrailingReturnTypeCheck.h" #include "UseTrailingReturnTypeCheck.h"
#include "UseTransparentFunctorsCheck.h" #include "UseTransparentFunctorsCheck.h"
#include "UseUncaughtExceptionsCheck.h" #include "UseUncaughtExceptionsCheck.h"
#include "UseUsingCheck.h" #include "UseUsingCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
namespace modernize { namespace modernize {
class ModernizeModule : public ClangTidyModule { class ModernizeModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind"); CheckFactories.registerCheck<AvoidBindCheck>("modernize-avoid-bind");
CheckFactories.registerCheck<AvoidCArraysCheck>("modernize-avoid-c-arrays"); CheckFactories.registerCheck<AvoidCArraysCheck>("modernize-avoid-c-arrays");
CheckFactories.registerCheck<ConcatNestedNamespacesCheck>( CheckFactories.registerCheck<ConcatNestedNamespacesCheck>(
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesstatic ClangTidyModuleRegistry::Add<ModernizeModule> X("modernize-module",
"Add modernize checks."); "Add modernize checks.");
} // namespace modernize } // namespace modernize
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the ModernizeModule. // and thus register the ModernizeModule.
volatile int ModernizeModuleAnchorSource = 0; volatile int ModernizeModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/PassByValueCheck.cpp

Show All 12 Lines
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace llvm; using namespace llvm;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
/// Matches move-constructible classes. /// Matches move-constructible classes.
/// ///
/// Given /// Given
/// \code /// \code
/// // POD types are trivially move constructible. /// // POD types are trivially move constructible.
/// struct Foo { int a; }; /// struct Foo { int a; };
▲ Show 20 Lines • Show All 268 Lines • ▼ Show 20 Linesvoid PassByValueCheck::check(const MatchFinder::MatchResult &Result) {
Diag << FixItHint::CreateInsertion(Initializer->getRParenLoc(), ")") Diag << FixItHint::CreateInsertion(Initializer->getRParenLoc(), ")")
<< FixItHint::CreateInsertion( << FixItHint::CreateInsertion(
Initializer->getLParenLoc().getLocWithOffset(1), "std::move(") Initializer->getLParenLoc().getLocWithOffset(1), "std::move(")
<< Inserter.createIncludeInsertion( << Inserter.createIncludeInsertion(
Result.SourceManager->getFileID(Initializer->getSourceLocation()), Result.SourceManager->getFileID(Initializer->getSourceLocation()),
"<utility>"); "<utility>");
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

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

//===--- RawStringLiteralCheck.cpp - clang-tidy----------------------------===// //===--- RawStringLiteralCheck.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RawStringLiteralCheck.h" #include "RawStringLiteralCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
bool containsEscapes(StringRef HayStack, StringRef Escapes) { bool containsEscapes(StringRef HayStack, StringRef Escapes) {
size_t BackSlash = HayStack.find('\\'); size_t BackSlash = HayStack.find('\\');
if (BackSlash == StringRef::npos) if (BackSlash == StringRef::npos)
return false; return false;
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Linesvoid RawStringLiteralCheck::replaceWithRawStringLiteral(
CharSourceRange CharRange = Lexer::makeFileCharRange( CharSourceRange CharRange = Lexer::makeFileCharRange(
CharSourceRange::getTokenRange(Literal->getSourceRange()), CharSourceRange::getTokenRange(Literal->getSourceRange()),
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
diag(Literal->getBeginLoc(), diag(Literal->getBeginLoc(),
"escaped string literal can be written as a raw string literal") "escaped string literal can be written as a raw string literal")
<< FixItHint::CreateReplacement(CharRange, Replacement); << FixItHint::CreateReplacement(CharRange, Replacement);
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/RedundantVoidArgCheck.cpp

//===- RedundantVoidArgCheck.cpp - clang-tidy -----------------------------===// //===- RedundantVoidArgCheck.cpp - clang-tidy -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RedundantVoidArgCheck.h" #include "RedundantVoidArgCheck.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
// Determine if the given QualType is a nullary function or pointer to same. // Determine if the given QualType is a nullary function or pointer to same.
bool protoTypeHasNoParms(QualType QT) { bool protoTypeHasNoParms(QualType QT) {
if (const auto *PT = QT->getAs<PointerType>()) if (const auto *PT = QT->getAs<PointerType>())
QT = PT->getPointeeType(); QT = PT->getPointeeType();
if (auto *MPT = QT->getAs<MemberPointerType>()) if (auto *MPT = QT->getAs<MemberPointerType>())
▲ Show 20 Lines • Show All 256 Lines • ▼ Show 20 Lines if (Lambda->getLambdaClass()->getLambdaCallOperator()->getNumParams() == 0 &&
TypeLoc TL = Lambda->getLambdaClass()->getLambdaTypeInfo()->getTypeLoc(); TypeLoc TL = Lambda->getLambdaClass()->getLambdaTypeInfo()->getTypeLoc();
removeVoidArgumentTokens(Result, removeVoidArgumentTokens(Result,
{SM->getSpellingLoc(TL.getBeginLoc()), {SM->getSpellingLoc(TL.getBeginLoc()),
SM->getSpellingLoc(TL.getEndLoc())}, SM->getSpellingLoc(TL.getEndLoc())},
"lambda expression"); "lambda expression");
} }
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp

Show All 10 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
using namespace clang; using namespace clang;
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
static const char AutoPtrTokenId[] = "AutoPrTokenId"; static const char AutoPtrTokenId[] = "AutoPrTokenId";
static const char AutoPtrOwnershipTransferId[] = "AutoPtrOwnershipTransferId"; static const char AutoPtrOwnershipTransferId[] = "AutoPtrOwnershipTransferId";
/// Matches expressions that are lvalues. /// Matches expressions that are lvalues.
/// ///
/// In the following example, a[0] matches expr(isLValue()): /// In the following example, a[0] matches expr(isLValue()):
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Linesvoid ReplaceAutoPtrCheck::check(const MatchFinder::MatchResult &Result) {
SourceLocation EndLoc = SourceLocation EndLoc =
AutoPtrLoc.getLocWithOffset(strlen("auto_ptr") - 1); AutoPtrLoc.getLocWithOffset(strlen("auto_ptr") - 1);
diag(AutoPtrLoc, "auto_ptr is deprecated, use unique_ptr instead") diag(AutoPtrLoc, "auto_ptr is deprecated, use unique_ptr instead")
<< FixItHint::CreateReplacement(SourceRange(AutoPtrLoc, EndLoc), << FixItHint::CreateReplacement(SourceRange(AutoPtrLoc, EndLoc),
"unique_ptr"); "unique_ptr");
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/ReplaceDisallowCopyAndAssignMacroCheck.cpp

//===--- ReplaceDisallowCopyAndAssignMacroCheck.cpp - clang-tidy ----------===// //===--- ReplaceDisallowCopyAndAssignMacroCheck.cpp - clang-tidy ----------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ReplaceDisallowCopyAndAssignMacroCheck.h" #include "ReplaceDisallowCopyAndAssignMacroCheck.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/MacroArgs.h" #include "clang/Lex/MacroArgs.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "llvm/Support/FormatVariadic.h" #include "llvm/Support/FormatVariadic.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
class ReplaceDisallowCopyAndAssignMacroCallbacks : public PPCallbacks { class ReplaceDisallowCopyAndAssignMacroCallbacks : public PPCallbacks {
public: public:
explicit ReplaceDisallowCopyAndAssignMacroCallbacks( explicit ReplaceDisallowCopyAndAssignMacroCallbacks(
ReplaceDisallowCopyAndAssignMacroCheck &Check, Preprocessor &PP) ReplaceDisallowCopyAndAssignMacroCheck &Check, Preprocessor &PP)
: Check(Check), PP(PP) {} : Check(Check), PP(PP) {}
▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines PP->addPPCallbacks(
*this, *ModuleExpanderPP)); *this, *ModuleExpanderPP));
} }
void ReplaceDisallowCopyAndAssignMacroCheck::storeOptions( void ReplaceDisallowCopyAndAssignMacroCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "MacroName", MacroName); Options.store(Opts, "MacroName", MacroName);
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
ReplaceRandomShuffleCheck::ReplaceRandomShuffleCheck(StringRef Name, ReplaceRandomShuffleCheck::ReplaceRandomShuffleCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IncludeInserter(Options.getLocalOrGlobal("IncludeStyle", IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
utils::IncludeSorter::IS_LLVM), utils::IncludeSorter::IS_LLVM),
areDiagsSelfContained()) {} areDiagsSelfContained()) {}
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Linesvoid ReplaceRandomShuffleCheck::check(const MatchFinder::MatchResult &Result) {
Diag << FixItHint::CreateRemoval(MatchedDecl->getSourceRange()); Diag << FixItHint::CreateRemoval(MatchedDecl->getSourceRange());
Diag << FixItHint::CreateInsertion(MatchedDecl->getBeginLoc(), NewName); Diag << FixItHint::CreateInsertion(MatchedDecl->getBeginLoc(), NewName);
Diag << IncludeInserter.createIncludeInsertion( Diag << IncludeInserter.createIncludeInsertion(
Result.Context->getSourceManager().getFileID( Result.Context->getSourceManager().getFileID(
MatchedCallExpr->getBeginLoc()), MatchedCallExpr->getBeginLoc()),
"<random>"); "<random>");
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/ReturnBracedInitListCheck.cpp

//===--- ReturnBracedInitListCheck.cpp - clang-tidy------------------------===// //===--- ReturnBracedInitListCheck.cpp - clang-tidy------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ReturnBracedInitListCheck.h" #include "ReturnBracedInitListCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
void ReturnBracedInitListCheck::registerMatchers(MatchFinder *Finder) { void ReturnBracedInitListCheck::registerMatchers(MatchFinder *Finder) {
// Skip list initialization and constructors with an initializer list. // Skip list initialization and constructors with an initializer list.
auto ConstructExpr = auto ConstructExpr =
cxxConstructExpr( cxxConstructExpr(
unless(anyOf(hasDeclaration(cxxConstructorDecl(isExplicit())), unless(anyOf(hasDeclaration(cxxConstructorDecl(isExplicit())),
isListInitialization(), hasDescendant(initListExpr())))) isListInitialization(), hasDescendant(initListExpr()))))
.bind("ctor"); .bind("ctor");
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Linesvoid ReturnBracedInitListCheck::check(const MatchFinder::MatchResult &Result) {
CharSourceRange CtorCallSourceRange = CharSourceRange::getTokenRange( CharSourceRange CtorCallSourceRange = CharSourceRange::getTokenRange(
Loc, CallParensRange.getBegin().getLocWithOffset(-1)); Loc, CallParensRange.getBegin().getLocWithOffset(-1));
Diag << FixItHint::CreateRemoval(CtorCallSourceRange) Diag << FixItHint::CreateRemoval(CtorCallSourceRange)
<< FixItHint::CreateReplacement(CallParensRange.getBegin(), "{") << FixItHint::CreateReplacement(CallParensRange.getBegin(), "{")
<< FixItHint::CreateReplacement(CallParensRange.getEnd(), "}"); << FixItHint::CreateReplacement(CallParensRange.getEnd(), "}");
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/ShrinkToFitCheck.cpp

//===--- ShrinkToFitCheck.cpp - clang-tidy---------------------------------===// //===--- ShrinkToFitCheck.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ShrinkToFitCheck.h" #include "ShrinkToFitCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
void ShrinkToFitCheck::registerMatchers(MatchFinder *Finder) { void ShrinkToFitCheck::registerMatchers(MatchFinder *Finder) {
// Swap as a function need not to be considered, because rvalue can not // Swap as a function need not to be considered, because rvalue can not
// be bound to a non-const reference. // be bound to a non-const reference.
const auto ShrinkableExpr = mapAnyOf(memberExpr, declRefExpr); const auto ShrinkableExpr = mapAnyOf(memberExpr, declRefExpr);
const auto Shrinkable = const auto Shrinkable =
ShrinkableExpr.with(hasDeclaration(valueDecl().bind("ContainerDecl"))); ShrinkableExpr.with(hasDeclaration(valueDecl().bind("ContainerDecl")));
const auto BoundShrinkable = ShrinkableExpr.with( const auto BoundShrinkable = ShrinkableExpr.with(
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Linesvoid ShrinkToFitCheck::check(const MatchFinder::MatchResult &Result) {
} }
diag(MemberCall->getBeginLoc(), "the shrink_to_fit method should be used " diag(MemberCall->getBeginLoc(), "the shrink_to_fit method should be used "
"to reduce the capacity of a shrinkable " "to reduce the capacity of a shrinkable "
"container") "container")
<< Hint; << Hint;
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UnaryStaticAssertCheck.cpp

//===--- UnaryStaticAssertCheck.cpp - clang-tidy---------------------------===// //===--- UnaryStaticAssertCheck.cpp - clang-tidy---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UnaryStaticAssertCheck.h" #include "UnaryStaticAssertCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
void UnaryStaticAssertCheck::registerMatchers(MatchFinder *Finder) { void UnaryStaticAssertCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(staticAssertDecl().bind("static_assert"), this); Finder->addMatcher(staticAssertDecl().bind("static_assert"), this);
} }
void UnaryStaticAssertCheck::check(const MatchFinder::MatchResult &Result) { void UnaryStaticAssertCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedDecl = const auto *MatchedDecl =
Result.Nodes.getNodeAs<StaticAssertDecl>("static_assert"); Result.Nodes.getNodeAs<StaticAssertDecl>("static_assert");
const StringLiteral *AssertMessage = MatchedDecl->getMessage(); const StringLiteral *AssertMessage = MatchedDecl->getMessage();
SourceLocation Loc = MatchedDecl->getLocation(); SourceLocation Loc = MatchedDecl->getLocation();
if (!AssertMessage || AssertMessage->getLength() || if (!AssertMessage || AssertMessage->getLength() ||
AssertMessage->getBeginLoc().isMacroID() || Loc.isMacroID()) AssertMessage->getBeginLoc().isMacroID() || Loc.isMacroID())
return; return;
diag(Loc, diag(Loc,
"use unary 'static_assert' when the string literal is an empty string") "use unary 'static_assert' when the string literal is an empty string")
<< FixItHint::CreateRemoval(AssertMessage->getSourceRange()); << FixItHint::CreateRemoval(AssertMessage->getSourceRange());
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

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

Show All 11 Lines
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Basic/CharInfo.h" #include "clang/Basic/CharInfo.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang; using namespace clang;
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::ast_matchers::internal; using namespace clang::ast_matchers::internal;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
const char IteratorDeclStmtId[] = "iterator_decl"; const char IteratorDeclStmtId[] = "iterator_decl";
const char DeclWithNewId[] = "decl_new"; const char DeclWithNewId[] = "decl_new";
const char DeclWithCastId[] = "decl_cast"; const char DeclWithCastId[] = "decl_cast";
const char DeclWithTemplateCastId[] = "decl_template"; const char DeclWithTemplateCastId[] = "decl_template";
size_t getTypeNameLength(bool RemoveStars, StringRef Text) { size_t getTypeNameLength(bool RemoveStars, StringRef Text) {
▲ Show 20 Lines • Show All 413 Lines • ▼ Show 20 Lines replaceExpr(
}, },
"use auto when initializing with a template cast to avoid duplicating " "use auto when initializing with a template cast to avoid duplicating "
"the type name"); "the type name");
} else { } else {
llvm_unreachable("Bad Callback. No node provided."); llvm_unreachable("Bad Callback. No node provided.");
} }
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseBoolLiteralsCheck.cpp

//===--- UseBoolLiteralsCheck.cpp - clang-tidy-----------------------------===// //===--- UseBoolLiteralsCheck.cpp - clang-tidy-----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseBoolLiteralsCheck.h" #include "UseBoolLiteralsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
UseBoolLiteralsCheck::UseBoolLiteralsCheck(StringRef Name, UseBoolLiteralsCheck::UseBoolLiteralsCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {} IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
void UseBoolLiteralsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void UseBoolLiteralsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IgnoreMacros", IgnoreMacros); Options.store(Opts, "IgnoreMacros", IgnoreMacros);
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines auto Diag =
diag(Expression->getExprLoc(), diag(Expression->getExprLoc(),
"converting integer literal to bool, use bool literal instead"); "converting integer literal to bool, use bool literal instead");
if (!InMacro) if (!InMacro)
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
Expression->getSourceRange(), LiteralBooleanValue ? "true" : "false"); Expression->getSourceRange(), LiteralBooleanValue ? "true" : "false");
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

//===--- UseDefaultMemberInitCheck.cpp - clang-tidy------------------------===// //===--- UseDefaultMemberInitCheck.cpp - clang-tidy------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseDefaultMemberInitCheck.h" #include "UseDefaultMemberInitCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
AST_MATCHER_P(InitListExpr, initCountIs, unsigned, N) { AST_MATCHER_P(InitListExpr, initCountIs, unsigned, N) {
return Node.getNumInits() == N; return Node.getNumInits() == N;
} }
} // namespace } // namespace
static StringRef getValueOfValueInit(const QualType InitType) { static StringRef getValueOfValueInit(const QualType InitType) {
▲ Show 20 Lines • Show All 264 Lines • ▼ Show 20 Linesvoid UseDefaultMemberInitCheck::checkExistingInit(
if (!sameValue(Field->getInClassInitializer(), Init->getInit())) if (!sameValue(Field->getInClassInitializer(), Init->getInit()))
return; return;
diag(Init->getSourceLocation(), "member initializer for %0 is redundant") diag(Init->getSourceLocation(), "member initializer for %0 is redundant")
<< Field << Field
<< FixItHint::CreateRemoval(Init->getSourceRange()); << FixItHint::CreateRemoval(Init->getSourceRange());
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseEmplaceCheck.cpp

//===--- UseEmplaceCheck.cpp - clang-tidy----------------------------------===// //===--- UseEmplaceCheck.cpp - clang-tidy----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseEmplaceCheck.h" #include "UseEmplaceCheck.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
// Identical to hasAnyName, except it does not take template specifiers into // Identical to hasAnyName, except it does not take template specifiers into
// account. This is used to match the functions names as in // account. This is used to match the functions names as in
// DefaultEmplacyFunctions below without caring about the template types of the // DefaultEmplacyFunctions below without caring about the template types of the
// containers. // containers.
AST_MATCHER_P(NamedDecl, hasAnyNameIgnoringTemplates, std::vector<StringRef>, AST_MATCHER_P(NamedDecl, hasAnyNameIgnoringTemplates, std::vector<StringRef>,
Names) { Names) {
▲ Show 20 Lines • Show All 345 Lines • ▼ Show 20 Linesvoid UseEmplaceCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "TupleTypes", Options.store(Opts, "TupleTypes",
utils::options::serializeStringList(TupleTypes)); utils::options::serializeStringList(TupleTypes));
Options.store(Opts, "TupleMakeFunctions", Options.store(Opts, "TupleMakeFunctions",
utils::options::serializeStringList(TupleMakeFunctions)); utils::options::serializeStringList(TupleMakeFunctions));
Options.store(Opts, "EmplacyFunctions", Options.store(Opts, "EmplacyFunctions",
utils::options::serializeStringList(EmplacyFunctions)); utils::options::serializeStringList(EmplacyFunctions));
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseEqualsDefaultCheck.cpp

Show All 10 Lines
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
static const char SpecialFunction[] = "SpecialFunction"; static const char SpecialFunction[] = "SpecialFunction";
/// Finds all the named non-static fields of \p Record. /// Finds all the named non-static fields of \p Record.
static std::set<const FieldDecl *> static std::set<const FieldDecl *>
getAllNamedFields(const CXXRecordDecl *Record) { getAllNamedFields(const CXXRecordDecl *Record) {
std::set<const FieldDecl *> Result; std::set<const FieldDecl *> Result;
for (const auto *Field : Record->fields()) { for (const auto *Field : Record->fields()) {
▲ Show 20 Lines • Show All 320 Lines • ▼ Show 20 Lines std::optional<Token> Token = utils::lexer::findNextTokenSkippingComments(
Result.Context->getLangOpts()); Result.Context->getLangOpts());
StringRef Replacement = StringRef Replacement =
Token && Token->is(tok::semi) ? "= default" : "= default;"; Token && Token->is(tok::semi) ? "= default" : "= default;";
Diag << FixItHint::CreateReplacement(Body->getSourceRange(), Replacement) Diag << FixItHint::CreateReplacement(Body->getSourceRange(), Replacement)
<< RemoveInitializers; << RemoveInitializers;
} }
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseEqualsDeleteCheck.cpp

//===--- UseEqualsDeleteCheck.cpp - clang-tidy-----------------------------===// //===--- UseEqualsDeleteCheck.cpp - clang-tidy-----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseEqualsDeleteCheck.h" #include "UseEqualsDeleteCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
static const char SpecialFunction[] = "SpecialFunction"; static const char SpecialFunction[] = "SpecialFunction";
static const char DeletedNotPublic[] = "DeletedNotPublic"; static const char DeletedNotPublic[] = "DeletedNotPublic";
void UseEqualsDeleteCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void UseEqualsDeleteCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IgnoreMacros", IgnoreMacros); Options.store(Opts, "IgnoreMacros", IgnoreMacros);
} }
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines if (const auto *Func =
// automatically fix the warning when macros are in play. // automatically fix the warning when macros are in play.
if (Func->getLocation().isMacroID() && IgnoreMacros) if (Func->getLocation().isMacroID() && IgnoreMacros)
return; return;
// FIXME: Add FixItHint to make the method public. // FIXME: Add FixItHint to make the method public.
diag(Func->getLocation(), "deleted member function should be public"); diag(Func->getLocation(), "deleted member function should be public");
} }
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseNodiscardCheck.cpp

//===--- UseNodiscardCheck.cpp - clang-tidy -------------------------------===// //===--- UseNodiscardCheck.cpp - clang-tidy -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseNodiscardCheck.h" #include "UseNodiscardCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
#include "clang/AST/Type.h" #include "clang/AST/Type.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
static bool doesNoDiscardMacroExist(ASTContext &Context, static bool doesNoDiscardMacroExist(ASTContext &Context,
const llvm::StringRef &MacroId) { const llvm::StringRef &MacroId) {
// Don't check for the Macro existence if we are using an attribute // Don't check for the Macro existence if we are using an attribute
// either a C++17 standard attribute or pre C++17 syntax // either a C++17 standard attribute or pre C++17 syntax
if (MacroId.startswith("[[") || MacroId.startswith("__attribute__")) if (MacroId.startswith("[[") || MacroId.startswith("__attribute__"))
return true; return true;
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Linesbool UseNodiscardCheck::isLanguageVersionSupported(
// ReplacementString option. // ReplacementString option.
if (NoDiscardMacro == "[[nodiscard]]") if (NoDiscardMacro == "[[nodiscard]]")
return LangOpts.CPlusPlus17; return LangOpts.CPlusPlus17;
return LangOpts.CPlusPlus; return LangOpts.CPlusPlus;
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseNoexceptCheck.cpp

//===--- UseNoexceptCheck.cpp - clang-tidy---------------------------------===// //===--- UseNoexceptCheck.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseNoexceptCheck.h" #include "UseNoexceptCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
AST_MATCHER(NamedDecl, isValid) { return !Node.isInvalidDecl(); } AST_MATCHER(NamedDecl, isValid) { return !Node.isInvalidDecl(); }
} // namespace } // namespace
UseNoexceptCheck::UseNoexceptCheck(StringRef Name, ClangTidyContext *Context) UseNoexceptCheck::UseNoexceptCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
NoexceptMacro(Options.get("ReplacementString", "")), NoexceptMacro(Options.get("ReplacementString", "")),
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Linesvoid UseNoexceptCheck::check(const MatchFinder::MatchResult &Result) {
diag(Range.getBegin(), "dynamic exception specification '%0' is deprecated; " diag(Range.getBegin(), "dynamic exception specification '%0' is deprecated; "
"consider %select{using '%2'|removing it}1 instead") "consider %select{using '%2'|removing it}1 instead")
<< Lexer::getSourceText(CRange, *Result.SourceManager, << Lexer::getSourceText(CRange, *Result.SourceManager,
Result.Context->getLangOpts()) Result.Context->getLangOpts())
<< ReplacementStr.empty() << ReplacementStr << FixIt; << ReplacementStr.empty() << ReplacementStr << FixIt;
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/AST/RecursiveASTVisitor.h" #include "clang/AST/RecursiveASTVisitor.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang; using namespace clang;
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace llvm; using namespace llvm;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
const char CastSequence[] = "sequence"; const char CastSequence[] = "sequence";
AST_MATCHER(Type, sugaredNullptrType) { AST_MATCHER(Type, sugaredNullptrType) {
const Type *DesugaredType = Node.getUnqualifiedDesugaredType(); const Type *DesugaredType = Node.getUnqualifiedDesugaredType();
if (const auto *BT = dyn_cast<BuiltinType>(DesugaredType)) if (const auto *BT = dyn_cast<BuiltinType>(DesugaredType))
return BT->getKind() == BuiltinType::NullPtr; return BT->getKind() == BuiltinType::NullPtr;
▲ Show 20 Lines • Show All 475 Lines • ▼ Show 20 Linesvoid UseNullptrCheck::check(const MatchFinder::MatchResult &Result) {
// Given an implicit null-ptr cast or an explicit cast with an implicit // Given an implicit null-ptr cast or an explicit cast with an implicit
// null-to-pointer cast within use CastSequenceVisitor to identify sequences // null-to-pointer cast within use CastSequenceVisitor to identify sequences
// of explicit casts that can be converted into 'nullptr'. // of explicit casts that can be converted into 'nullptr'.
CastSequenceVisitor(*Result.Context, NullMacros, *this) CastSequenceVisitor(*Result.Context, NullMacros, *this)
.TraverseStmt(const_cast<CastExpr *>(NullCast)); .TraverseStmt(const_cast<CastExpr *>(NullCast));
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseOverrideCheck.cpp

//===--- UseOverrideCheck.cpp - clang-tidy --------------------------------===// //===--- UseOverrideCheck.cpp - clang-tidy --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseOverrideCheck.h" #include "UseOverrideCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
UseOverrideCheck::UseOverrideCheck(StringRef Name, ClangTidyContext *Context) UseOverrideCheck::UseOverrideCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnoreDestructors(Options.get("IgnoreDestructors", false)), IgnoreDestructors(Options.get("IgnoreDestructors", false)),
AllowOverrideAndFinal(Options.get("AllowOverrideAndFinal", false)), AllowOverrideAndFinal(Options.get("AllowOverrideAndFinal", false)),
OverrideSpelling(Options.get("OverrideSpelling", "override")), OverrideSpelling(Options.get("OverrideSpelling", "override")),
FinalSpelling(Options.get("FinalSpelling", "final")) {} FinalSpelling(Options.get("FinalSpelling", "final")) {}
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Lines for (Token Tok : Tokens) {
Diag << FixItHint::CreateRemoval(CharSourceRange::getTokenRange( Diag << FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
Tok.getLocation(), Tok.getLocation())); Tok.getLocation(), Tok.getLocation()));
break; break;
} }
} }
} }
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp

Show All 13 Lines
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include <cctype> #include <cctype>
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
namespace { namespace {
struct UnqualNameVisitor : public RecursiveASTVisitor<UnqualNameVisitor> { struct UnqualNameVisitor : public RecursiveASTVisitor<UnqualNameVisitor> {
public: public:
UnqualNameVisitor(const FunctionDecl &F) : F(F) {} UnqualNameVisitor(const FunctionDecl &F) : F(F) {}
bool Collision = false; bool Collision = false;
bool shouldWalkTypesOfTypeLocs() const { return false; } bool shouldWalkTypesOfTypeLocs() const { return false; }
▲ Show 20 Lines • Show All 458 Lines • ▼ Show 20 Linesvoid UseTrailingReturnTypeCheck::check(const MatchFinder::MatchResult &Result) {
keepSpecifiers(ReturnType, Auto, ReturnTypeCVRange, *F, Fr, Ctx, SM, keepSpecifiers(ReturnType, Auto, ReturnTypeCVRange, *F, Fr, Ctx, SM,
LangOpts); LangOpts);
diag(F->getLocation(), Message) diag(F->getLocation(), Message)
<< FixItHint::CreateReplacement(ReturnTypeCVRange, Auto) << FixItHint::CreateReplacement(ReturnTypeCVRange, Auto)
<< FixItHint::CreateInsertion(InsertionLoc, " -> " + ReturnType); << FixItHint::CreateInsertion(InsertionLoc, " -> " + ReturnType);
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseTransparentFunctorsCheck.cpp

//===--- UseTransparentFunctorsCheck.cpp - clang-tidy----------------------===// //===--- UseTransparentFunctorsCheck.cpp - clang-tidy----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseTransparentFunctorsCheck.h" #include "UseTransparentFunctorsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
UseTransparentFunctorsCheck::UseTransparentFunctorsCheck( UseTransparentFunctorsCheck::UseTransparentFunctorsCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), SafeMode(Options.get("SafeMode", false)) {} : ClangTidyCheck(Name, Context), SafeMode(Options.get("SafeMode", false)) {}
void UseTransparentFunctorsCheck::storeOptions( void UseTransparentFunctorsCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "SafeMode", SafeMode); Options.store(Opts, "SafeMode", SafeMode);
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Linesvoid UseTransparentFunctorsCheck::check(
SourceLocation ReportLoc = FunctorLoc.getLocation(); SourceLocation ReportLoc = FunctorLoc.getLocation();
if (ReportLoc.isInvalid()) if (ReportLoc.isInvalid())
return; return;
diag(ReportLoc, Message) << FuncClass->getName() diag(ReportLoc, Message) << FuncClass->getName()
<< FixItHint::CreateRemoval( << FixItHint::CreateRemoval(
FunctorTypeLoc.getArgLoc(0).getSourceRange()); FunctorTypeLoc.getArgLoc(0).getSourceRange());
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseUncaughtExceptionsCheck.cpp

//===--- UseUncaughtExceptionsCheck.cpp - clang-tidy--------------------===// //===--- UseUncaughtExceptionsCheck.cpp - clang-tidy--------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseUncaughtExceptionsCheck.h" #include "UseUncaughtExceptionsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
void UseUncaughtExceptionsCheck::registerMatchers(MatchFinder *Finder) { void UseUncaughtExceptionsCheck::registerMatchers(MatchFinder *Finder) {
std::string MatchText = "::std::uncaught_exception"; std::string MatchText = "::std::uncaught_exception";
// Using declaration: warning and fix-it. // Using declaration: warning and fix-it.
Finder->addMatcher( Finder->addMatcher(
usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(hasName(MatchText)))) usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(hasName(MatchText))))
.bind("using_decl"), .bind("using_decl"),
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines if (!C) {
"s"); "s");
} else { } else {
Diag << FixItHint::CreateReplacement(C->getSourceRange(), Diag << FixItHint::CreateReplacement(C->getSourceRange(),
"std::uncaught_exceptions() > 0"); "std::uncaught_exceptions() > 0");
} }
} }
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/modernize/UseUsingCheck.cpp

//===--- UseUsingCheck.cpp - clang-tidy------------------------------------===// //===--- UseUsingCheck.cpp - clang-tidy------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UseUsingCheck.h" #include "UseUsingCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::modernize {
namespace tidy {
namespace modernize {
static constexpr llvm::StringLiteral ParentDeclName = "parent-decl"; static constexpr llvm::StringLiteral ParentDeclName = "parent-decl";
static constexpr llvm::StringLiteral TagDeclName = "tag-decl"; static constexpr llvm::StringLiteral TagDeclName = "tag-decl";
static constexpr llvm::StringLiteral TypedefName = "typedef"; static constexpr llvm::StringLiteral TypedefName = "typedef";
UseUsingCheck::UseUsingCheck(StringRef Name, ClangTidyContext *Context) UseUsingCheck::UseUsingCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {} IgnoreMacros(Options.getLocalOrGlobal("IgnoreMacros", true)) {}
▲ Show 20 Lines • Show All 111 Lines • ▼ Show 20 Lines Type = std::string(Lexer::getSourceText(
*Result.SourceManager, getLangOpts())); *Result.SourceManager, getLangOpts()));
if (Type.empty()) if (Type.empty())
return; return;
} }
std::string Replacement = Using + Name + " = " + Type; std::string Replacement = Using + Name + " = " + Type;
Diag << FixItHint::CreateReplacement(ReplaceRange, Replacement); Diag << FixItHint::CreateReplacement(ReplaceRange, Replacement);
} }
} // namespace modernize } // namespace clang::tidy::modernize
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/mpi/BufferDerefCheck.cpp

//===--- BufferDerefCheck.cpp - clang-tidy---------------------------------===// //===--- BufferDerefCheck.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "BufferDerefCheck.h" #include "BufferDerefCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::mpi {
namespace tidy {
namespace mpi {
void BufferDerefCheck::registerMatchers(MatchFinder *Finder) { void BufferDerefCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(callExpr().bind("CE"), this); Finder->addMatcher(callExpr().bind("CE"), this);
} }
void BufferDerefCheck::check(const MatchFinder::MatchResult &Result) { void BufferDerefCheck::check(const MatchFinder::MatchResult &Result) {
const auto *CE = Result.Nodes.getNodeAs<CallExpr>("CE"); const auto *CE = Result.Nodes.getNodeAs<CallExpr>("CE");
if (!CE->getDirectCallee()) if (!CE->getDirectCallee())
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines if (IndirectionCount > 1) {
const auto Loc = BufferExprs[I]->getSourceRange().getBegin(); const auto Loc = BufferExprs[I]->getSourceRange().getBegin();
diag(Loc, "buffer is insufficiently dereferenced: %0") << IndirectionDesc; diag(Loc, "buffer is insufficiently dereferenced: %0") << IndirectionDesc;
} }
} }
} }
void BufferDerefCheck::onEndOfTranslationUnit() { FuncClassifier.reset(); } void BufferDerefCheck::onEndOfTranslationUnit() { FuncClassifier.reset(); }
} // namespace mpi } // namespace clang::tidy::mpi
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/mpi/MPITidyModule.cpp

//===--- MPITidyModule.cpp - clang-tidy -----------------------------------===// //===--- MPITidyModule.cpp - clang-tidy -----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "BufferDerefCheck.h" #include "BufferDerefCheck.h"
#include "TypeMismatchCheck.h" #include "TypeMismatchCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace mpi { namespace mpi {
class MPIModule : public ClangTidyModule { class MPIModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<BufferDerefCheck>("mpi-buffer-deref"); CheckFactories.registerCheck<BufferDerefCheck>("mpi-buffer-deref");
CheckFactories.registerCheck<TypeMismatchCheck>("mpi-type-mismatch"); CheckFactories.registerCheck<TypeMismatchCheck>("mpi-type-mismatch");
} }
}; };
} // namespace mpi } // namespace mpi
// Register the MPITidyModule using this statically initialized variable. // Register the MPITidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<mpi::MPIModule> static ClangTidyModuleRegistry::Add<mpi::MPIModule>
X("mpi-module", "Adds MPI clang-tidy checks."); X("mpi-module", "Adds MPI clang-tidy checks.");
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the MPIModule. // and thus register the MPIModule.
volatile int MPIModuleAnchorSource = 0; volatile int MPIModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/mpi/TypeMismatchCheck.cpp

//===--- TypeMismatchCheck.cpp - clang-tidy--------------------------------===// //===--- TypeMismatchCheck.cpp - clang-tidy--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TypeMismatchCheck.h" #include "TypeMismatchCheck.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include "llvm/ADT/StringSet.h" #include "llvm/ADT/StringSet.h"
#include <map> #include <map>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::mpi {
namespace tidy {
namespace mpi {
/// Check if a BuiltinType::Kind matches the MPI datatype. /// Check if a BuiltinType::Kind matches the MPI datatype.
/// ///
/// \param MultiMap datatype group /// \param MultiMap datatype group
/// \param Kind buffer type kind /// \param Kind buffer type kind
/// \param MPIDatatype name of the MPI datatype /// \param MPIDatatype name of the MPI datatype
/// ///
/// \returns true if the pair matches /// \returns true if the pair matches
▲ Show 20 Lines • Show All 297 Lines • ▼ Show 20 Lines if (Error) {
const auto Loc = BufferExprs[I]->getSourceRange().getBegin(); const auto Loc = BufferExprs[I]->getSourceRange().getBegin();
diag(Loc, "buffer type '%0' does not match the MPI datatype '%1'") diag(Loc, "buffer type '%0' does not match the MPI datatype '%1'")
<< BufferTypeName << MPIDatatypes[I]; << BufferTypeName << MPIDatatypes[I];
} }
} }
} }
void TypeMismatchCheck::onEndOfTranslationUnit() { FuncClassifier.reset(); } void TypeMismatchCheck::onEndOfTranslationUnit() { FuncClassifier.reset(); }
} // namespace mpi } // namespace clang::tidy::mpi
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/AssertEquals.cpp

//===--- AssertEquals.cpp - clang-tidy --------------------------*- C++ -*-===// //===--- AssertEquals.cpp - clang-tidy --------------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AssertEquals.h" #include "AssertEquals.h"
#include <map> #include <map>
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::objc {
namespace tidy {
namespace objc {
// Mapping from `XCTAssert*Equal` to `XCTAssert*EqualObjects` name. // Mapping from `XCTAssert*Equal` to `XCTAssert*EqualObjects` name.
static const std::map<std::string, std::string> &NameMap() { static const std::map<std::string, std::string> &NameMap() {
static std::map<std::string, std::string> map{ static std::map<std::string, std::string> map{
{"XCTAssertEqual", "XCTAssertEqualObjects"}, {"XCTAssertEqual", "XCTAssertEqualObjects"},
{"XCTAssertNotEqual", "XCTAssertNotEqualObjects"}, {"XCTAssertNotEqual", "XCTAssertNotEqualObjects"},
}; };
Show All 28 Lines if (const auto *root = result.Nodes.getNodeAs<BinaryOperator>(pair.first)) {
clang::CharSourceRange::getCharRange( clang::CharSourceRange::getCharRange(
macro_callsite, macro_callsite,
macro_callsite.getLocWithOffset(pair.first.length())), macro_callsite.getLocWithOffset(pair.first.length())),
pair.second); pair.second);
} }
} }
} }
} // namespace objc } // namespace clang::tidy::objc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/AvoidNSErrorInitCheck.cpp

//===--- AvoidNSErrorInitCheck.cpp - clang-tidy----------------------------===// //===--- AvoidNSErrorInitCheck.cpp - clang-tidy----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidNSErrorInitCheck.h" #include "AvoidNSErrorInitCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::objc {
namespace tidy {
namespace objc {
void AvoidNSErrorInitCheck::registerMatchers(MatchFinder *Finder) { void AvoidNSErrorInitCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(objcMessageExpr(hasSelector("init"), Finder->addMatcher(objcMessageExpr(hasSelector("init"),
hasReceiverType(asString("NSError *"))) hasReceiverType(asString("NSError *")))
.bind("nserrorInit"), .bind("nserrorInit"),
this); this);
} }
void AvoidNSErrorInitCheck::check(const MatchFinder::MatchResult &Result) { void AvoidNSErrorInitCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedExpr = const auto *MatchedExpr =
Result.Nodes.getNodeAs<ObjCMessageExpr>("nserrorInit"); Result.Nodes.getNodeAs<ObjCMessageExpr>("nserrorInit");
diag(MatchedExpr->getBeginLoc(), diag(MatchedExpr->getBeginLoc(),
"use errorWithDomain:code:userInfo: or initWithDomain:code:userInfo: to " "use errorWithDomain:code:userInfo: or initWithDomain:code:userInfo: to "
"create a new NSError"); "create a new NSError");
} }
} // namespace objc } // namespace clang::tidy::objc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/DeallocInCategoryCheck.cpp

//===--- DeallocInCategoryCheck.cpp - clang-tidy -------------------===// //===--- DeallocInCategoryCheck.cpp - clang-tidy -------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DeallocInCategoryCheck.h" #include "DeallocInCategoryCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h" #include "clang/AST/DeclObjC.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::objc {
namespace tidy {
namespace objc {
void DeallocInCategoryCheck::registerMatchers(MatchFinder *Finder) { void DeallocInCategoryCheck::registerMatchers(MatchFinder *Finder) {
// Non-NSObject/NSProxy-derived objects may not have -dealloc as a special // Non-NSObject/NSProxy-derived objects may not have -dealloc as a special
// method. However, it seems highly unrealistic to expect many false-positives // method. However, it seems highly unrealistic to expect many false-positives
// by warning on -dealloc in categories on classes without one of those // by warning on -dealloc in categories on classes without one of those
// base classes. // base classes.
Finder->addMatcher( Finder->addMatcher(
objcMethodDecl(isInstanceMethod(), hasName("dealloc"), objcMethodDecl(isInstanceMethod(), hasName("dealloc"),
hasDeclContext(objcCategoryImplDecl().bind("impl"))) hasDeclContext(objcCategoryImplDecl().bind("impl")))
.bind("dealloc"), .bind("dealloc"),
this); this);
} }
void DeallocInCategoryCheck::check(const MatchFinder::MatchResult &Result) { void DeallocInCategoryCheck::check(const MatchFinder::MatchResult &Result) {
const auto *DeallocDecl = Result.Nodes.getNodeAs<ObjCMethodDecl>("dealloc"); const auto *DeallocDecl = Result.Nodes.getNodeAs<ObjCMethodDecl>("dealloc");
const auto *CID = Result.Nodes.getNodeAs<ObjCCategoryImplDecl>("impl"); const auto *CID = Result.Nodes.getNodeAs<ObjCCategoryImplDecl>("impl");
assert(DeallocDecl != nullptr); assert(DeallocDecl != nullptr);
diag(DeallocDecl->getLocation(), "category %0 should not implement -dealloc") diag(DeallocDecl->getLocation(), "category %0 should not implement -dealloc")
<< CID; << CID;
} }
} // namespace objc } // namespace clang::tidy::objc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/ForbiddenSubclassingCheck.cpp

Show All 9 Lines
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/Hashing.h" #include "llvm/ADT/Hashing.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::objc {
namespace tidy {
namespace objc {
namespace { namespace {
constexpr char DefaultForbiddenSuperClassNames[] = constexpr char DefaultForbiddenSuperClassNames[] =
"ABNewPersonViewController;" "ABNewPersonViewController;"
"ABPeoplePickerNavigationController;" "ABPeoplePickerNavigationController;"
"ABPersonViewController;" "ABPersonViewController;"
"ABUnknownPersonViewController;" "ABUnknownPersonViewController;"
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
void ForbiddenSubclassingCheck::storeOptions( void ForbiddenSubclassingCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store( Options.store(
Opts, Opts,
"ForbiddenSuperClassNames", "ForbiddenSuperClassNames",
utils::options::serializeStringList(ForbiddenSuperClassNames)); utils::options::serializeStringList(ForbiddenSuperClassNames));
} }
} // namespace objc } // namespace clang::tidy::objc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/MissingHashCheck.cpp

//===--- MissingHashCheck.cpp - clang-tidy --------------------------------===// //===--- MissingHashCheck.cpp - clang-tidy --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MissingHashCheck.h" #include "MissingHashCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::objc {
namespace tidy {
namespace objc {
namespace { namespace {
AST_MATCHER_P(ObjCImplementationDecl, hasInterface, AST_MATCHER_P(ObjCImplementationDecl, hasInterface,
ast_matchers::internal::Matcher<ObjCInterfaceDecl>, Base) { ast_matchers::internal::Matcher<ObjCInterfaceDecl>, Base) {
const ObjCInterfaceDecl *InterfaceDecl = Node.getClassInterface(); const ObjCInterfaceDecl *InterfaceDecl = Node.getClassInterface();
return Base.matches(*InterfaceDecl, Finder, Builder); return Base.matches(*InterfaceDecl, Finder, Builder);
} }
Show All 22 Lines
} }
void MissingHashCheck::check(const MatchFinder::MatchResult &Result) { void MissingHashCheck::check(const MatchFinder::MatchResult &Result) {
const auto *ID = Result.Nodes.getNodeAs<ObjCImplementationDecl>("impl"); const auto *ID = Result.Nodes.getNodeAs<ObjCImplementationDecl>("impl");
diag(ID->getLocation(), "%0 implements -isEqual: without implementing -hash") diag(ID->getLocation(), "%0 implements -isEqual: without implementing -hash")
<< ID; << ID;
} }
} // namespace objc } // namespace clang::tidy::objc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/NSDateFormatterCheck.cpp

//===--- NSDateFormatterCheck.cpp - clang-tidy ----------------------------===// //===--- NSDateFormatterCheck.cpp - clang-tidy ----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NSDateFormatterCheck.h" #include "NSDateFormatterCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::objc {
namespace tidy {
namespace objc {
void NSDateFormatterCheck::registerMatchers(MatchFinder *Finder) { void NSDateFormatterCheck::registerMatchers(MatchFinder *Finder) {
// Adding matchers. // Adding matchers.
Finder->addMatcher( Finder->addMatcher(
objcMessageExpr(hasSelector("setDateFormat:"), objcMessageExpr(hasSelector("setDateFormat:"),
hasReceiverType(asString("NSDateFormatter *")), hasReceiverType(asString("NSDateFormatter *")),
hasArgument(0, ignoringImpCasts( hasArgument(0, ignoringImpCasts(
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Linesvoid NSDateFormatterCheck::check(const MatchFinder::MatchResult &Result) {
} }
if (SR.contains('Y') && SR.contains('F') && !SR.contains('y')) { if (SR.contains('Y') && SR.contains('F') && !SR.contains('y')) {
diag(StrExpr->getExprLoc(), diag(StrExpr->getExprLoc(),
"use of week year (Y) with day of the week in month (F); " "use of week year (Y) with day of the week in month (F); "
"did you mean to use calendar year (y) instead?"); "did you mean to use calendar year (y) instead?");
} }
} }
} // namespace objc } // namespace clang::tidy::objc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/NSInvocationArgumentLifetimeCheck.cpp

Show All 22 Lines
#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManager.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::objc {
namespace tidy {
namespace objc {
namespace { namespace {
static constexpr StringRef WeakText = "__weak"; static constexpr StringRef WeakText = "__weak";
static constexpr StringRef StrongText = "__strong"; static constexpr StringRef StrongText = "__strong";
static constexpr StringRef UnsafeUnretainedText = "__unsafe_unretained"; static constexpr StringRef UnsafeUnretainedText = "__unsafe_unretained";
/// Matches ObjCIvarRefExpr, DeclRefExpr, or MemberExpr that reference /// Matches ObjCIvarRefExpr, DeclRefExpr, or MemberExpr that reference
/// Objective-C object (or block) variables or fields whose object lifetimes /// Objective-C object (or block) variables or fields whose object lifetimes
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Linesvoid NSInvocationArgumentLifetimeCheck::check(
if (!VD) if (!VD)
return; return;
if (auto Hint = fixItHintForVarDecl(VD, *Result.SourceManager, if (auto Hint = fixItHintForVarDecl(VD, *Result.SourceManager,
Result.Context->getLangOpts())) Result.Context->getLangOpts()))
Diag << *Hint; Diag << *Hint;
} }
} // namespace objc } // namespace clang::tidy::objc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/ObjCTidyModule.cpp

Show All 15 Lines
#include "MissingHashCheck.h" #include "MissingHashCheck.h"
#include "NSDateFormatterCheck.h" #include "NSDateFormatterCheck.h"
#include "NSInvocationArgumentLifetimeCheck.h" #include "NSInvocationArgumentLifetimeCheck.h"
#include "PropertyDeclarationCheck.h" #include "PropertyDeclarationCheck.h"
#include "SuperSelfCheck.h" #include "SuperSelfCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
namespace objc { namespace objc {
class ObjCModule : public ClangTidyModule { class ObjCModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<AvoidNSErrorInitCheck>( CheckFactories.registerCheck<AvoidNSErrorInitCheck>(
"objc-avoid-nserror-init"); "objc-avoid-nserror-init");
CheckFactories.registerCheck<AssertEquals>("objc-assert-equals"); CheckFactories.registerCheck<AssertEquals>("objc-assert-equals");
Show All 20 Linesstatic ClangTidyModuleRegistry::Add<ObjCModule> X(
"Adds Objective-C lint checks."); "Adds Objective-C lint checks.");
} // namespace objc } // namespace objc
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the ObjCModule. // and thus register the ObjCModule.
volatile int ObjCModuleAnchorSource = 0; volatile int ObjCModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/PropertyDeclarationCheck.cpp

Show All 12 Lines
#include "clang/Basic/CharInfo.h" #include "clang/Basic/CharInfo.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Regex.h" #include "llvm/Support/Regex.h"
#include <algorithm> #include <algorithm>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::objc {
namespace tidy {
namespace objc {
namespace { namespace {
// For StandardProperty the naming style is 'lowerCamelCase'. // For StandardProperty the naming style is 'lowerCamelCase'.
// For CategoryProperty especially in categories of system class, // For CategoryProperty especially in categories of system class,
// to avoid naming conflict, the suggested naming style is // to avoid naming conflict, the suggested naming style is
// 'abc_lowerCamelCase' (adding lowercase prefix followed by '_'). // 'abc_lowerCamelCase' (adding lowercase prefix followed by '_').
// Regardless of the style, all acronyms and initialisms should be capitalized. // Regardless of the style, all acronyms and initialisms should be capitalized.
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Linesvoid PropertyDeclarationCheck::check(const MatchFinder::MatchResult &Result) {
} }
diag(MatchedDecl->getLocation(), diag(MatchedDecl->getLocation(),
"property name '%0' not using lowerCamelCase style or not prefixed in " "property name '%0' not using lowerCamelCase style or not prefixed in "
"a category, according to the Apple Coding Guidelines") "a category, according to the Apple Coding Guidelines")
<< MatchedDecl->getName() << MatchedDecl->getName()
<< generateFixItHint(MatchedDecl, StandardProperty); << generateFixItHint(MatchedDecl, StandardProperty);
} }
} // namespace objc } // namespace clang::tidy::objc
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/objc/SuperSelfCheck.cpp

//===--- SuperSelfCheck.cpp - clang-tidy ----------------------------------===// //===--- SuperSelfCheck.cpp - clang-tidy ----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SuperSelfCheck.h" #include "SuperSelfCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::objc {
namespace tidy {
namespace objc {
namespace { namespace {
/// Matches Objective-C methods in the initializer family. /// Matches Objective-C methods in the initializer family.
/// ///
/// Example matches -init and -initWithInt:. /// Example matches -init and -initWithInt:.
/// (matcher = objcMethodDecl(isInitializer())) /// (matcher = objcMethodDecl(isInitializer()))
/// \code /// \code
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Linesvoid SuperSelfCheck::check(const MatchFinder::MatchResult &Result) {
SourceLocation SelectorLoc = Message->getSelectorStartLoc(); SourceLocation SelectorLoc = Message->getSelectorStartLoc();
if (SelectorLoc.isMacroID() || SelectorLoc.isInvalid()) if (SelectorLoc.isMacroID() || SelectorLoc.isInvalid())
return; return;
Diag << FixItHint::CreateReplacement(Message->getSourceRange(), Diag << FixItHint::CreateReplacement(Message->getSourceRange(),
StringRef("[super init]")); StringRef("[super init]"));
} }
} // namespace objc } // namespace clang::tidy::objc
} // namespace tidy
} // namespace clang

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

Show All 11 Lines
#include "clang/AST/Stmt.h" #include "clang/AST/Stmt.h"
#include "clang/AST/StmtOpenMP.h" #include "clang/AST/StmtOpenMP.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/ASTMatchers/ASTMatchersMacros.h" #include "clang/ASTMatchers/ASTMatchersMacros.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::openmp {
namespace tidy {
namespace openmp {
ExceptionEscapeCheck::ExceptionEscapeCheck(StringRef Name, ExceptionEscapeCheck::ExceptionEscapeCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
RawIgnoredExceptions(Options.get("IgnoredExceptions", "")) { RawIgnoredExceptions(Options.get("IgnoredExceptions", "")) {
llvm::SmallVector<StringRef, 8> FunctionsThatShouldNotThrowVec, llvm::SmallVector<StringRef, 8> FunctionsThatShouldNotThrowVec,
IgnoredExceptionsVec; IgnoredExceptionsVec;
Show All 35 Linesvoid ExceptionEscapeCheck::check(const MatchFinder::MatchResult &Result) {
// the exception is thrown, maybe the full path the exception escapes. // the exception is thrown, maybe the full path the exception escapes.
diag(StructuredBlock->getBeginLoc(), diag(StructuredBlock->getBeginLoc(),
"an exception thrown inside of the OpenMP '%0' region is not caught in " "an exception thrown inside of the OpenMP '%0' region is not caught in "
"that same region") "that same region")
<< getOpenMPDirectiveName(Directive->getDirectiveKind()); << getOpenMPDirectiveName(Directive->getDirectiveKind());
} }
} // namespace openmp } // namespace clang::tidy::openmp
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/openmp/OpenMPTidyModule.cpp

//===--- OpenMPTidyModule.cpp - clang-tidy--------------------------------===// //===--- OpenMPTidyModule.cpp - clang-tidy--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "ExceptionEscapeCheck.h" #include "ExceptionEscapeCheck.h"
#include "UseDefaultNoneCheck.h" #include "UseDefaultNoneCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace openmp { namespace openmp {
/// This module is for OpenMP-specific checks. /// This module is for OpenMP-specific checks.
class OpenMPModule : public ClangTidyModule { class OpenMPModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<ExceptionEscapeCheck>( CheckFactories.registerCheck<ExceptionEscapeCheck>(
"openmp-exception-escape"); "openmp-exception-escape");
CheckFactories.registerCheck<UseDefaultNoneCheck>( CheckFactories.registerCheck<UseDefaultNoneCheck>(
"openmp-use-default-none"); "openmp-use-default-none");
} }
}; };
// Register the OpenMPTidyModule using this statically initialized variable. // Register the OpenMPTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<OpenMPModule> static ClangTidyModuleRegistry::Add<OpenMPModule>
X("openmp-module", "Adds OpenMP-specific checks."); X("openmp-module", "Adds OpenMP-specific checks.");
} // namespace openmp } // namespace openmp
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the OpenMPModule. // and thus register the OpenMPModule.
volatile int OpenMPModuleAnchorSource = 0; volatile int OpenMPModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/openmp/UseDefaultNoneCheck.cpp

Show All 11 Lines
#include "clang/AST/Stmt.h" #include "clang/AST/Stmt.h"
#include "clang/AST/StmtOpenMP.h" #include "clang/AST/StmtOpenMP.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/ASTMatchers/ASTMatchersMacros.h" #include "clang/ASTMatchers/ASTMatchersMacros.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::openmp {
namespace tidy {
namespace openmp {
void UseDefaultNoneCheck::registerMatchers(MatchFinder *Finder) { void UseDefaultNoneCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
ompExecutableDirective( ompExecutableDirective(
allOf(isAllowedToContainClauseKind(llvm::omp::OMPC_default), allOf(isAllowedToContainClauseKind(llvm::omp::OMPC_default),
anyOf(unless(hasAnyClause(ompDefaultClause())), anyOf(unless(hasAnyClause(ompDefaultClause())),
hasAnyClause(ompDefaultClause(unless(isNoneKind())) hasAnyClause(ompDefaultClause(unless(isNoneKind()))
.bind("clause"))))) .bind("clause")))))
Show All 19 Linesvoid UseDefaultNoneCheck::check(const MatchFinder::MatchResult &Result) {
} }
diag(Directive->getBeginLoc(), diag(Directive->getBeginLoc(),
"OpenMP directive '%0' does not specify 'default' clause, consider " "OpenMP directive '%0' does not specify 'default' clause, consider "
"specifying 'default(none)' clause") "specifying 'default(none)' clause")
<< getOpenMPDirectiveName(Directive->getDirectiveKind()); << getOpenMPDirectiveName(Directive->getDirectiveKind());
} }
} // namespace openmp } // namespace clang::tidy::openmp
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
namespace { namespace {
std::optional<std::string> makeCharacterLiteral(const StringLiteral *Literal) { std::optional<std::string> makeCharacterLiteral(const StringLiteral *Literal) {
std::string Result; std::string Result;
{ {
llvm::raw_string_ostream OS(Result); llvm::raw_string_ostream OS(Result);
Literal->outputString(OS); Literal->outputString(OS);
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines diag(Literal->getBeginLoc(), "%0 called with a string literal consisting of "
"effective overload accepting a character") "effective overload accepting a character")
<< FindFunc << FindFunc
<< FixItHint::CreateReplacement( << FixItHint::CreateReplacement(
CharSourceRange::getTokenRange(Literal->getBeginLoc(), CharSourceRange::getTokenRange(Literal->getBeginLoc(),
Literal->getEndLoc()), Literal->getEndLoc()),
*Replacement); *Replacement);
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/ForRangeCopyCheck.cpp

Show All 12 Lines
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "../utils/TypeTraits.h" #include "../utils/TypeTraits.h"
#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h" #include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
#include "clang/Basic/Diagnostic.h" #include "clang/Basic/Diagnostic.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
ForRangeCopyCheck::ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context) ForRangeCopyCheck::ForRangeCopyCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
WarnOnAllAutoCopies(Options.get("WarnOnAllAutoCopies", false)), WarnOnAllAutoCopies(Options.get("WarnOnAllAutoCopies", false)),
AllowedTypes( AllowedTypes(
utils::options::parseStringList(Options.get("AllowedTypes", ""))) {} utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
void ForRangeCopyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void ForRangeCopyCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines if (std::optional<FixItHint> Fix = utils::fixit::addQualifierToVarDecl(
LoopVar, Context, DeclSpec::TQ::TQ_const)) LoopVar, Context, DeclSpec::TQ::TQ_const))
Diag << *Fix << utils::fixit::changeVarDeclToReference(LoopVar, Context); Diag << *Fix << utils::fixit::changeVarDeclToReference(LoopVar, Context);
return true; return true;
} }
return false; return false;
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/ImplicitConversionInLoopCheck.cpp

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
// Checks if the stmt is a ImplicitCastExpr with a CastKind that is not a NoOp. // Checks if the stmt is a ImplicitCastExpr with a CastKind that is not a NoOp.
// The subtlety is that in some cases (user defined conversions), we can // The subtlety is that in some cases (user defined conversions), we can
// get to ImplicitCastExpr inside each other, with the outer one a NoOp. In this // get to ImplicitCastExpr inside each other, with the outer one a NoOp. In this
// case we skip the first cast expr. // case we skip the first cast expr.
static bool isNonTrivialImplicitCast(const Stmt *ST) { static bool isNonTrivialImplicitCast(const Stmt *ST) {
if (const auto *ICE = dyn_cast<ImplicitCastExpr>(ST)) { if (const auto *ICE = dyn_cast<ImplicitCastExpr>(ST)) {
return (ICE->getCastKind() != CK_NoOp) || return (ICE->getCastKind() != CK_NoOp) ||
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines const char Message[] =
"the type of the loop variable %0 is different from the one returned " "the type of the loop variable %0 is different from the one returned "
"by the iterator and generates an implicit conversion; you can either " "by the iterator and generates an implicit conversion; you can either "
"change the type to the matching one (%1 but 'const auto&' is always a " "change the type to the matching one (%1 but 'const auto&' is always a "
"valid option) or remove the reference to make it explicit that you are " "valid option) or remove the reference to make it explicit that you are "
"creating a new value"; "creating a new value";
diag(VD->getBeginLoc(), Message) << VD << ConstRefType; diag(VD->getBeginLoc(), Message) << VD << ConstRefType;
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/InefficientAlgorithmCheck.cpp

//===--- InefficientAlgorithmCheck.cpp - clang-tidy------------------------===// //===--- InefficientAlgorithmCheck.cpp - clang-tidy------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "InefficientAlgorithmCheck.h" #include "InefficientAlgorithmCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
static bool areTypesCompatible(QualType Left, QualType Right) { static bool areTypesCompatible(QualType Left, QualType Right) {
if (const auto *LeftRefType = Left->getAs<ReferenceType>()) if (const auto *LeftRefType = Left->getAs<ReferenceType>())
Left = LeftRefType->getPointeeType(); Left = LeftRefType->getPointeeType();
if (const auto *RightRefType = Right->getAs<ReferenceType>()) if (const auto *RightRefType = Right->getAs<ReferenceType>())
Right = RightRefType->getPointeeType(); Right = RightRefType->getPointeeType();
return Left->getCanonicalTypeUnqualified() == return Left->getCanonicalTypeUnqualified() ==
Right->getCanonicalTypeUnqualified(); Right->getCanonicalTypeUnqualified();
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Lines if (!CallRange.getBegin().isMacroID() && !Maplike && CompatibleTypes) {
Hint = FixItHint::CreateReplacement(CallRange, ReplacementText); Hint = FixItHint::CreateReplacement(CallRange, ReplacementText);
} }
diag(AlgCall->getBeginLoc(), diag(AlgCall->getBeginLoc(),
"this STL algorithm call should be replaced with a container method") "this STL algorithm call should be replaced with a container method")
<< Hint; << Hint;
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/InefficientStringConcatenationCheck.cpp

//===--- InefficientStringConcatenationCheck.cpp - clang-tidy--------------===// //===--- InefficientStringConcatenationCheck.cpp - clang-tidy--------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "InefficientStringConcatenationCheck.h" #include "InefficientStringConcatenationCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
void InefficientStringConcatenationCheck::storeOptions( void InefficientStringConcatenationCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "StrictMode", StrictMode); Options.store(Opts, "StrictMode", StrictMode);
} }
InefficientStringConcatenationCheck::InefficientStringConcatenationCheck( InefficientStringConcatenationCheck::InefficientStringConcatenationCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines const char *DiagMsg =
"strings; consider using 'operator+=' or 'string::append()' instead"; "strings; consider using 'operator+=' or 'string::append()' instead";
if (LhsStr) if (LhsStr)
diag(LhsStr->getExprLoc(), DiagMsg); diag(LhsStr->getExprLoc(), DiagMsg);
else if (PlusOperator) else if (PlusOperator)
diag(PlusOperator->getExprLoc(), DiagMsg); diag(PlusOperator->getExprLoc(), DiagMsg);
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.cpp

Show All 9 Lines
#include "../utils/DeclRefExprUtils.h" #include "../utils/DeclRefExprUtils.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
namespace { namespace {
// Matcher names. Given the code: // Matcher names. Given the code:
// //
// \code // \code
// void f() { // void f() {
// vector<T> v; // vector<T> v;
▲ Show 20 Lines • Show All 239 Lines • ▼ Show 20 Lines auto Diag = diag(AppendCall->getBeginLoc(),
<< AppendCall->getMethodDecl()->getDeclName(); << AppendCall->getMethodDecl()->getDeclName();
if (!ReserveSize.empty()) { if (!ReserveSize.empty()) {
std::string ReserveStmt = std::string ReserveStmt =
(VarName + PartialReserveStmt + "(" + ReserveSize + ");\n").str(); (VarName + PartialReserveStmt + "(" + ReserveSize + ");\n").str();
Diag << FixItHint::CreateInsertion(LoopStmt->getBeginLoc(), ReserveStmt); Diag << FixItHint::CreateInsertion(LoopStmt->getBeginLoc(), ReserveStmt);
} }
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/MoveConstArgCheck.cpp

//===--- MoveConstArgCheck.cpp - clang-tidy -----------------------===// //===--- MoveConstArgCheck.cpp - clang-tidy -----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MoveConstArgCheck.h" #include "MoveConstArgCheck.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
static void replaceCallWithArg(const CallExpr *Call, DiagnosticBuilder &Diag, static void replaceCallWithArg(const CallExpr *Call, DiagnosticBuilder &Diag,
const SourceManager &SM, const SourceManager &SM,
const LangOptions &LangOpts) { const LangOptions &LangOpts) {
const Expr *Arg = Call->getArg(0); const Expr *Arg = Call->getArg(0);
CharSourceRange BeforeArgumentsRange = Lexer::makeFileCharRange( CharSourceRange BeforeArgumentsRange = Lexer::makeFileCharRange(
CharSourceRange::getCharRange(Call->getBeginLoc(), Arg->getBeginLoc()), CharSourceRange::getCharRange(Call->getBeginLoc(), Arg->getBeginLoc()),
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines if (IsConstArg || IsTriviallyCopyable) {
auto Diag = diag(FileMoveRange.getBegin(), auto Diag = diag(FileMoveRange.getBegin(),
"passing result of std::move() as a const reference " "passing result of std::move() as a const reference "
"argument; no move will actually happen"); "argument; no move will actually happen");
replaceCallWithArg(CallMove, Diag, SM, getLangOpts()); replaceCallWithArg(CallMove, Diag, SM, getLangOpts());
} }
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/MoveConstructorInitCheck.cpp

//===--- MoveConstructorInitCheck.cpp - clang-tidy-------------------------===// //===--- MoveConstructorInitCheck.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MoveConstructorInitCheck.h" #include "MoveConstructorInitCheck.h"
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
MoveConstructorInitCheck::MoveConstructorInitCheck(StringRef Name, MoveConstructorInitCheck::MoveConstructorInitCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) { void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse(TK_AsIs, traverse(TK_AsIs,
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines diag(Initializer->getSourceLocation(),
<< Initializer->isBaseInitializer(); << Initializer->isBaseInitializer();
diag(CopyCtor->getLocation(), "copy constructor being called", diag(CopyCtor->getLocation(), "copy constructor being called",
DiagnosticIDs::Note); DiagnosticIDs::Note);
diag(Candidate->getLocation(), "candidate move constructor here", diag(Candidate->getLocation(), "candidate move constructor here",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} }
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp

//===--- NoAutomaticMoveCheck.cpp - clang-tidy ----------------------------===// //===--- NoAutomaticMoveCheck.cpp - clang-tidy ----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NoAutomaticMoveCheck.h" #include "NoAutomaticMoveCheck.h"
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
NoAutomaticMoveCheck::NoAutomaticMoveCheck(StringRef Name, NoAutomaticMoveCheck::NoAutomaticMoveCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
AllowedTypes( AllowedTypes(
utils::options::parseStringList(Options.get("AllowedTypes", ""))) {} utils::options::parseStringList(Options.get("AllowedTypes", ""))) {}
void NoAutomaticMoveCheck::registerMatchers(MatchFinder *Finder) { void NoAutomaticMoveCheck::registerMatchers(MatchFinder *Finder) {
Show All 34 Lines diag(CtorCall->getExprLoc(), "constness of '%0' prevents automatic move")
<< Var->getName(); << Var->getName();
} }
void NoAutomaticMoveCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void NoAutomaticMoveCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "AllowedTypes", Options.store(Opts, "AllowedTypes",
utils::options::serializeStringList(AllowedTypes)); utils::options::serializeStringList(AllowedTypes));
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/NoIntToPtrCheck.cpp

//===--- NoIntToPtrCheck.cpp - clang-tidy ---------------------------------===// //===--- NoIntToPtrCheck.cpp - clang-tidy ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NoIntToPtrCheck.h" #include "NoIntToPtrCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
void NoIntToPtrCheck::registerMatchers(MatchFinder *Finder) { void NoIntToPtrCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(castExpr(hasCastKind(CK_IntegralToPointer), Finder->addMatcher(castExpr(hasCastKind(CK_IntegralToPointer),
unless(hasSourceExpression(integerLiteral()))) unless(hasSourceExpression(integerLiteral())))
.bind("x"), .bind("x"),
this); this);
} }
void NoIntToPtrCheck::check(const MatchFinder::MatchResult &Result) { void NoIntToPtrCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedCast = Result.Nodes.getNodeAs<CastExpr>("x"); const auto *MatchedCast = Result.Nodes.getNodeAs<CastExpr>("x");
diag(MatchedCast->getBeginLoc(), diag(MatchedCast->getBeginLoc(),
"integer to pointer cast pessimizes optimization opportunities"); "integer to pointer cast pessimizes optimization opportunities");
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/NoexceptMoveConstructorCheck.cpp

//===--- NoexceptMoveConstructorCheck.cpp - clang-tidy---------------------===// //===--- NoexceptMoveConstructorCheck.cpp - clang-tidy---------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NoexceptMoveConstructorCheck.h" #include "NoexceptMoveConstructorCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
void NoexceptMoveConstructorCheck::registerMatchers(MatchFinder *Finder) { void NoexceptMoveConstructorCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
cxxMethodDecl(anyOf(cxxConstructorDecl(), hasOverloadedOperatorName("=")), cxxMethodDecl(anyOf(cxxConstructorDecl(), hasOverloadedOperatorName("=")),
unless(isImplicit()), unless(isDeleted())) unless(isImplicit()), unless(isDeleted()))
.bind("decl"), .bind("decl"),
this); this);
} }
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines if (ProtoType->canThrow() == CT_Can) {
"noexcept specifier on the move %select{assignment " "noexcept specifier on the move %select{assignment "
"operator|constructor}0 evaluates to 'false'") "operator|constructor}0 evaluates to 'false'")
<< IsConstructor; << IsConstructor;
} }
} }
} }
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/PerformanceTidyModule.cpp

Show All 19 Lines
#include "NoAutomaticMoveCheck.h" #include "NoAutomaticMoveCheck.h"
#include "NoIntToPtrCheck.h" #include "NoIntToPtrCheck.h"
#include "NoexceptMoveConstructorCheck.h" #include "NoexceptMoveConstructorCheck.h"
#include "TriviallyDestructibleCheck.h" #include "TriviallyDestructibleCheck.h"
#include "TypePromotionInMathFnCheck.h" #include "TypePromotionInMathFnCheck.h"
#include "UnnecessaryCopyInitialization.h" #include "UnnecessaryCopyInitialization.h"
#include "UnnecessaryValueParamCheck.h" #include "UnnecessaryValueParamCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace performance { namespace performance {
class PerformanceModule : public ClangTidyModule { class PerformanceModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<FasterStringFindCheck>( CheckFactories.registerCheck<FasterStringFindCheck>(
"performance-faster-string-find"); "performance-faster-string-find");
CheckFactories.registerCheck<ForRangeCopyCheck>( CheckFactories.registerCheck<ForRangeCopyCheck>(
Show All 31 Linesstatic ClangTidyModuleRegistry::Add<PerformanceModule>
X("performance-module", "Adds performance checks."); X("performance-module", "Adds performance checks.");
} // namespace performance } // namespace performance
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the PerformanceModule. // and thus register the PerformanceModule.
volatile int PerformanceModuleAnchorSource = 0; volatile int PerformanceModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/TriviallyDestructibleCheck.cpp

Show All 10 Lines
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::ast_matchers::internal; using namespace clang::ast_matchers::internal;
using namespace clang::tidy::matchers; using namespace clang::tidy::matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
namespace { namespace {
AST_MATCHER(Decl, isFirstDecl) { return Node.isFirstDecl(); } AST_MATCHER(Decl, isFirstDecl) { return Node.isFirstDecl(); }
AST_MATCHER_P(CXXRecordDecl, hasBase, Matcher<QualType>, InnerMatcher) { AST_MATCHER_P(CXXRecordDecl, hasBase, Matcher<QualType>, InnerMatcher) {
for (const CXXBaseSpecifier &BaseSpec : Node.bases()) { for (const CXXBaseSpecifier &BaseSpec : Node.bases()) {
QualType BaseType = BaseSpec.getType(); QualType BaseType = BaseSpec.getType();
Show All 39 Lines diag(FirstDecl->getLocation(),
"destructor on its first declaration") "destructor on its first declaration")
<< FirstDecl->getParent() << FirstDecl->getParent()
<< FixItHint::CreateInsertion(FirstDeclEnd, " = default") << FixItHint::CreateInsertion(FirstDeclEnd, " = default")
<< FixItHint::CreateRemoval(SecondDeclRange); << FixItHint::CreateRemoval(SecondDeclRange);
diag(MatchedDecl->getLocation(), "destructor definition is here", diag(MatchedDecl->getLocation(), "destructor definition is here",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/performance/TypePromotionInMathFnCheck.cpp

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/StringSet.h" #include "llvm/ADT/StringSet.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
namespace { namespace {
AST_MATCHER_P(Type, isBuiltinType, BuiltinType::Kind, Kind) { AST_MATCHER_P(Type, isBuiltinType, BuiltinType::Kind, Kind) {
if (const auto *BT = dyn_cast<BuiltinType>(&Node)) { if (const auto *BT = dyn_cast<BuiltinType>(&Node)) {
return BT->getKind() == Kind; return BT->getKind() == Kind;
} }
return false; return false;
} }
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Linesvoid TypePromotionInMathFnCheck::check(const MatchFinder::MatchResult &Result) {
// <math.h>, because the functions we're suggesting moving away from are all // <math.h>, because the functions we're suggesting moving away from are all
// declared in <math.h>. // declared in <math.h>.
if (FnInCmath) if (FnInCmath)
Diag << IncludeInserter.createIncludeInsertion( Diag << IncludeInserter.createIncludeInsertion(
Result.Context->getSourceManager().getFileID(Call->getBeginLoc()), Result.Context->getSourceManager().getFileID(Call->getBeginLoc()),
"<cmath>"); "<cmath>");
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "../utils/FixItHintUtils.h" #include "../utils/FixItHintUtils.h"
#include "../utils/LexerUtils.h" #include "../utils/LexerUtils.h"
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
#include "clang/Basic/Diagnostic.h" #include "clang/Basic/Diagnostic.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
namespace { namespace {
using namespace ::clang::ast_matchers; using namespace ::clang::ast_matchers;
using llvm::StringRef; using llvm::StringRef;
using utils::decl_ref_expr::allDeclRefExprs; using utils::decl_ref_expr::allDeclRefExprs;
using utils::decl_ref_expr::isOnlyUsedAsConst; using utils::decl_ref_expr::isOnlyUsedAsConst;
static constexpr StringRef ObjectArgId = "objectArg"; static constexpr StringRef ObjectArgId = "objectArg";
▲ Show 20 Lines • Show All 335 Lines • ▼ Show 20 Lines
void UnnecessaryCopyInitialization::storeOptions( void UnnecessaryCopyInitialization::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "AllowedTypes", Options.store(Opts, "AllowedTypes",
utils::options::serializeStringList(AllowedTypes)); utils::options::serializeStringList(AllowedTypes));
Options.store(Opts, "ExcludedContainerTypes", Options.store(Opts, "ExcludedContainerTypes",
utils::options::serializeStringList(ExcludedContainerTypes)); utils::options::serializeStringList(ExcludedContainerTypes));
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

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

Show All 14 Lines
#include "../utils/TypeTraits.h" #include "../utils/TypeTraits.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::performance {
namespace tidy {
namespace performance {
namespace { namespace {
std::string paramNameOrIndex(StringRef Name, size_t Index) { std::string paramNameOrIndex(StringRef Name, size_t Index) {
return (Name.empty() ? llvm::Twine('#') + llvm::Twine(Index + 1) return (Name.empty() ? llvm::Twine('#') + llvm::Twine(Index + 1)
: llvm::Twine('\'') + Name + llvm::Twine('\'')) : llvm::Twine('\'') + Name + llvm::Twine('\''))
.str(); .str();
} }
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Linesvoid UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var,
auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM, auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM,
Context.getLangOpts()); Context.getLangOpts());
Diag << FixItHint::CreateInsertion(CopyArgument.getBeginLoc(), "std::move(") Diag << FixItHint::CreateInsertion(CopyArgument.getBeginLoc(), "std::move(")
<< FixItHint::CreateInsertion(EndLoc, ")") << FixItHint::CreateInsertion(EndLoc, ")")
<< Inserter.createIncludeInsertion( << Inserter.createIncludeInsertion(
SM.getFileID(CopyArgument.getBeginLoc()), "<utility>"); SM.getFileID(CopyArgument.getBeginLoc()), "<utility>");
} }
} // namespace performance } // namespace clang::tidy::performance
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/plugin/ClangTidyPlugin.cpp

//===- ClangTidyPlugin.cpp - clang-tidy as a clang plugin -----------------===// //===- ClangTidyPlugin.cpp - clang-tidy as a clang plugin -----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyDiagnosticConsumer.h" #include "../ClangTidyDiagnosticConsumer.h"
#include "../ClangTidyForceLinker.h" #include "../ClangTidyForceLinker.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendPluginRegistry.h" #include "clang/Frontend/FrontendPluginRegistry.h"
#include "clang/Frontend/MultiplexConsumer.h" #include "clang/Frontend/MultiplexConsumer.h"
namespace clang { namespace clang::tidy {
namespace tidy {
/// The core clang tidy plugin action. This just provides the AST consumer and /// The core clang tidy plugin action. This just provides the AST consumer and
/// command line flag parsing for using clang-tidy as a clang plugin. /// command line flag parsing for using clang-tidy as a clang plugin.
class ClangTidyPluginAction : public PluginASTAction { class ClangTidyPluginAction : public PluginASTAction {
/// Wrapper to grant the context and diagnostics engine the same lifetime as /// Wrapper to grant the context and diagnostics engine the same lifetime as
/// the action. /// the action.
/// We use MultiplexConsumer to avoid writing out all the forwarding methods. /// We use MultiplexConsumer to avoid writing out all the forwarding methods.
class WrapConsumer : public MultiplexConsumer { class WrapConsumer : public MultiplexConsumer {
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines auto Options = std::make_unique<FileOptionsProvider>(
GlobalOptions, DefaultOptions, OverrideOptions); GlobalOptions, DefaultOptions, OverrideOptions);
Context = std::make_unique<ClangTidyContext>(std::move(Options)); Context = std::make_unique<ClangTidyContext>(std::move(Options));
return true; return true;
} }
private: private:
std::unique_ptr<ClangTidyContext> Context; std::unique_ptr<ClangTidyContext> Context;
}; };
} // namespace tidy } // namespace clang::tidy
} // namespace clang
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the clang-tidy plugin. // and thus register the clang-tidy plugin.
volatile int ClangTidyPluginAnchorSource = 0; volatile int ClangTidyPluginAnchorSource = 0;
static clang::FrontendPluginRegistry::Add<clang::tidy::ClangTidyPluginAction> static clang::FrontendPluginRegistry::Add<clang::tidy::ClangTidyPluginAction>
X("clang-tidy", "clang-tidy"); X("clang-tidy", "clang-tidy");

clang-tools-extra/clang-tidy/portability/PortabilityTidyModule.cpp

//===--- PortabilityTidyModule.cpp - clang-tidy ---------------------------===// //===--- PortabilityTidyModule.cpp - clang-tidy ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "RestrictSystemIncludesCheck.h" #include "RestrictSystemIncludesCheck.h"
#include "SIMDIntrinsicsCheck.h" #include "SIMDIntrinsicsCheck.h"
#include "StdAllocatorConstCheck.h" #include "StdAllocatorConstCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace portability { namespace portability {
class PortabilityModule : public ClangTidyModule { class PortabilityModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<RestrictSystemIncludesCheck>( CheckFactories.registerCheck<RestrictSystemIncludesCheck>(
"portability-restrict-system-includes"); "portability-restrict-system-includes");
CheckFactories.registerCheck<SIMDIntrinsicsCheck>( CheckFactories.registerCheck<SIMDIntrinsicsCheck>(
"portability-simd-intrinsics"); "portability-simd-intrinsics");
CheckFactories.registerCheck<StdAllocatorConstCheck>( CheckFactories.registerCheck<StdAllocatorConstCheck>(
"portability-std-allocator-const"); "portability-std-allocator-const");
} }
}; };
// Register the PortabilityModule using this statically initialized variable. // Register the PortabilityModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<PortabilityModule> static ClangTidyModuleRegistry::Add<PortabilityModule>
X("portability-module", "Adds portability-related checks."); X("portability-module", "Adds portability-related checks.");
} // namespace portability } // namespace portability
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the PortabilityModule. // and thus register the PortabilityModule.
volatile int PortabilityModuleAnchorSource = 0; volatile int PortabilityModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/portability/RestrictSystemIncludesCheck.cpp

Show All 10 Lines
#include "clang/Lex/HeaderSearch.h" #include "clang/Lex/HeaderSearch.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include <cstring> #include <cstring>
namespace clang { namespace clang::tidy::portability {
namespace tidy {
namespace portability {
void RestrictedIncludesPPCallbacks::InclusionDirective( void RestrictedIncludesPPCallbacks::InclusionDirective(
SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName, SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
bool IsAngled, CharSourceRange FilenameRange, OptionalFileEntryRef File, bool IsAngled, CharSourceRange FilenameRange, OptionalFileEntryRef File,
StringRef SearchPath, StringRef RelativePath, const Module *Imported, StringRef SearchPath, StringRef RelativePath, const Module *Imported,
SrcMgr::CharacteristicKind FileType) { SrcMgr::CharacteristicKind FileType) {
if (!Check.contains(FileName) && SrcMgr::isSystem(FileType)) { if (!Check.contains(FileName) && SrcMgr::isSystem(FileType)) {
SmallString<256> FullPath; SmallString<256> FullPath;
Show All 40 Lines PP->addPPCallbacks(
std::make_unique<RestrictedIncludesPPCallbacks>(*this, SM)); std::make_unique<RestrictedIncludesPPCallbacks>(*this, SM));
} }
void RestrictSystemIncludesCheck::storeOptions( void RestrictSystemIncludesCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "Includes", AllowedIncludes); Options.store(Opts, "Includes", AllowedIncludes);
} }
} // namespace portability } // namespace clang::tidy::portability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/portability/SIMDIntrinsicsCheck.cpp

Show All 11 Lines
#include "clang/Basic/TargetInfo.h" #include "clang/Basic/TargetInfo.h"
#include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringMap.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
#include "llvm/Support/ManagedStatic.h" #include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/Regex.h" #include "llvm/Support/Regex.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::portability {
namespace tidy {
namespace portability {
namespace { namespace {
// If the callee has parameter of VectorType or pointer to VectorType, // If the callee has parameter of VectorType or pointer to VectorType,
// or the return type is VectorType, we consider it a vector function // or the return type is VectorType, we consider it a vector function
// and a candidate for checking. // and a candidate for checking.
AST_MATCHER(FunctionDecl, isVectorFunction) { AST_MATCHER(FunctionDecl, isVectorFunction) {
bool IsVector = Node.getReturnType()->isVectorType(); bool IsVector = Node.getReturnType()->isVectorType();
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines if (Suggest) {
StdRegex.sub(Std, New)); StdRegex.sub(Std, New));
} else { } else {
diag("'%0' is a non-portable %1 intrinsic function") diag("'%0' is a non-portable %1 intrinsic function")
<< Old << llvm::Triple::getArchTypeName(Arch); << Old << llvm::Triple::getArchTypeName(Arch);
} }
} }
} }
} // namespace portability } // namespace clang::tidy::portability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/portability/StdAllocatorConstCheck.cpp

//===-- StdAllocatorConstCheck.cpp - clang-tidy --------------------------===// //===-- StdAllocatorConstCheck.cpp - clang-tidy --------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StdAllocatorConstCheck.h" #include "StdAllocatorConstCheck.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::portability {
namespace tidy {
namespace portability {
void StdAllocatorConstCheck::registerMatchers(MatchFinder *Finder) { void StdAllocatorConstCheck::registerMatchers(MatchFinder *Finder) {
// Match std::allocator<const T>. // Match std::allocator<const T>.
auto allocatorConst = auto allocatorConst =
recordType(hasDeclaration(classTemplateSpecializationDecl( recordType(hasDeclaration(classTemplateSpecializationDecl(
hasName("::std::allocator"), hasName("::std::allocator"),
hasTemplateArgument(0, refersToType(qualType(isConstQualified())))))); hasTemplateArgument(0, refersToType(qualType(isConstQualified()))))));
Show All 36 Lines if (isSystem(Result.Context->getSourceManager().getFileCharacteristic(
return; return;
diag(T->getBeginLoc(), diag(T->getBeginLoc(),
"container using std::allocator<const T> is a deprecated libc++ " "container using std::allocator<const T> is a deprecated libc++ "
"extension; remove const for compatibility with other standard " "extension; remove const for compatibility with other standard "
"libraries"); "libraries");
} }
} // namespace portability } // namespace clang::tidy::portability
} // namespace tidy
} // namespace clang

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

//===--- AvoidConstParamsInDecls.cpp - clang-tidy--------------------------===// //===--- AvoidConstParamsInDecls.cpp - clang-tidy--------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AvoidConstParamsInDecls.h" #include "AvoidConstParamsInDecls.h"
#include "../utils/LexerUtils.h" #include "../utils/LexerUtils.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
SourceRange getTypeRange(const ParmVarDecl &Param) { SourceRange getTypeRange(const ParmVarDecl &Param) {
return SourceRange(Param.getBeginLoc(), return SourceRange(Param.getBeginLoc(),
Param.getLocation().getLocWithOffset(-1)); Param.getLocation().getLocWithOffset(-1));
} }
} // namespace } // namespace
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Linesvoid AvoidConstParamsInDecls::check(const MatchFinder::MatchResult &Result) {
auto Tok = tidy::utils::lexer::getQualifyingToken( auto Tok = tidy::utils::lexer::getQualifyingToken(
tok::kw_const, FileRange, *Result.Context, *Result.SourceManager); tok::kw_const, FileRange, *Result.Context, *Result.SourceManager);
if (!Tok) if (!Tok)
return; return;
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
CharSourceRange::getTokenRange(Tok->getLocation(), Tok->getLocation())); CharSourceRange::getTokenRange(Tok->getLocation(), Tok->getLocation()));
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

//===--- BracesAroundStatementsCheck.cpp - clang-tidy ---------------------===// //===--- BracesAroundStatementsCheck.cpp - clang-tidy ---------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "BracesAroundStatementsCheck.h" #include "BracesAroundStatementsCheck.h"
#include "../utils/LexerUtils.h" #include "../utils/LexerUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
static tok::TokenKind getTokenKind(SourceLocation Loc, const SourceManager &SM, static tok::TokenKind getTokenKind(SourceLocation Loc, const SourceManager &SM,
const ASTContext *Context) { const ASTContext *Context) {
Token Tok; Token Tok;
SourceLocation Beginning = SourceLocation Beginning =
Lexer::GetBeginningOfToken(Loc, SM, Context->getLangOpts()); Lexer::GetBeginningOfToken(Loc, SM, Context->getLangOpts());
const bool Invalid = const bool Invalid =
Lexer::getRawToken(Beginning, Tok, SM, Context->getLangOpts()); Lexer::getRawToken(Beginning, Tok, SM, Context->getLangOpts());
▲ Show 20 Lines • Show All 236 Lines • ▼ Show 20 Lines Diag << FixItHint::CreateInsertion(StartLoc, " {")
<< FixItHint::CreateInsertion(EndLoc, ClosingInsertion); << FixItHint::CreateInsertion(EndLoc, ClosingInsertion);
return true; return true;
} }
void BracesAroundStatementsCheck::onEndOfTranslationUnit() { void BracesAroundStatementsCheck::onEndOfTranslationUnit() {
ForceBracesStmts.clear(); ForceBracesStmts.clear();
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/ConstReturnTypeCheck.cpp

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceLocation.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
// Finds the location of the qualifying `const` token in the `FunctionDecl`'s // Finds the location of the qualifying `const` token in the `FunctionDecl`'s
// return type. Returns `std::nullopt` when the return type is not // return type. Returns `std::nullopt` when the return type is not
// `const`-qualified or `const` does not appear in `Def`'s source, like when the // `const`-qualified or `const` does not appear in `Def`'s source, like when the
// type is an alias or a macro. // type is an alias or a macro.
static std::optional<Token> static std::optional<Token>
findConstToRemove(const FunctionDecl *Def, findConstToRemove(const FunctionDecl *Def,
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Lines CheckResult CR = checkDef(Def, Result);
for (auto &Hint : CR.Hints) for (auto &Hint : CR.Hints)
Diagnostic << Hint; Diagnostic << Hint;
} }
for (auto Loc : CR.DeclLocs) for (auto Loc : CR.DeclLocs)
diag(Loc, "could not transform this declaration", DiagnosticIDs::Note); diag(Loc, "could not transform this declaration", DiagnosticIDs::Note);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/ContainerContainsCheck.cpp

//===--- ContainerContainsCheck.cpp - clang-tidy --------------------------===// //===--- ContainerContainsCheck.cpp - clang-tidy --------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ContainerContainsCheck.h" #include "ContainerContainsCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void ContainerContainsCheck::registerMatchers(MatchFinder *Finder) { void ContainerContainsCheck::registerMatchers(MatchFinder *Finder) {
const auto SupportedContainers = hasType( const auto SupportedContainers = hasType(
hasUnqualifiedDesugaredType(recordType(hasDeclaration(cxxRecordDecl( hasUnqualifiedDesugaredType(recordType(hasDeclaration(cxxRecordDecl(
hasAnyName("::std::set", "::std::unordered_set", "::std::map", hasAnyName("::std::set", "::std::unordered_set", "::std::map",
"::std::unordered_map", "::std::multiset", "::std::unordered_map", "::std::multiset",
"::std::unordered_multiset", "::std::multimap", "::std::unordered_multiset", "::std::multimap",
"::std::unordered_multimap")))))); "::std::unordered_multimap"))))));
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Linesvoid ContainerContainsCheck::check(const MatchFinder::MatchResult &Result) {
SourceLocation CallEnd = Call->getSourceRange().getEnd(); SourceLocation CallEnd = Call->getSourceRange().getEnd();
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
CharSourceRange::getCharRange(ComparisonBegin, CallBegin), CharSourceRange::getCharRange(ComparisonBegin, CallBegin),
Negated ? "!" : ""); Negated ? "!" : "");
Diag << FixItHint::CreateRemoval(CharSourceRange::getCharRange( Diag << FixItHint::CreateRemoval(CharSourceRange::getCharRange(
CallEnd.getLocWithOffset(1), ComparisonEnd.getLocWithOffset(1))); CallEnd.getLocWithOffset(1), ComparisonEnd.getLocWithOffset(1)));
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/ContainerDataPointerCheck.cpp

//===--- ContainerDataPointerCheck.cpp - clang-tidy -----------------------===// //===--- ContainerDataPointerCheck.cpp - clang-tidy -----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ContainerDataPointerCheck.h" #include "ContainerDataPointerCheck.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
constexpr llvm::StringLiteral ContainerExprName = "container-expr"; constexpr llvm::StringLiteral ContainerExprName = "container-expr";
constexpr llvm::StringLiteral DerefContainerExprName = "deref-container-expr"; constexpr llvm::StringLiteral DerefContainerExprName = "deref-container-expr";
constexpr llvm::StringLiteral AddrOfContainerExprName = constexpr llvm::StringLiteral AddrOfContainerExprName =
"addr-of-container-expr"; "addr-of-container-expr";
constexpr llvm::StringLiteral AddressOfName = "address-of"; constexpr llvm::StringLiteral AddressOfName = "address-of";
ContainerDataPointerCheck::ContainerDataPointerCheck(StringRef Name, ContainerDataPointerCheck::ContainerDataPointerCheck(StringRef Name,
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linesvoid ContainerDataPointerCheck::check(const MatchFinder::MatchResult &Result) {
FixItHint Hint = FixItHint Hint =
FixItHint::CreateReplacement(UO->getSourceRange(), ReplacementText); FixItHint::CreateReplacement(UO->getSourceRange(), ReplacementText);
diag(UO->getBeginLoc(), diag(UO->getBeginLoc(),
"'data' should be used for accessing the data pointer instead of taking " "'data' should be used for accessing the data pointer instead of taking "
"the address of the 0-th element") "the address of the 0-th element")
<< Hint; << Hint;
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/ContainerSizeEmptyCheck.cpp

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
} }
AST_MATCHER(CXXConstructExpr, isDefaultConstruction) { AST_MATCHER(CXXConstructExpr, isDefaultConstruction) {
return Node.getConstructor()->isDefaultConstructor(); return Node.getConstructor()->isDefaultConstructor();
} }
AST_MATCHER(QualType, isIntegralType) { AST_MATCHER(QualType, isIntegralType) {
return Node->isIntegralType(Finder->getASTContext()); return Node->isIntegralType(Finder->getASTContext());
} }
} // namespace ast_matchers } // namespace ast_matchers
namespace tidy { namespace tidy::readability {
namespace readability {
using utils::isBinaryOrTernary; using utils::isBinaryOrTernary;
ContainerSizeEmptyCheck::ContainerSizeEmptyCheck(StringRef Name, ContainerSizeEmptyCheck::ContainerSizeEmptyCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void ContainerSizeEmptyCheck::registerMatchers(MatchFinder *Finder) { void ContainerSizeEmptyCheck::registerMatchers(MatchFinder *Finder) {
▲ Show 20 Lines • Show All 220 Lines • ▼ Show 20 Linesvoid ContainerSizeEmptyCheck::check(const MatchFinder::MatchResult &Result) {
} }
const auto *Empty = Result.Nodes.getNodeAs<FunctionDecl>("empty"); const auto *Empty = Result.Nodes.getNodeAs<FunctionDecl>("empty");
diag(Empty->getLocation(), "method %0::empty() defined here", diag(Empty->getLocation(), "method %0::empty() defined here",
DiagnosticIDs::Note) DiagnosticIDs::Note)
<< Container; << Container;
} }
} // namespace readability } // namespace tidy::readability
} // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/readability/ConvertMemberFunctionsToStatic.cpp

Show All 10 Lines
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
#include "clang/AST/RecursiveASTVisitor.h" #include "clang/AST/RecursiveASTVisitor.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceLocation.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
AST_MATCHER(CXXMethodDecl, isStatic) { return Node.isStatic(); } AST_MATCHER(CXXMethodDecl, isStatic) { return Node.isStatic(); }
AST_MATCHER(CXXMethodDecl, hasTrivialBody) { return Node.hasTrivialBody(); } AST_MATCHER(CXXMethodDecl, hasTrivialBody) { return Node.hasTrivialBody(); }
AST_MATCHER(CXXMethodDecl, isOverloadedOperator) { AST_MATCHER(CXXMethodDecl, isOverloadedOperator) {
return Node.isOverloadedOperator(); return Node.isOverloadedOperator();
} }
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines if (Definition->isConst()) {
} }
// Remove existing 'const' from both declaration and definition. // Remove existing 'const' from both declaration and definition.
Diag << FixItHint::CreateRemoval(DefConst); Diag << FixItHint::CreateRemoval(DefConst);
} }
Diag << FixItHint::CreateInsertion(Declaration->getBeginLoc(), "static "); Diag << FixItHint::CreateInsertion(Declaration->getBeginLoc(), "static ");
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/DeleteNullPointerCheck.cpp

//===--- DeleteNullPointerCheck.cpp - clang-tidy---------------------------===// //===--- DeleteNullPointerCheck.cpp - clang-tidy---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DeleteNullPointerCheck.h" #include "DeleteNullPointerCheck.h"
#include "../utils/LexerUtils.h" #include "../utils/LexerUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void DeleteNullPointerCheck::registerMatchers(MatchFinder *Finder) { void DeleteNullPointerCheck::registerMatchers(MatchFinder *Finder) {
const auto DeleteExpr = const auto DeleteExpr =
cxxDeleteExpr( cxxDeleteExpr(
has(declRefExpr(to(decl(equalsBoundNode("deletedPointer")))))) has(declRefExpr(to(decl(equalsBoundNode("deletedPointer"))))))
.bind("deleteExpr"); .bind("deleteExpr");
const auto DeleteMemberExpr = const auto DeleteMemberExpr =
Show All 40 Linesvoid DeleteNullPointerCheck::check(const MatchFinder::MatchResult &Result) {
if (Compound) { if (Compound) {
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
CharSourceRange::getTokenRange(Compound->getLBracLoc())); CharSourceRange::getTokenRange(Compound->getLBracLoc()));
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
CharSourceRange::getTokenRange(Compound->getRBracLoc())); CharSourceRange::getTokenRange(Compound->getRBracLoc()));
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/DuplicateIncludeCheck.cpp

//===--- DuplicateIncludeCheck.cpp - clang-tidy ---------------------------===// //===--- DuplicateIncludeCheck.cpp - clang-tidy ---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DuplicateIncludeCheck.h" #include "DuplicateIncludeCheck.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include <memory> #include <memory>
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
static SourceLocation advanceBeyondCurrentLine(const SourceManager &SM, static SourceLocation advanceBeyondCurrentLine(const SourceManager &SM,
SourceLocation Start, SourceLocation Start,
int Offset) { int Offset) {
const FileID Id = SM.getFileID(Start); const FileID Id = SM.getFileID(Start);
const unsigned LineNumber = SM.getSpellingLineNumber(Start); const unsigned LineNumber = SM.getSpellingLineNumber(Start);
while (SM.getFileID(Start) == Id && while (SM.getFileID(Start) == Id &&
SM.getSpellingLineNumber(Start.getLocWithOffset(Offset)) == LineNumber) SM.getSpellingLineNumber(Start.getLocWithOffset(Offset)) == LineNumber)
▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void DuplicateIncludeCheck::registerPPCallbacks( void DuplicateIncludeCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
PP->addPPCallbacks(std::make_unique<DuplicateIncludeCallbacks>(*this, SM)); PP->addPPCallbacks(std::make_unique<DuplicateIncludeCallbacks>(*this, SM));
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/ElseAfterReturnCheck.cpp

Show All 10 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
class PPConditionalCollector : public PPCallbacks { class PPConditionalCollector : public PPCallbacks {
public: public:
PPConditionalCollector( PPConditionalCollector(
ElseAfterReturnCheck::ConditionalBranchMap &Collections, ElseAfterReturnCheck::ConditionalBranchMap &Collections,
const SourceManager &SM) const SourceManager &SM)
▲ Show 20 Lines • Show All 289 Lines • ▼ Show 20 Lines if (checkInitDeclUsageInElse(If) != nullptr) {
return; return;
} }
DiagnosticBuilder Diag = diag(ElseLoc, WarningMessage) DiagnosticBuilder Diag = diag(ElseLoc, WarningMessage)
<< ControlFlowInterruptor << SourceRange(ElseLoc); << ControlFlowInterruptor << SourceRange(ElseLoc);
removeElseAndBrackets(Diag, *Result.Context, Else, ElseLoc); removeElseAndBrackets(Diag, *Result.Context, Else, ElseLoc);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/FunctionCognitiveComplexityCheck.cpp

Show All 27 Lines
#include <optional> #include <optional>
#include <stack> #include <stack>
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <utility> #include <utility>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
struct CognitiveComplexity final { struct CognitiveComplexity final {
// Any increment is based on some combination of reasons. // Any increment is based on some combination of reasons.
// For details you can look at the Specification at // For details you can look at the Specification at
// https://www.sonarsource.com/docs/CognitiveComplexity.pdf // https://www.sonarsource.com/docs/CognitiveComplexity.pdf
// or user-facing docs at // or user-facing docs at
// http://clang.llvm.org/extra/clang-tidy/checks/readability/function-cognitive-complexity.html // http://clang.llvm.org/extra/clang-tidy/checks/readability/function-cognitive-complexity.html
▲ Show 20 Lines • Show All 510 Lines • ▼ Show 20 Lines for (const auto &Detail : Visitor.CC.Details) {
assert(MsgId < Msgs.size() && "MsgId should always be valid"); assert(MsgId < Msgs.size() && "MsgId should always be valid");
// Increase, on the other hand, can be 0. // Increase, on the other hand, can be 0.
diag(Detail.Loc, Msgs[MsgId], DiagnosticIDs::Note) diag(Detail.Loc, Msgs[MsgId], DiagnosticIDs::Note)
<< (unsigned)Increase << (unsigned)Detail.Nesting << 1 + Detail.Nesting; << (unsigned)Increase << (unsigned)Detail.Nesting << 1 + Detail.Nesting;
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/FunctionSizeCheck.cpp

//===-- FunctionSizeCheck.cpp - clang-tidy --------------------------------===// //===-- FunctionSizeCheck.cpp - clang-tidy --------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FunctionSizeCheck.h" #include "FunctionSizeCheck.h"
#include "clang/AST/RecursiveASTVisitor.h" #include "clang/AST/RecursiveASTVisitor.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/BitVector.h" #include "llvm/ADT/BitVector.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
class FunctionASTVisitor : public RecursiveASTVisitor<FunctionASTVisitor> { class FunctionASTVisitor : public RecursiveASTVisitor<FunctionASTVisitor> {
using Base = RecursiveASTVisitor<FunctionASTVisitor>; using Base = RecursiveASTVisitor<FunctionASTVisitor>;
public: public:
bool VisitVarDecl(VarDecl *VD) { bool VisitVarDecl(VarDecl *VD) {
// Do not count function params. // Do not count function params.
▲ Show 20 Lines • Show All 189 Lines • ▼ Show 20 Linesvoid FunctionSizeCheck::check(const MatchFinder::MatchResult &Result) {
if (FI.Variables > VariableThreshold) { if (FI.Variables > VariableThreshold) {
diag(Func->getLocation(), "%0 variables (threshold %1)", diag(Func->getLocation(), "%0 variables (threshold %1)",
DiagnosticIDs::Note) DiagnosticIDs::Note)
<< FI.Variables << VariableThreshold; << FI.Variables << VariableThreshold;
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/IdentifierLengthCheck.cpp

//===--- IdentifierLengthCheck.cpp - clang-tidy //===--- IdentifierLengthCheck.cpp - clang-tidy
//-----------------------------===// //-----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "IdentifierLengthCheck.h" #include "IdentifierLengthCheck.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
const unsigned DefaultMinimumVariableNameLength = 3; const unsigned DefaultMinimumVariableNameLength = 3;
const unsigned DefaultMinimumLoopCounterNameLength = 2; const unsigned DefaultMinimumLoopCounterNameLength = 2;
const unsigned DefaultMinimumExceptionNameLength = 2; const unsigned DefaultMinimumExceptionNameLength = 2;
const unsigned DefaultMinimumParameterNameLength = 3; const unsigned DefaultMinimumParameterNameLength = 3;
const char DefaultIgnoredLoopCounterNames[] = "^[ijk_]$"; const char DefaultIgnoredLoopCounterNames[] = "^[ijk_]$";
const char DefaultIgnoredVariableNames[] = ""; const char DefaultIgnoredVariableNames[] = "";
const char DefaultIgnoredExceptionVariableNames[] = "^[e]$"; const char DefaultIgnoredExceptionVariableNames[] = "^[e]$";
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines if (VarName.size() >= MinimumParameterNameLength ||
IgnoredParameterNames.match(VarName)) IgnoredParameterNames.match(VarName))
return; return;
diag(ParamVar->getLocation(), ErrorMessage) diag(ParamVar->getLocation(), ErrorMessage)
<< 3 << ParamVar << MinimumParameterNameLength; << 3 << ParamVar << MinimumParameterNameLength;
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

Show All 22 Lines
#include <optional> #include <optional>
#define DEBUG_TYPE "clang-tidy" #define DEBUG_TYPE "clang-tidy"
// FixItHint // FixItHint
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
llvm::ArrayRef< llvm::ArrayRef<
std::pair<readability::IdentifierNamingCheck::CaseType, StringRef>> std::pair<readability::IdentifierNamingCheck::CaseType, StringRef>>
OptionEnumMapping< OptionEnumMapping<
readability::IdentifierNamingCheck::CaseType>::getEnumMapping() { readability::IdentifierNamingCheck::CaseType>::getEnumMapping() {
static constexpr std::pair<readability::IdentifierNamingCheck::CaseType, static constexpr std::pair<readability::IdentifierNamingCheck::CaseType,
StringRef> StringRef>
Mapping[] = { Mapping[] = {
▲ Show 20 Lines • Show All 1,405 Lines • ▼ Show 20 LinesIdentifierNamingCheck::getStyleForFile(StringRef FileName) const {
} }
// Default construction gives an empty style. // Default construction gives an empty style.
auto It = NamingStylesCache.try_emplace(Parent); auto It = NamingStylesCache.try_emplace(Parent);
assert(It.second); assert(It.second);
return It.first->getValue(); return It.first->getValue();
} }
} // namespace readability } // namespace readability
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/ImplicitBoolConversionCheck.cpp

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
#include <queue> #include <queue>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
AST_MATCHER(Stmt, isMacroExpansion) { AST_MATCHER(Stmt, isMacroExpansion) {
SourceManager &SM = Finder->getASTContext().getSourceManager(); SourceManager &SM = Finder->getASTContext().getSourceManager();
SourceLocation Loc = Node.getBeginLoc(); SourceLocation Loc = Node.getBeginLoc();
return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc); return SM.isMacroBodyExpansion(Loc) || SM.isMacroArgExpansion(Loc);
} }
▲ Show 20 Lines • Show All 357 Lines • ▼ Show 20 Lines if (const auto *BoolLiteral =
dyn_cast<CXXBoolLiteralExpr>(Cast->getSubExpr())) { dyn_cast<CXXBoolLiteralExpr>(Cast->getSubExpr())) {
Diag << tooling::fixit::createReplacement( Diag << tooling::fixit::createReplacement(
*Cast, getEquivalentForBoolLiteral(BoolLiteral, DestType, Context)); *Cast, getEquivalentForBoolLiteral(BoolLiteral, DestType, Context));
} else { } else {
fixGenericExprCastFromBool(Diag, Cast, Context, DestType.getAsString()); fixGenericExprCastFromBool(Diag, Cast, Context, DestType.getAsString());
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include <functional> #include <functional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
AST_MATCHER(FunctionDecl, hasOtherDeclarations) { AST_MATCHER(FunctionDecl, hasOtherDeclarations) {
auto It = Node.redecls_begin(); auto It = Node.redecls_begin();
auto EndIt = Node.redecls_end(); auto EndIt = Node.redecls_end();
if (It == EndIt) if (It == EndIt)
▲ Show 20 Lines • Show All 316 Lines • ▼ Show 20 Lines
void InconsistentDeclarationParameterNameCheck::markRedeclarationsAsVisited( void InconsistentDeclarationParameterNameCheck::markRedeclarationsAsVisited(
const FunctionDecl *OriginalDeclaration) { const FunctionDecl *OriginalDeclaration) {
for (const FunctionDecl *Redecl : OriginalDeclaration->redecls()) { for (const FunctionDecl *Redecl : OriginalDeclaration->redecls()) {
VisitedDeclarations.insert(Redecl); VisitedDeclarations.insert(Redecl);
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/IsolateDeclarationCheck.cpp

//===--- IsolateDeclarationCheck.cpp - clang-tidy -------------------------===// //===--- IsolateDeclarationCheck.cpp - clang-tidy -------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "IsolateDeclarationCheck.h" #include "IsolateDeclarationCheck.h"
#include "../utils/LexerUtils.h" #include "../utils/LexerUtils.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::tidy::utils::lexer; using namespace clang::tidy::utils::lexer;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
AST_MATCHER(DeclStmt, isSingleDecl) { return Node.isSingleDecl(); } AST_MATCHER(DeclStmt, isSingleDecl) { return Node.isSingleDecl(); }
AST_MATCHER(DeclStmt, onlyDeclaresVariables) { AST_MATCHER(DeclStmt, onlyDeclaresVariables) {
return llvm::all_of(Node.decls(), [](Decl *D) { return isa<VarDecl>(D); }); return llvm::all_of(Node.decls(), [](Decl *D) { return isa<VarDecl>(D); });
} }
} // namespace } // namespace
▲ Show 20 Lines • Show All 240 Lines • ▼ Show 20 Lines std::string Replacement = llvm::join(
NewDecls, NewDecls,
(Twine("\n") + Lexer::getIndentationForLine(WholeDecl->getBeginLoc(), (Twine("\n") + Lexer::getIndentationForLine(WholeDecl->getBeginLoc(),
*Result.SourceManager)) *Result.SourceManager))
.str()); .str());
Diag << FixItHint::CreateReplacement(WholeDecl->getSourceRange(), Diag << FixItHint::CreateReplacement(WholeDecl->getSourceRange(),
Replacement); Replacement);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/MagicNumbersCheck.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines if (AsFieldDecl && AsFieldDecl->isBitField())
return true; return true;
return llvm::any_of(Result.Context->getParents(Node), return llvm::any_of(Result.Context->getParents(Node),
[&Result](const DynTypedNode &Parent) { [&Result](const DynTypedNode &Parent) {
return isUsedToDefineABitField(Result, Parent); return isUsedToDefineABitField(Result, Parent);
}); });
} }
namespace tidy { namespace tidy::readability {
namespace readability {
const char DefaultIgnoredIntegerValues[] = "1;2;3;4;"; const char DefaultIgnoredIntegerValues[] = "1;2;3;4;";
const char DefaultIgnoredFloatingPointValues[] = "1.0;100.0;"; const char DefaultIgnoredFloatingPointValues[] = "1.0;100.0;";
MagicNumbersCheck::MagicNumbersCheck(StringRef Name, ClangTidyContext *Context) MagicNumbersCheck::MagicNumbersCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
IgnoreAllFloatingPointValues( IgnoreAllFloatingPointValues(
Options.get("IgnoreAllFloatingPointValues", false)), Options.get("IgnoreAllFloatingPointValues", false)),
▲ Show 20 Lines • Show All 153 Lines • ▼ Show 20 Linesbool MagicNumbersCheck::isBitFieldWidth(
const IntegerLiteral &Literal) const { const IntegerLiteral &Literal) const {
return IgnoreBitFieldsWidths && return IgnoreBitFieldsWidths &&
llvm::any_of(Result.Context->getParents(Literal), llvm::any_of(Result.Context->getParents(Literal),
[&Result](const DynTypedNode &Parent) { [&Result](const DynTypedNode &Parent) {
return isUsedToDefineABitField(Result, Parent); return isUsedToDefineABitField(Result, Parent);
}); });
} }
} // namespace readability } // namespace tidy::readability
} // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/clang-tidy/readability/MakeMemberFunctionConstCheck.cpp

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/ParentMapContext.h" #include "clang/AST/ParentMapContext.h"
#include "clang/AST/RecursiveASTVisitor.h" #include "clang/AST/RecursiveASTVisitor.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
AST_MATCHER(CXXMethodDecl, isStatic) { return Node.isStatic(); } AST_MATCHER(CXXMethodDecl, isStatic) { return Node.isStatic(); }
AST_MATCHER(CXXMethodDecl, hasTrivialBody) { return Node.hasTrivialBody(); } AST_MATCHER(CXXMethodDecl, hasTrivialBody) { return Node.hasTrivialBody(); }
AST_MATCHER(CXXRecordDecl, hasAnyDependentBases) { AST_MATCHER(CXXRecordDecl, hasAnyDependentBases) {
return Node.hasAnyDependentBases(); return Node.hasAnyDependentBases();
} }
▲ Show 20 Lines • Show All 233 Lines • ▼ Show 20 Lines auto Diag = diag(Definition->getLocation(), "method %0 can be made const")
<< FixItHint::CreateInsertion(getConstInsertionPoint(Definition), << FixItHint::CreateInsertion(getConstInsertionPoint(Definition),
" const"); " const");
if (Declaration != Definition) { if (Declaration != Definition) {
Diag << FixItHint::CreateInsertion(getConstInsertionPoint(Declaration), Diag << FixItHint::CreateInsertion(getConstInsertionPoint(Declaration),
" const"); " const");
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/MisleadingIndentationCheck.cpp

//===--- MisleadingIndentationCheck.cpp - clang-tidy-----------------------===// //===--- MisleadingIndentationCheck.cpp - clang-tidy-----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MisleadingIndentationCheck.h" #include "MisleadingIndentationCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
static const IfStmt *getPrecedingIf(const SourceManager &SM, static const IfStmt *getPrecedingIf(const SourceManager &SM,
ASTContext *Context, const IfStmt *If) { ASTContext *Context, const IfStmt *If) {
auto Parents = Context->getParents(*If); auto Parents = Context->getParents(*If);
if (Parents.size() != 1) if (Parents.size() != 1)
return nullptr; return nullptr;
if (const auto *PrecedingIf = Parents[0].get<IfStmt>()) { if (const auto *PrecedingIf = Parents[0].get<IfStmt>()) {
SourceLocation PreviousElseLoc = PrecedingIf->getElseLoc(); SourceLocation PreviousElseLoc = PrecedingIf->getElseLoc();
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines
void MisleadingIndentationCheck::check(const MatchFinder::MatchResult &Result) { void MisleadingIndentationCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *If = Result.Nodes.getNodeAs<IfStmt>("if")) if (const auto *If = Result.Nodes.getNodeAs<IfStmt>("if"))
danglingElseCheck(*Result.SourceManager, Result.Context, If); danglingElseCheck(*Result.SourceManager, Result.Context, If);
if (const auto *CStmt = Result.Nodes.getNodeAs<CompoundStmt>("compound")) if (const auto *CStmt = Result.Nodes.getNodeAs<CompoundStmt>("compound"))
missingBracesCheck(*Result.SourceManager, CStmt); missingBracesCheck(*Result.SourceManager, CStmt);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/MisplacedArrayIndexCheck.cpp

//===--- MisplacedArrayIndexCheck.cpp - clang-tidy-------------------------===// //===--- MisplacedArrayIndexCheck.cpp - clang-tidy-------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "MisplacedArrayIndexCheck.h" #include "MisplacedArrayIndexCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void MisplacedArrayIndexCheck::registerMatchers(MatchFinder *Finder) { void MisplacedArrayIndexCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse(TK_AsIs, arraySubscriptExpr(hasLHS(hasType(isInteger())), traverse(TK_AsIs, arraySubscriptExpr(hasLHS(hasType(isInteger())),
hasRHS(hasType(isAnyPointer()))) hasRHS(hasType(isAnyPointer())))
.bind("expr")), .bind("expr")),
this); this);
} }
Show All 19 Lines const StringRef RText = tooling::fixit::getText(
ArraySubscriptE->getRHS()->getSourceRange(), *Result.Context); ArraySubscriptE->getRHS()->getSourceRange(), *Result.Context);
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
ArraySubscriptE->getLHS()->getSourceRange(), RText); ArraySubscriptE->getLHS()->getSourceRange(), RText);
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
ArraySubscriptE->getRHS()->getSourceRange(), LText); ArraySubscriptE->getRHS()->getSourceRange(), LText);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/NamedParameterCheck.cpp

//===--- NamedParameterCheck.cpp - clang-tidy -------------------*- C++ -*-===// //===--- NamedParameterCheck.cpp - clang-tidy -------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NamedParameterCheck.h" #include "NamedParameterCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void NamedParameterCheck::registerMatchers(ast_matchers::MatchFinder *Finder) { void NamedParameterCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
Finder->addMatcher(functionDecl().bind("decl"), this); Finder->addMatcher(functionDecl().bind("decl"), this);
} }
void NamedParameterCheck::check(const MatchFinder::MatchResult &Result) { void NamedParameterCheck::check(const MatchFinder::MatchResult &Result) {
const SourceManager &SM = *Result.SourceManager; const SourceManager &SM = *Result.SourceManager;
const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("decl"); const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("decl");
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines for (auto P : UnnamedParams) {
// function pointers right. // function pointers right.
const ParmVarDecl *Parm = P.first->getParamDecl(P.second); const ParmVarDecl *Parm = P.first->getParamDecl(P.second);
D << FixItHint::CreateInsertion(Parm->getLocation(), D << FixItHint::CreateInsertion(Parm->getLocation(),
" /*" + NewName.str() + "*/"); " /*" + NewName.str() + "*/");
} }
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

Show All 12 Lines
#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceLocation.h"
#include "clang/Basic/TokenKinds.h" #include "clang/Basic/TokenKinds.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
NamespaceCommentCheck::NamespaceCommentCheck(StringRef Name, NamespaceCommentCheck::NamespaceCommentCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
NamespaceCommentPattern("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *" NamespaceCommentPattern("^/[/*] *(end (of )?)? *(anonymous|unnamed)? *"
"namespace( +([a-zA-Z0-9_:]+))?\\.? *(\\*/)?$", "namespace( +([a-zA-Z0-9_:]+))?\\.? *(\\*/)?$",
llvm::Regex::IgnoreCase), llvm::Regex::IgnoreCase),
ShortNamespaceLines(Options.get("ShortNamespaceLines", 1u)), ShortNamespaceLines(Options.get("ShortNamespaceLines", 1u)),
▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Linesvoid NamespaceCommentCheck::check(const MatchFinder::MatchResult &Result) {
diag(DiagLoc, Message) << NamespaceNameForDiag diag(DiagLoc, Message) << NamespaceNameForDiag
<< FixItHint::CreateReplacement( << FixItHint::CreateReplacement(
CharSourceRange::getCharRange(OldCommentRange), CharSourceRange::getCharRange(OldCommentRange),
Fix); Fix);
diag(ND->getLocation(), "%0 starts here", DiagnosticIDs::Note) diag(ND->getLocation(), "%0 starts here", DiagnosticIDs::Note)
<< NamespaceNameForDiag; << NamespaceNameForDiag;
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/NonConstParameterCheck.cpp

//===--- NonConstParameterCheck.cpp - clang-tidy---------------------------===// //===--- NonConstParameterCheck.cpp - clang-tidy---------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NonConstParameterCheck.h" #include "NonConstParameterCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void NonConstParameterCheck::registerMatchers(MatchFinder *Finder) { void NonConstParameterCheck::registerMatchers(MatchFinder *Finder) {
// Add parameters to Parameters. // Add parameters to Parameters.
Finder->addMatcher(parmVarDecl().bind("Parm"), this); Finder->addMatcher(parmVarDecl().bind("Parm"), this);
// C++ constructor. // C++ constructor.
Finder->addMatcher(cxxConstructorDecl().bind("Ctor"), this); Finder->addMatcher(cxxConstructorDecl().bind("Ctor"), this);
▲ Show 20 Lines • Show All 202 Lines • ▼ Show 20 Lines if (const auto *B = dyn_cast<BinaryOperator>(E)) {
if (const auto *D = dyn_cast<DeclRefExpr>(E)) { if (const auto *D = dyn_cast<DeclRefExpr>(E)) {
auto It = Parameters.find(dyn_cast<ParmVarDecl>(D->getDecl())); auto It = Parameters.find(dyn_cast<ParmVarDecl>(D->getDecl()));
if (It != Parameters.end()) if (It != Parameters.end())
It->second.CanBeConst = false; It->second.CanBeConst = false;
} }
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp

//===--- QualifiedAutoCheck.cpp - clang-tidy ------------------------------===// //===--- QualifiedAutoCheck.cpp - clang-tidy ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "QualifiedAutoCheck.h" #include "QualifiedAutoCheck.h"
#include "../utils/LexerUtils.h" #include "../utils/LexerUtils.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
// FIXME move to ASTMatchers // FIXME move to ASTMatchers
AST_MATCHER_P(QualType, hasUnqualifiedType, AST_MATCHER_P(QualType, hasUnqualifiedType,
ast_matchers::internal::Matcher<QualType>, InnerMatcher) { ast_matchers::internal::Matcher<QualType>, InnerMatcher) {
return InnerMatcher.matches(Node.getUnqualifiedType(), Finder, Builder); return InnerMatcher.matches(Node.getUnqualifiedType(), Finder, Builder);
} }
▲ Show 20 Lines • Show All 253 Lines • ▼ Show 20 Lines if (std::optional<SourceRange> TypeSpec =
SourceLocation InsertPos = TypeSpec->getBegin(); SourceLocation InsertPos = TypeSpec->getBegin();
diag(InsertPos, "'auto &%0' can be declared as 'const auto &%0'") diag(InsertPos, "'auto &%0' can be declared as 'const auto &%0'")
<< Var->getName() << FixItHint::CreateInsertion(InsertPos, "const "); << Var->getName() << FixItHint::CreateInsertion(InsertPos, "const ");
} }
return; return;
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/ReadabilityTidyModule.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
#include "StaticAccessedThroughInstanceCheck.h" #include "StaticAccessedThroughInstanceCheck.h"
#include "StaticDefinitionInAnonymousNamespaceCheck.h" #include "StaticDefinitionInAnonymousNamespaceCheck.h"
#include "StringCompareCheck.h" #include "StringCompareCheck.h"
#include "SuspiciousCallArgumentCheck.h" #include "SuspiciousCallArgumentCheck.h"
#include "UniqueptrDeleteReleaseCheck.h" #include "UniqueptrDeleteReleaseCheck.h"
#include "UppercaseLiteralSuffixCheck.h" #include "UppercaseLiteralSuffixCheck.h"
#include "UseAnyOfAllOfCheck.h" #include "UseAnyOfAllOfCheck.h"
namespace clang { namespace clang::tidy {
namespace tidy {
namespace readability { namespace readability {
class ReadabilityModule : public ClangTidyModule { class ReadabilityModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<AvoidConstParamsInDecls>( CheckFactories.registerCheck<AvoidConstParamsInDecls>(
"readability-avoid-const-params-in-decls"); "readability-avoid-const-params-in-decls");
CheckFactories.registerCheck<BracesAroundStatementsCheck>( CheckFactories.registerCheck<BracesAroundStatementsCheck>(
▲ Show 20 Lines • Show All 86 Lines • ▼ Show 20 Linesstatic ClangTidyModuleRegistry::Add<ReadabilityModule>
X("readability-module", "Adds readability-related checks."); X("readability-module", "Adds readability-related checks.");
} // namespace readability } // namespace readability
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the ReadabilityModule. // and thus register the ReadabilityModule.
volatile int ReadabilityModuleAnchorSource = 0; volatile int ReadabilityModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/RedundantAccessSpecifiersCheck.cpp

//===--- RedundantAccessSpecifiersCheck.cpp - clang-tidy ------------------===// //===--- RedundantAccessSpecifiersCheck.cpp - clang-tidy ------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RedundantAccessSpecifiersCheck.h" #include "RedundantAccessSpecifiersCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void RedundantAccessSpecifiersCheck::registerMatchers(MatchFinder *Finder) { void RedundantAccessSpecifiersCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
cxxRecordDecl(has(accessSpecDecl())).bind("redundant-access-specifiers"), cxxRecordDecl(has(accessSpecDecl())).bind("redundant-access-specifiers"),
this); this);
} }
void RedundantAccessSpecifiersCheck::check( void RedundantAccessSpecifiersCheck::check(
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines if (LastASDecl->getAccess() == ASDecl->getAccess()) {
diag(LastASDecl->getLocation(), "previously declared here", diag(LastASDecl->getLocation(), "previously declared here",
DiagnosticIDs::Note); DiagnosticIDs::Note);
} else { } else {
LastASDecl = ASDecl; LastASDecl = ASDecl;
} }
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

//===--- RedundantControlFlowCheck.cpp - clang-tidy------------------------===// //===--- RedundantControlFlowCheck.cpp - clang-tidy------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RedundantControlFlowCheck.h" #include "RedundantControlFlowCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
const char *const RedundantReturnDiag = "redundant return statement at the end " const char *const RedundantReturnDiag = "redundant return statement at the end "
"of a function with a void return type"; "of a function with a void return type";
const char *const RedundantContinueDiag = "redundant continue statement at the " const char *const RedundantContinueDiag = "redundant continue statement at the "
"end of loop statement"; "end of loop statement";
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Linesvoid RedundantControlFlowCheck::issueDiagnostic(
auto RemovedRange = CharSourceRange::getCharRange( auto RemovedRange = CharSourceRange::getCharRange(
Start, Lexer::findLocationAfterToken( Start, Lexer::findLocationAfterToken(
StmtRange.getEnd(), tok::semi, SM, getLangOpts(), StmtRange.getEnd(), tok::semi, SM, getLangOpts(),
/*SkipTrailingWhitespaceAndNewLine=*/true)); /*SkipTrailingWhitespaceAndNewLine=*/true));
diag(StmtRange.getBegin(), Diag) << FixItHint::CreateRemoval(RemovedRange); diag(StmtRange.getBegin(), Diag) << FixItHint::CreateRemoval(RemovedRange);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

//===--- RedundantDeclarationCheck.cpp - clang-tidy------------------------===// //===--- RedundantDeclarationCheck.cpp - clang-tidy------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RedundantDeclarationCheck.h" #include "RedundantDeclarationCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
AST_MATCHER(FunctionDecl, doesDeclarationForceExternallyVisibleDefinition) { AST_MATCHER(FunctionDecl, doesDeclarationForceExternallyVisibleDefinition) {
return Node.doesDeclarationForceExternallyVisibleDefinition(); return Node.doesDeclarationForceExternallyVisibleDefinition();
} }
RedundantDeclarationCheck::RedundantDeclarationCheck(StringRef Name, RedundantDeclarationCheck::RedundantDeclarationCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesvoid RedundantDeclarationCheck::check(const MatchFinder::MatchResult &Result) {
{ {
auto Diag = diag(D->getLocation(), "redundant %0 declaration") << D; auto Diag = diag(D->getLocation(), "redundant %0 declaration") << D;
if (!MultiVar && !DifferentHeaders) if (!MultiVar && !DifferentHeaders)
Diag << FixItHint::CreateRemoval( Diag << FixItHint::CreateRemoval(
SourceRange(D->getSourceRange().getBegin(), EndLoc)); SourceRange(D->getSourceRange().getBegin(), EndLoc));
} }
diag(Prev->getLocation(), "previously declared here", DiagnosticIDs::Note); diag(Prev->getLocation(), "previously declared here", DiagnosticIDs::Note);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/RedundantFunctionPtrDereferenceCheck.cpp

//===--- RedundantFunctionPtrDereferenceCheck.cpp - clang-tidy-------------===// //===--- RedundantFunctionPtrDereferenceCheck.cpp - clang-tidy-------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RedundantFunctionPtrDereferenceCheck.h" #include "RedundantFunctionPtrDereferenceCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void RedundantFunctionPtrDereferenceCheck::registerMatchers(MatchFinder *Finder) { void RedundantFunctionPtrDereferenceCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
traverse(TK_AsIs, unaryOperator(hasOperatorName("*"), traverse(TK_AsIs, unaryOperator(hasOperatorName("*"),
has(implicitCastExpr(hasCastKind( has(implicitCastExpr(hasCastKind(
CK_FunctionToPointerDecay)))) CK_FunctionToPointerDecay))))
.bind("op")), .bind("op")),
this); this);
} }
void RedundantFunctionPtrDereferenceCheck::check(const MatchFinder::MatchResult &Result) { void RedundantFunctionPtrDereferenceCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Operator = Result.Nodes.getNodeAs<UnaryOperator>("op"); const auto *Operator = Result.Nodes.getNodeAs<UnaryOperator>("op");
diag(Operator->getOperatorLoc(), diag(Operator->getOperatorLoc(),
"redundant repeated dereference of function pointer") "redundant repeated dereference of function pointer")
<< FixItHint::CreateRemoval(Operator->getOperatorLoc()); << FixItHint::CreateRemoval(Operator->getOperatorLoc());
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include <algorithm> #include <algorithm>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::tidy::matchers; using namespace clang::tidy::matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void RedundantMemberInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void RedundantMemberInitCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IgnoreBaseInCopyConstructors", Options.store(Opts, "IgnoreBaseInCopyConstructors",
IgnoreBaseInCopyConstructors); IgnoreBaseInCopyConstructors);
} }
void RedundantMemberInitCheck::registerMatchers(MatchFinder *Finder) { void RedundantMemberInitCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
Show All 34 Lines if (Init->isAnyMemberInitializer()) {
diag(Init->getSourceLocation(), diag(Init->getSourceLocation(),
"initializer for base class %0 is redundant") "initializer for base class %0 is redundant")
<< Construct->getType() << Construct->getType()
<< FixItHint::CreateRemoval(Init->getSourceRange()); << FixItHint::CreateRemoval(Init->getSourceRange());
} }
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/RedundantPreprocessorCheck.cpp

//===--- RedundantPreprocessorCheck.cpp - clang-tidy ----------------------===// //===--- RedundantPreprocessorCheck.cpp - clang-tidy ----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RedundantPreprocessorCheck.h" #include "RedundantPreprocessorCheck.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
/// Information about an opening preprocessor directive. /// Information about an opening preprocessor directive.
struct PreprocessorEntry { struct PreprocessorEntry {
SourceLocation Loc; SourceLocation Loc;
/// Condition used after the preprocessor directive. /// Condition used after the preprocessor directive.
std::string Condition; std::string Condition;
}; };
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
} // namespace } // namespace
void RedundantPreprocessorCheck::registerPPCallbacks( void RedundantPreprocessorCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
PP->addPPCallbacks( PP->addPPCallbacks(
::std::make_unique<RedundantPreprocessorCallbacks>(*this, *PP)); ::std::make_unique<RedundantPreprocessorCallbacks>(*this, *PP));
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/RedundantSmartptrGetCheck.cpp

//===--- RedundantSmartptrGetCheck.cpp - clang-tidy -----------------------===// //===--- RedundantSmartptrGetCheck.cpp - clang-tidy -----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RedundantSmartptrGetCheck.h" #include "RedundantSmartptrGetCheck.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
internal::Matcher<Expr> callToGet(const internal::Matcher<Decl> &OnClass) { internal::Matcher<Expr> callToGet(const internal::Matcher<Decl> &OnClass) {
return expr( return expr(
anyOf(cxxMemberCallExpr( anyOf(cxxMemberCallExpr(
on(expr(anyOf(hasType(OnClass), on(expr(anyOf(hasType(OnClass),
hasType(qualType(pointsTo( hasType(qualType(pointsTo(
decl(OnClass).bind("ptr_to_ptr")))))) decl(OnClass).bind("ptr_to_ptr"))))))
▲ Show 20 Lines • Show All 141 Lines • ▼ Show 20 Lines StringRef SmartptrText = Lexer::getSourceText(
CharSourceRange::getTokenRange(Smartptr->getSourceRange()), CharSourceRange::getTokenRange(Smartptr->getSourceRange()),
*Result.SourceManager, getLangOpts()); *Result.SourceManager, getLangOpts());
// Replace foo->get() with *foo, and foo.get() with foo. // Replace foo->get() with *foo, and foo.get() with foo.
std::string Replacement = Twine(IsPtrToPtr ? "*" : "", SmartptrText).str(); std::string Replacement = Twine(IsPtrToPtr ? "*" : "", SmartptrText).str();
diag(GetCall->getBeginLoc(), "redundant get() call on smart pointer") diag(GetCall->getBeginLoc(), "redundant get() call on smart pointer")
<< FixItHint::CreateReplacement(SR, Replacement); << FixItHint::CreateReplacement(SR, Replacement);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

Show All 10 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "RedundantStringCStrCheck.h" #include "RedundantStringCStrCheck.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
// Return true if expr needs to be put in parens when it is an argument of a // Return true if expr needs to be put in parens when it is an argument of a
// prefix unary operator, e.g. when it is a binary or ternary operator // prefix unary operator, e.g. when it is a binary or ternary operator
// syntactically. // syntactically.
bool needParensAfterUnaryOperator(const Expr &ExprNode) { bool needParensAfterUnaryOperator(const Expr &ExprNode) {
if (isa<clang::BinaryOperator>(&ExprNode) || if (isa<clang::BinaryOperator>(&ExprNode) ||
▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 Linesvoid RedundantStringCStrCheck::check(const MatchFinder::MatchResult &Result) {
if (ArgText.empty()) if (ArgText.empty())
return; return;
diag(Call->getBeginLoc(), "redundant call to %0") diag(Call->getBeginLoc(), "redundant call to %0")
<< Member->getMemberDecl() << Member->getMemberDecl()
<< FixItHint::CreateReplacement(Call->getSourceRange(), ArgText); << FixItHint::CreateReplacement(Call->getSourceRange(), ArgText);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "../utils/Matchers.h" #include "../utils/Matchers.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::tidy::matchers; using namespace clang::tidy::matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
const char DefaultStringNames[] = const char DefaultStringNames[] =
"::std::basic_string_view;::std::basic_string"; "::std::basic_string_view;::std::basic_string";
static std::vector<StringRef> removeNamespaces(ArrayRef<StringRef> Names) { static std::vector<StringRef> removeNamespaces(ArrayRef<StringRef> Names) {
std::vector<StringRef> Result; std::vector<StringRef> Result;
Result.reserve(Names.size()); Result.reserve(Names.size());
for (StringRef Name : Names) { for (StringRef Name : Names) {
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines if (!Construct)
return; return;
if (std::optional<SourceRange> RemovalRange = if (std::optional<SourceRange> RemovalRange =
getConstructExprArgRange(*Construct)) getConstructExprArgRange(*Construct))
diag(CtorInit->getMemberLocation(), "redundant string initialization") diag(CtorInit->getMemberLocation(), "redundant string initialization")
<< FixItHint::CreateRemoval(*RemovalRange); << FixItHint::CreateRemoval(*RemovalRange);
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp

Show All 11 Lines
#include "llvm/Support/SaveAndRestore.h" #include "llvm/Support/SaveAndRestore.h"
#include <optional> #include <optional>
#include <string> #include <string>
#include <utility> #include <utility>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
StringRef getText(const ASTContext &Context, SourceRange Range) { StringRef getText(const ASTContext &Context, SourceRange Range) {
return Lexer::getSourceText(CharSourceRange::getTokenRange(Range), return Lexer::getSourceText(CharSourceRange::getTokenRange(Range),
Context.getSourceManager(), Context.getSourceManager(),
Context.getLangOpts()); Context.getLangOpts());
} }
▲ Show 20 Lines • Show All 921 Lines • ▼ Show 20 Linesbool SimplifyBooleanExprCheck::reportDeMorgan(const ASTContext &Context,
if (flipDemorganOperator(Fixes, Inner)) if (flipDemorganOperator(Fixes, Inner))
return false; return false;
if (flipDemorganSide(Fixes, Context, Inner->getLHS(), NewOpcode) || if (flipDemorganSide(Fixes, Context, Inner->getLHS(), NewOpcode) ||
flipDemorganSide(Fixes, Context, Inner->getRHS(), NewOpcode)) flipDemorganSide(Fixes, Context, Inner->getRHS(), NewOpcode))
return false; return false;
Diag << Fixes; Diag << Fixes;
return true; return true;
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/SimplifySubscriptExprCheck.cpp

//===--- SimplifySubscriptExprCheck.cpp - clang-tidy-----------------------===// //===--- SimplifySubscriptExprCheck.cpp - clang-tidy-----------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "SimplifySubscriptExprCheck.h" #include "SimplifySubscriptExprCheck.h"
#include "../utils/OptionsUtils.h" #include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
static const char KDefaultTypes[] = static const char KDefaultTypes[] =
"::std::basic_string;::std::basic_string_view;::std::vector;::std::array"; "::std::basic_string;::std::basic_string_view;::std::vector;::std::array";
SimplifySubscriptExprCheck::SimplifySubscriptExprCheck( SimplifySubscriptExprCheck::SimplifySubscriptExprCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), Types(utils::options::parseStringList( : ClangTidyCheck(Name, Context), Types(utils::options::parseStringList(
Options.get("Types", KDefaultTypes))) { Options.get("Types", KDefaultTypes))) {
Show All 34 Lines DiagBuilder << FixItHint::CreateRemoval(
{Member->getOperatorLoc(), Call->getEndLoc()}); {Member->getOperatorLoc(), Call->getEndLoc()});
} }
void SimplifySubscriptExprCheck::storeOptions( void SimplifySubscriptExprCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "Types", utils::options::serializeStringList(Types)); Options.store(Opts, "Types", utils::options::serializeStringList(Types));
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/StaticAccessedThroughInstanceCheck.cpp

//===--- StaticAccessedThroughInstanceCheck.cpp - clang-tidy---------------===// //===--- StaticAccessedThroughInstanceCheck.cpp - clang-tidy---------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StaticAccessedThroughInstanceCheck.h" #include "StaticAccessedThroughInstanceCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
static unsigned getNameSpecifierNestingLevel(const QualType &QType) { static unsigned getNameSpecifierNestingLevel(const QualType &QType) {
if (const ElaboratedType *ElType = QType->getAs<ElaboratedType>()) { if (const ElaboratedType *ElType = QType->getAs<ElaboratedType>()) {
if (const NestedNameSpecifier *NestedSpecifiers = ElType->getQualifier()) { if (const NestedNameSpecifier *NestedSpecifiers = ElType->getQualifier()) {
unsigned NameSpecifierNestingLevel = 1; unsigned NameSpecifierNestingLevel = 1;
do { do {
NameSpecifierNestingLevel++; NameSpecifierNestingLevel++;
NestedSpecifiers = NestedSpecifiers->getPrefix(); NestedSpecifiers = NestedSpecifiers->getPrefix();
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines if (BaseExpr->HasSideEffects(*AstContext) ||
return; return;
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
CharSourceRange::getCharRange(MemberExprStartLoc, CharSourceRange::getCharRange(MemberExprStartLoc,
MemberExpression->getMemberLoc()), MemberExpression->getMemberLoc()),
BaseTypeName + "::"); BaseTypeName + "::");
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/StaticDefinitionInAnonymousNamespaceCheck.cpp

//===--- StaticDefinitionInAnonymousNamespaceCheck.cpp - clang-tidy--------===// //===--- StaticDefinitionInAnonymousNamespaceCheck.cpp - clang-tidy--------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StaticDefinitionInAnonymousNamespaceCheck.h" #include "StaticDefinitionInAnonymousNamespaceCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void StaticDefinitionInAnonymousNamespaceCheck::registerMatchers( void StaticDefinitionInAnonymousNamespaceCheck::registerMatchers(
MatchFinder *Finder) { MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
namedDecl(anyOf(functionDecl(isDefinition(), isStaticStorageClass()), namedDecl(anyOf(functionDecl(isDefinition(), isStaticStorageClass()),
varDecl(isDefinition(), isStaticStorageClass())), varDecl(isDefinition(), isStaticStorageClass())),
isInAnonymousNamespace()) isInAnonymousNamespace())
.bind("static-def"), .bind("static-def"),
Show All 28 Lines while (Loc < Def->getSourceRange().getEnd() &&
if (SourceText == "static") { if (SourceText == "static") {
Diag << FixItHint::CreateRemoval(TokenRange); Diag << FixItHint::CreateRemoval(TokenRange);
break; break;
} }
Loc = Tok.getEndLoc(); Loc = Tok.getEndLoc();
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/StringCompareCheck.cpp

//===-- StringCompareCheck.cpp - clang-tidy--------------------------------===// //===-- StringCompareCheck.cpp - clang-tidy--------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "StringCompareCheck.h" #include "StringCompareCheck.h"
#include "../utils/FixItHintUtils.h" #include "../utils/FixItHintUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/FixIt.h" #include "clang/Tooling/FixIt.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
static const StringRef CompareMessage = "do not use 'compare' to test equality " static const StringRef CompareMessage = "do not use 'compare' to test equality "
"of strings; use the string equality " "of strings; use the string equality "
"operator instead"; "operator instead";
void StringCompareCheck::registerMatchers(MatchFinder *Finder) { void StringCompareCheck::registerMatchers(MatchFinder *Finder) {
const auto StrCompare = cxxMemberCallExpr( const auto StrCompare = cxxMemberCallExpr(
callee(cxxMethodDecl(hasName("compare"), callee(cxxMethodDecl(hasName("compare"),
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines if (const auto *Zero = Result.Nodes.getNodeAs<Stmt>("zero")) {
<< tooling::fixit::createReplacement(*Compare, *Str1->getBase(), << tooling::fixit::createReplacement(*Compare, *Str1->getBase(),
Ctx); Ctx);
} }
} }
// FIXME: Add fixit to fix the code for case one and two (match1). // FIXME: Add fixit to fix the code for case one and two (match1).
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/SuspiciousCallArgumentCheck.cpp

Show All 11 Lines
#include "clang/AST/Type.h" #include "clang/AST/Type.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <optional> #include <optional>
#include <sstream> #include <sstream>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace optutils = clang::tidy::utils::options; namespace optutils = clang::tidy::utils::options;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
struct DefaultHeuristicConfiguration { struct DefaultHeuristicConfiguration {
/// Whether the heuristic is to be enabled by default. /// Whether the heuristic is to be enabled by default.
const bool Enabled; const bool Enabled;
/// The upper bound of % of similarity the two strings might have to be /// The upper bound of % of similarity the two strings might have to be
/// considered dissimilar. /// considered dissimilar.
▲ Show 20 Lines • Show All 771 Lines • ▼ Show 20 Linesbool SuspiciousCallArgumentCheck::areNamesSimilar(StringRef Arg,
case Heuristic::JaroWinkler: case Heuristic::JaroWinkler:
return applyJaroWinklerHeuristic(Arg, Param, Threshold); return applyJaroWinklerHeuristic(Arg, Param, Threshold);
case Heuristic::Dice: case Heuristic::Dice:
return applyDiceHeuristic(Arg, Param, Threshold); return applyDiceHeuristic(Arg, Param, Threshold);
} }
llvm_unreachable("Unhandled heuristic kind"); llvm_unreachable("Unhandled heuristic kind");
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

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

Show All 9 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Basic/Diagnostic.h" #include "clang/Basic/Diagnostic.h"
#include "clang/Basic/SourceLocation.h" #include "clang/Basic/SourceLocation.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
void UniqueptrDeleteReleaseCheck::storeOptions( void UniqueptrDeleteReleaseCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "PreferResetCall", PreferResetCall); Options.store(Opts, "PreferResetCall", PreferResetCall);
} }
UniqueptrDeleteReleaseCheck::UniqueptrDeleteReleaseCheck( UniqueptrDeleteReleaseCheck::UniqueptrDeleteReleaseCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines if (ReleaseExpr->isArrow())
"*"); "*");
D << FixItHint::CreateReplacement( D << FixItHint::CreateReplacement(
CharSourceRange::getTokenRange(ReleaseExpr->getOperatorLoc(), CharSourceRange::getTokenRange(ReleaseExpr->getOperatorLoc(),
ReleaseCallExpr->getEndLoc()), ReleaseCallExpr->getEndLoc()),
" = nullptr"); " = nullptr");
} }
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp

Show All 11 Lines
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include <cctype> #include <cctype>
#include <optional> #include <optional>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::readability {
namespace tidy {
namespace readability {
namespace { namespace {
struct IntegerLiteralCheck { struct IntegerLiteralCheck {
using type = clang::IntegerLiteral; using type = clang::IntegerLiteral;
static constexpr llvm::StringLiteral Name = llvm::StringLiteral("integer"); static constexpr llvm::StringLiteral Name = llvm::StringLiteral("integer");
// What should be skipped before looking for the Suffixes? (Nothing here.) // What should be skipped before looking for the Suffixes? (Nothing here.)
static constexpr llvm::StringLiteral SkipFirst = llvm::StringLiteral(""); static constexpr llvm::StringLiteral SkipFirst = llvm::StringLiteral("");
▲ Show 20 Lines • Show All 205 Lines • ▼ Show 20 Lines
void UppercaseLiteralSuffixCheck::check( void UppercaseLiteralSuffixCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
if (checkBoundMatch<IntegerLiteralCheck>(Result)) if (checkBoundMatch<IntegerLiteralCheck>(Result))
return; // If it *was* IntegerLiteral, don't check for FloatingLiteral. return; // If it *was* IntegerLiteral, don't check for FloatingLiteral.
checkBoundMatch<FloatingLiteralCheck>(Result); checkBoundMatch<FloatingLiteralCheck>(Result);
} }
} // namespace readability } // namespace clang::tidy::readability
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/readability/UseAnyOfAllOfCheck.cpp

Show All 31 LinesAST_MATCHER_P(Stmt, nextStmt, ast_matchers::internal::Matcher<Stmt>,
assert(I != C->body_end() && "C is parent of Node"); assert(I != C->body_end() && "C is parent of Node");
if (++I == C->body_end()) if (++I == C->body_end())
return false; // Node is last statement. return false; // Node is last statement.
return InnerMatcher.matches(**I, Finder, Builder); return InnerMatcher.matches(**I, Finder, Builder);
} }
} // namespace } // namespace
namespace tidy { namespace tidy::readability {
namespace readability {
void UseAnyOfAllOfCheck::registerMatchers(MatchFinder *Finder) { void UseAnyOfAllOfCheck::registerMatchers(MatchFinder *Finder) {
auto Returns = [](bool V) { auto Returns = [](bool V) {
return returnStmt(hasReturnValue(cxxBoolLiteral(equals(V)))); return returnStmt(hasReturnValue(cxxBoolLiteral(equals(V))));
}; };
auto ReturnsButNotTrue = auto ReturnsButNotTrue =
returnStmt(hasReturnValue(unless(cxxBoolLiteral(equals(true))))); returnStmt(hasReturnValue(unless(cxxBoolLiteral(equals(true)))));
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines if (const auto *S = Result.Nodes.getNodeAs<CXXForRangeStmt>("any_of_loop")) {
if (!isViableLoop(*S, *Result.Context)) if (!isViableLoop(*S, *Result.Context))
return; return;
diag(S->getForLoc(), "replace loop by 'std%select{|::ranges}0::all_of()'") diag(S->getForLoc(), "replace loop by 'std%select{|::ranges}0::all_of()'")
<< getLangOpts().CPlusPlus20; << getLangOpts().CPlusPlus20;
} }
} }
} // namespace readability } // namespace tidy::readability
} // namespace tidy
} // namespace clang } // namespace clang

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

Show First 20 Lines • Show All 302 Lines • ▼ Show 20 Lines if new_module == 'llvm':
new_namespace = new_module + '_check' new_namespace = new_module + '_check'
else: else:
new_namespace = new_module new_namespace = new_module
check_implementation_files = glob.glob( check_implementation_files = glob.glob(
os.path.join(old_module_path, new_check_name_camel + '*')) os.path.join(old_module_path, new_check_name_camel + '*'))
for filename in check_implementation_files: for filename in check_implementation_files:
# Move check implementation to the directory of the new module. # Move check implementation to the directory of the new module.
filename = fileRename(filename, old_module_path, new_module_path) filename = fileRename(filename, old_module_path, new_module_path)
replaceInFileRegex(filename, 'namespace ' + old_module + '[^ \n]*', replaceInFileRegex(filename,
'namespace ' + new_namespace) 'namespace clang::tidy::' + old_module + '[^ \n]*',
'namespace clang::tidy::' + new_namespace)
if (args.old_check_name == args.new_check_name): if (args.old_check_name == args.new_check_name):
return return
# Add check to the new module. # Add check to the new module.
adapt_cmake(new_module_path, new_check_name_camel) adapt_cmake(new_module_path, new_check_name_camel)
adapt_module(new_module_path, new_module, args.new_check_name, adapt_module(new_module_path, new_module, args.new_check_name,
new_check_name_camel) new_check_name_camel)
os.system(os.path.join(clang_tidy_path, 'add_new_check.py') os.system(os.path.join(clang_tidy_path, 'add_new_check.py')
+ ' --update-docs') + ' --update-docs')
add_release_notes(clang_tidy_path, args.old_check_name, args.new_check_name) add_release_notes(clang_tidy_path, args.old_check_name, args.new_check_name)
if __name__ == '__main__': if __name__ == '__main__':
main() main()

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

Show First 20 Lines • Show All 257 Lines • ▼ Show 20 Lines)"),
cl::init(false), cl::cat(ClangTidyCategory)); cl::init(false), cl::cat(ClangTidyCategory));
static cl::opt<bool> VerifyConfig("verify-config", cl::desc(R"( static cl::opt<bool> VerifyConfig("verify-config", cl::desc(R"(
Check the config files to ensure each check and Check the config files to ensure each check and
option is recognized. option is recognized.
)"), )"),
cl::init(false), cl::cat(ClangTidyCategory)); cl::init(false), cl::cat(ClangTidyCategory));
namespace clang { namespace clang::tidy {
namespace tidy {
static void printStats(const ClangTidyStats &Stats) { static void printStats(const ClangTidyStats &Stats) {
if (Stats.errorsIgnored()) { if (Stats.errorsIgnored()) {
llvm::errs() << "Suppressed " << Stats.errorsIgnored() << " warnings ("; llvm::errs() << "Suppressed " << Stats.errorsIgnored() << " warnings (";
StringRef Separator = ""; StringRef Separator = "";
if (Stats.ErrorsIgnoredNonUserCode) { if (Stats.ErrorsIgnoredNonUserCode) {
llvm::errs() << Stats.ErrorsIgnoredNonUserCode << " in non-user code"; llvm::errs() << Stats.ErrorsIgnoredNonUserCode << " in non-user code";
Separator = ", "; Separator = ", ";
▲ Show 20 Lines • Show All 379 Lines • ▼ Show 20 Lines if (FoundErrors) {
if (!Quiet) if (!Quiet)
llvm::errs() << "Found compiler error(s).\n"; llvm::errs() << "Found compiler error(s).\n";
return 1; return 1;
} }
return 0; return 0;
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/ASTUtils.cpp

//===---------- ASTUtils.cpp - clang-tidy ---------------------------------===// //===---------- ASTUtils.cpp - clang-tidy ---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ASTUtils.h" #include "ASTUtils.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
using namespace ast_matchers; using namespace ast_matchers;
const FunctionDecl *getSurroundingFunction(ASTContext &Context, const FunctionDecl *getSurroundingFunction(ASTContext &Context,
const Stmt &Statement) { const Stmt &Statement) {
return selectFirst<const FunctionDecl>( return selectFirst<const FunctionDecl>(
"function", match(stmt(hasAncestor(functionDecl().bind("function"))), "function", match(stmt(hasAncestor(functionDecl().bind("function"))),
Statement, Context)); Statement, Context));
} }
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines return rangeIsEntirelyWithinMacroArgument(Range, SM) ||
Range.getBegin().isMacroID() || Range.getEnd().isMacroID(); Range.getBegin().isMacroID() || Range.getEnd().isMacroID();
} }
bool rangeCanBeFixed(SourceRange Range, const SourceManager *SM) { bool rangeCanBeFixed(SourceRange Range, const SourceManager *SM) {
return utils::rangeIsEntirelyWithinMacroArgument(Range, SM) || return utils::rangeIsEntirelyWithinMacroArgument(Range, SM) ||
!utils::rangeContainsMacroExpansion(Range, SM); !utils::rangeContainsMacroExpansion(Range, SM);
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/Aliasing.cpp

//===------------- Aliasing.cpp - clang-tidy ------------------------------===// //===------------- Aliasing.cpp - clang-tidy ------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "Aliasing.h" #include "Aliasing.h"
#include "clang/AST/Expr.h" #include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h" #include "clang/AST/ExprCXX.h"
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
/// Return whether \p S is a reference to the declaration of \p Var. /// Return whether \p S is a reference to the declaration of \p Var.
static bool isAccessForVar(const Stmt *S, const VarDecl *Var) { static bool isAccessForVar(const Stmt *S, const VarDecl *Var) {
if (const auto *DRE = dyn_cast<DeclRefExpr>(S)) if (const auto *DRE = dyn_cast<DeclRefExpr>(S))
return DRE->getDecl() == Var; return DRE->getDecl() == Var;
return false; return false;
} }
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Linesstatic bool refersToEnclosingLambdaCaptureByRef(const Decl *Func,
return capturesByRef(RD, Var); return capturesByRef(RD, Var);
} }
bool hasPtrOrReferenceInFunc(const Decl *Func, const VarDecl *Var) { bool hasPtrOrReferenceInFunc(const Decl *Func, const VarDecl *Var) {
return hasPtrOrReferenceInStmt(Func->getBody(), Var) || return hasPtrOrReferenceInStmt(Func->getBody(), Var) ||
refersToEnclosingLambdaCaptureByRef(Func, Var); refersToEnclosingLambdaCaptureByRef(Func, Var);
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/DeclRefExprUtils.cpp

//===--- DeclRefExprUtils.cpp - clang-tidy---------------------------------===// //===--- DeclRefExprUtils.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DeclRefExprUtils.h" #include "DeclRefExprUtils.h"
#include "Matchers.h" #include "Matchers.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
namespace clang { namespace clang::tidy::utils::decl_ref_expr {
namespace tidy {
namespace utils {
namespace decl_ref_expr {
using namespace ::clang::ast_matchers; using namespace ::clang::ast_matchers;
using llvm::SmallPtrSet; using llvm::SmallPtrSet;
namespace { namespace {
template <typename S> bool isSetDifferenceEmpty(const S &S1, const S &S2) { template <typename S> bool isSetDifferenceEmpty(const S &S1, const S &S2) {
for (auto E : S1) for (auto E : S1)
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines auto Matches = match(
decl(hasDescendant( decl(hasDescendant(
cxxOperatorCallExpr(UsedAsConstRefArg, hasOverloadedOperatorName("="), cxxOperatorCallExpr(UsedAsConstRefArg, hasOverloadedOperatorName("="),
callee(cxxMethodDecl(isCopyAssignmentOperator()))) callee(cxxMethodDecl(isCopyAssignmentOperator())))
.bind("operatorCallExpr"))), .bind("operatorCallExpr"))),
Decl, Context); Decl, Context);
return !Matches.empty(); return !Matches.empty();
} }
} // namespace decl_ref_expr } // namespace clang::tidy::utils::decl_ref_expr
} // namespace utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/ExceptionAnalyzer.cpp

//===--- ExceptionAnalyzer.cpp - clang-tidy -------------------------------===// //===--- ExceptionAnalyzer.cpp - clang-tidy -------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ExceptionAnalyzer.h" #include "ExceptionAnalyzer.h"
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
void ExceptionAnalyzer::ExceptionInfo::registerException( void ExceptionAnalyzer::ExceptionInfo::registerException(
const Type *ExceptionType) { const Type *ExceptionType) {
assert(ExceptionType != nullptr && "Only valid types are accepted"); assert(ExceptionType != nullptr && "Only valid types are accepted");
Behaviour = State::Throwing; Behaviour = State::Throwing;
ThrownExceptions.insert(ExceptionType); ThrownExceptions.insert(ExceptionType);
} }
▲ Show 20 Lines • Show All 247 Lines • ▼ Show 20 LinesExceptionAnalyzer::analyze(const FunctionDecl *Func) {
return analyzeDispatch(Func); return analyzeDispatch(Func);
} }
ExceptionAnalyzer::ExceptionInfo ExceptionAnalyzer::ExceptionInfo
ExceptionAnalyzer::analyze(const Stmt *Stmt) { ExceptionAnalyzer::analyze(const Stmt *Stmt) {
return analyzeDispatch(Stmt); return analyzeDispatch(Stmt);
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/ExprSequence.cpp

//===---------- ExprSequence.cpp - clang-tidy -----------------------------===// //===---------- ExprSequence.cpp - clang-tidy -----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ExprSequence.h" #include "ExprSequence.h"
#include "clang/AST/ParentMapContext.h" #include "clang/AST/ParentMapContext.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
// Returns the Stmt nodes that are parents of 'S', skipping any potential // Returns the Stmt nodes that are parents of 'S', skipping any potential
// intermediate non-Stmt nodes. // intermediate non-Stmt nodes.
// //
// In almost all cases, this function returns a single parent or no parents at // In almost all cases, this function returns a single parent or no parents at
// all. // all.
// //
// The case that a Stmt has multiple parents is rare but does actually occur in // The case that a Stmt has multiple parents is rare but does actually occur in
▲ Show 20 Lines • Show All 177 Lines • ▼ Show 20 Lines while (!Map.count(S)) {
if (Parents.empty()) if (Parents.empty())
return nullptr; return nullptr;
S = Parents[0]; S = Parents[0];
} }
return Map.lookup(S); return Map.lookup(S);
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/FileExtensionsUtils.cpp

//===--- FileExtensionsUtils.cpp - clang-tidy -------------------*- C++ -*-===// //===--- FileExtensionsUtils.cpp - clang-tidy -------------------*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FileExtensionsUtils.h" #include "FileExtensionsUtils.h"
#include "clang/Basic/CharInfo.h" #include "clang/Basic/CharInfo.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
bool isExpansionLocInHeaderFile(SourceLocation Loc, const SourceManager &SM, bool isExpansionLocInHeaderFile(SourceLocation Loc, const SourceManager &SM,
const FileExtensionsSet &HeaderFileExtensions) { const FileExtensionsSet &HeaderFileExtensions) {
SourceLocation ExpansionLoc = SM.getExpansionLoc(Loc); SourceLocation ExpansionLoc = SM.getExpansionLoc(Loc);
return isFileExtension(SM.getFilename(ExpansionLoc), HeaderFileExtensions); return isFileExtension(SM.getFilename(ExpansionLoc), HeaderFileExtensions);
} }
bool isPresumedLocInHeaderFile(SourceLocation Loc, SourceManager &SM, bool isPresumedLocInHeaderFile(SourceLocation Loc, SourceManager &SM,
Show All 40 LinesgetFileExtension(StringRef FileName, const FileExtensionsSet &FileExtensions) {
return Extension; return Extension;
} }
bool isFileExtension(StringRef FileName, bool isFileExtension(StringRef FileName,
const FileExtensionsSet &FileExtensions) { const FileExtensionsSet &FileExtensions) {
return getFileExtension(FileName, FileExtensions).has_value(); return getFileExtension(FileName, FileExtensions).has_value();
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/FixItHintUtils.cpp

//===--- FixItHintUtils.cpp - clang-tidy-----------------------------------===// //===--- FixItHintUtils.cpp - clang-tidy-----------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "FixItHintUtils.h" #include "FixItHintUtils.h"
#include "LexerUtils.h" #include "LexerUtils.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/Type.h" #include "clang/AST/Type.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::utils::fixit {
namespace tidy {
namespace utils {
namespace fixit {
FixItHint changeVarDeclToReference(const VarDecl &Var, ASTContext &Context) { FixItHint changeVarDeclToReference(const VarDecl &Var, ASTContext &Context) {
SourceLocation AmpLocation = Var.getLocation(); SourceLocation AmpLocation = Var.getLocation();
auto Token = utils::lexer::getPreviousToken( auto Token = utils::lexer::getPreviousToken(
AmpLocation, Context.getSourceManager(), Context.getLangOpts()); AmpLocation, Context.getSourceManager(), Context.getLangOpts());
if (!Token.is(tok::unknown)) if (!Token.is(tok::unknown))
AmpLocation = Lexer::getLocForEndOfToken(Token.getLocation(), 0, AmpLocation = Lexer::getLocForEndOfToken(Token.getLocation(), 0,
Context.getSourceManager(), Context.getSourceManager(),
▲ Show 20 Lines • Show All 192 Lines • ▼ Show 20 Lines if (ParenStrippedType->isArrayType()) {
if (AT->isPointerType()) if (AT->isPointerType())
return changePointer(Var, Qualifier, AT->getPointeeType().getTypePtr(), return changePointer(Var, Qualifier, AT->getPointeeType().getTypePtr(),
QualTarget, QualPolicy, Context); QualTarget, QualPolicy, Context);
} }
return std::nullopt; return std::nullopt;
} }
} // namespace fixit } // namespace clang::tidy::utils::fixit
} // namespace utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/HeaderGuard.cpp

//===--- HeaderGuard.cpp - clang-tidy -------------------------------------===// //===--- HeaderGuard.cpp - clang-tidy -------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "HeaderGuard.h" #include "HeaderGuard.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
/// canonicalize a path by removing ./ and ../ components. /// canonicalize a path by removing ./ and ../ components.
static std::string cleanPath(StringRef Path) { static std::string cleanPath(StringRef Path) {
SmallString<256> Result = Path; SmallString<256> Result = Path;
llvm::sys::path::remove_dots(Result, true); llvm::sys::path::remove_dots(Result, true);
return std::string(Result.str()); return std::string(Result.str());
} }
▲ Show 20 Lines • Show All 266 Lines • ▼ Show 20 Lines
bool HeaderGuardCheck::shouldSuggestToAddHeaderGuard(StringRef FileName) { bool HeaderGuardCheck::shouldSuggestToAddHeaderGuard(StringRef FileName) {
return utils::isFileExtension(FileName, HeaderFileExtensions); return utils::isFileExtension(FileName, HeaderFileExtensions);
} }
std::string HeaderGuardCheck::formatEndIf(StringRef HeaderGuard) { std::string HeaderGuardCheck::formatEndIf(StringRef HeaderGuard) {
return "endif // " + HeaderGuard.str(); return "endif // " + HeaderGuard.str();
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

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

//===-------- IncludeInserter.cpp - clang-tidy ----------------------------===// //===-------- IncludeInserter.cpp - clang-tidy ----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "IncludeInserter.h" #include "IncludeInserter.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "clang/Lex/Token.h" #include "clang/Lex/Token.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
class IncludeInserterCallback : public PPCallbacks { class IncludeInserterCallback : public PPCallbacks {
public: public:
explicit IncludeInserterCallback(IncludeInserter *Inserter) explicit IncludeInserterCallback(IncludeInserter *Inserter)
: Inserter(Inserter) {} : Inserter(Inserter) {}
// Implements PPCallbacks::InclusionDirective(). Records the names and source // Implements PPCallbacks::InclusionDirective(). Records the names and source
// locations of the inclusions in the main source file being processed. // locations of the inclusions in the main source file being processed.
void InclusionDirective(SourceLocation HashLocation, void InclusionDirective(SourceLocation HashLocation,
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Linesvoid IncludeInserter::addInclude(StringRef FileName, bool IsAngled,
SourceLocation HashLocation, SourceLocation HashLocation,
SourceLocation EndLocation) { SourceLocation EndLocation) {
assert(SourceMgr && "SourceMgr shouldn't be null; did you remember to call " assert(SourceMgr && "SourceMgr shouldn't be null; did you remember to call "
"registerPreprocessor()?"); "registerPreprocessor()?");
FileID FileID = SourceMgr->getFileID(HashLocation); FileID FileID = SourceMgr->getFileID(HashLocation);
getOrCreate(FileID).addInclude(FileName, IsAngled, HashLocation, EndLocation); getOrCreate(FileID).addInclude(FileName, IsAngled, HashLocation, EndLocation);
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/IncludeSorter.cpp

//===---------- IncludeSorter.cpp - clang-tidy ----------------------------===// //===---------- IncludeSorter.cpp - clang-tidy ----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "IncludeSorter.h" #include "IncludeSorter.h"
#include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManager.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include <algorithm> #include <algorithm>
#include <optional> #include <optional>
namespace clang { namespace clang::tidy {
namespace tidy {
namespace utils { namespace utils {
namespace { namespace {
StringRef removeFirstSuffix(StringRef Str, ArrayRef<const char *> Suffixes) { StringRef removeFirstSuffix(StringRef Str, ArrayRef<const char *> Suffixes) {
for (StringRef Suffix : Suffixes) { for (StringRef Suffix : Suffixes) {
if (Str.endswith(Suffix)) { if (Str.endswith(Suffix)) {
return Str.substr(0, Str.size() - Suffix.size()); return Str.substr(0, Str.size() - Suffix.size());
▲ Show 20 Lines • Show All 203 Lines • ▼ Show 20 Lines
llvm::ArrayRef<std::pair<utils::IncludeSorter::IncludeStyle, StringRef>> llvm::ArrayRef<std::pair<utils::IncludeSorter::IncludeStyle, StringRef>>
OptionEnumMapping<utils::IncludeSorter::IncludeStyle>::getEnumMapping() { OptionEnumMapping<utils::IncludeSorter::IncludeStyle>::getEnumMapping() {
static constexpr std::pair<utils::IncludeSorter::IncludeStyle, StringRef> static constexpr std::pair<utils::IncludeSorter::IncludeStyle, StringRef>
Mapping[] = {{utils::IncludeSorter::IS_LLVM, "llvm"}, Mapping[] = {{utils::IncludeSorter::IS_LLVM, "llvm"},
{utils::IncludeSorter::IS_Google, "google"}, {utils::IncludeSorter::IS_Google, "google"},
{utils::IncludeSorter::IS_Google_ObjC, "google-objc"}}; {utils::IncludeSorter::IS_Google_ObjC, "google-objc"}};
return ArrayRef(Mapping); return ArrayRef(Mapping);
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/LexerUtils.cpp

//===--- LexerUtils.cpp - clang-tidy---------------------------------------===// //===--- LexerUtils.cpp - clang-tidy---------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "LexerUtils.h" #include "LexerUtils.h"
#include "clang/AST/AST.h" #include "clang/AST/AST.h"
#include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManager.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::utils::lexer {
namespace tidy {
namespace utils {
namespace lexer {
Token getPreviousToken(SourceLocation Location, const SourceManager &SM, Token getPreviousToken(SourceLocation Location, const SourceManager &SM,
const LangOptions &LangOpts, bool SkipComments) { const LangOptions &LangOpts, bool SkipComments) {
Token Token; Token Token;
Token.setKind(tok::unknown); Token.setKind(tok::unknown);
Location = Location.getLocWithOffset(-1); Location = Location.getLocWithOffset(-1);
if (Location.isInvalid()) if (Location.isInvalid())
▲ Show 20 Lines • Show All 184 Lines • ▼ Show 20 LinesSourceLocation getUnifiedEndLoc(const Stmt &S, const SourceManager &SM,
if (!breakAndReturnEnd(*LastChild) && if (!breakAndReturnEnd(*LastChild) &&
breakAndReturnEndPlus1Token(*LastChild)) breakAndReturnEndPlus1Token(*LastChild))
return getSemicolonAfterStmtEndLoc(S.getEndLoc(), SM, LangOpts); return getSemicolonAfterStmtEndLoc(S.getEndLoc(), SM, LangOpts);
return S.getEndLoc(); return S.getEndLoc();
} }
} // namespace lexer } // namespace clang::tidy::utils::lexer
} // namespace utils
} // namespace tidy
} // namespace clang

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

//===---------- NamespaceAliaser.cpp - clang-tidy -------------------------===// //===---------- NamespaceAliaser.cpp - clang-tidy -------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "NamespaceAliaser.h" #include "NamespaceAliaser.h"
#include "ASTUtils.h" #include "ASTUtils.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
using namespace ast_matchers; using namespace ast_matchers;
NamespaceAliaser::NamespaceAliaser(const SourceManager &SourceMgr) NamespaceAliaser::NamespaceAliaser(const SourceManager &SourceMgr)
: SourceMgr(SourceMgr) {} : SourceMgr(SourceMgr) {}
AST_MATCHER_P(NamespaceAliasDecl, hasTargetNamespace, AST_MATCHER_P(NamespaceAliasDecl, hasTargetNamespace,
ast_matchers::internal::Matcher<NamespaceDecl>, innerMatcher) { ast_matchers::internal::Matcher<NamespaceDecl>, innerMatcher) {
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Linesstd::string NamespaceAliaser::getNamespaceName(ASTContext &Context,
if (FunctionAliases != AddedAliases.end()) { if (FunctionAliases != AddedAliases.end()) {
if (FunctionAliases->second.count(Namespace) != 0) { if (FunctionAliases->second.count(Namespace) != 0) {
return FunctionAliases->second.find(Namespace)->getValue(); return FunctionAliases->second.find(Namespace)->getValue();
} }
} }
return Namespace.str(); return Namespace.str();
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/OptionsUtils.cpp

//===-- OptionsUtils.cpp - clang-tidy -------------------------------------===// //===-- OptionsUtils.cpp - clang-tidy -------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "OptionsUtils.h" #include "OptionsUtils.h"
#include "llvm/ADT/StringExtras.h" #include "llvm/ADT/StringExtras.h"
namespace clang { namespace clang::tidy::utils::options {
namespace tidy {
namespace utils {
namespace options {
static const char StringsDelimiter[] = ";"; static const char StringsDelimiter[] = ";";
std::vector<StringRef> parseStringList(StringRef Option) { std::vector<StringRef> parseStringList(StringRef Option) {
Option = Option.trim().trim(StringsDelimiter); Option = Option.trim().trim(StringsDelimiter);
if (Option.empty()) if (Option.empty())
return {}; return {};
std::vector<StringRef> Result; std::vector<StringRef> Result;
Show All 34 Linesstd::vector<StringRef> parseListPair(StringRef L, StringRef R) {
} }
return Result; return Result;
} }
std::string serializeStringList(ArrayRef<StringRef> Strings) { std::string serializeStringList(ArrayRef<StringRef> Strings) {
return llvm::join(Strings, StringsDelimiter); return llvm::join(Strings, StringsDelimiter);
} }
} // namespace options } // namespace clang::tidy::utils::options
} // namespace utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines static bool isEqual(const NamingCheckId &LHS, const NamingCheckId &RHS) {
if (RHS == getTombstoneKey()) if (RHS == getTombstoneKey())
return LHS == getTombstoneKey(); return LHS == getTombstoneKey();
return LHS == RHS; return LHS == RHS;
} }
}; };
} // namespace llvm } // namespace llvm
namespace clang { namespace clang::tidy {
namespace tidy {
namespace { namespace {
/// Callback supplies macros to RenamerClangTidyCheck::checkMacro /// Callback supplies macros to RenamerClangTidyCheck::checkMacro
class RenamerClangTidyCheckPPCallbacks : public PPCallbacks { class RenamerClangTidyCheckPPCallbacks : public PPCallbacks {
public: public:
RenamerClangTidyCheckPPCallbacks(Preprocessor *PP, RenamerClangTidyCheckPPCallbacks(Preprocessor *PP,
RenamerClangTidyCheck *Check) RenamerClangTidyCheck *Check)
▲ Show 20 Lines • Show All 486 Lines • ▼ Show 20 Lines if (Failure.shouldNotify()) {
Diag << FixItHint::CreateReplacement(SourceRange(Loc), Diag << FixItHint::CreateReplacement(SourceRange(Loc),
Failure.Info.Fixup); Failure.Info.Fixup);
} }
} }
} }
} }
} }
} // namespace tidy } // namespace clang::tidy
} // namespace clang

clang-tools-extra/clang-tidy/utils/TransformerClangTidyCheck.cpp

//===---------- TransformerClangTidyCheck.cpp - clang-tidy ----------------===// //===---------- TransformerClangTidyCheck.cpp - clang-tidy ----------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TransformerClangTidyCheck.h" #include "TransformerClangTidyCheck.h"
#include "clang/Basic/DiagnosticIDs.h" #include "clang/Basic/DiagnosticIDs.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
using transformer::RewriteRuleWith; using transformer::RewriteRuleWith;
#ifndef NDEBUG #ifndef NDEBUG
static bool hasGenerator(const transformer::Generator<std::string> &G) { static bool hasGenerator(const transformer::Generator<std::string> &G) {
return G != nullptr; return G != nullptr;
} }
#endif #endif
▲ Show 20 Lines • Show All 126 Lines • ▼ Show 20 Linesvoid TransformerClangTidyCheck::check(
} }
} }
void TransformerClangTidyCheck::storeOptions( void TransformerClangTidyCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) { ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "IncludeStyle", Inserter.getStyle()); Options.store(Opts, "IncludeStyle", Inserter.getStyle());
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

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

//===--- TypeTraits.cpp - clang-tidy---------------------------------------===// //===--- TypeTraits.cpp - clang-tidy---------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "TypeTraits.h" #include "TypeTraits.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/DeclCXX.h" #include "clang/AST/DeclCXX.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::utils::type_traits {
namespace tidy {
namespace utils {
namespace type_traits {
namespace { namespace {
bool classHasTrivialCopyAndDestroy(QualType Type) { bool classHasTrivialCopyAndDestroy(QualType Type) {
auto *Record = Type->getAsCXXRecordDecl(); auto *Record = Type->getAsCXXRecordDecl();
return Record && Record->hasDefinition() && return Record && Record->hasDefinition() &&
!Record->hasNonTrivialCopyConstructor() && !Record->hasNonTrivialCopyConstructor() &&
!Record->hasNonTrivialDestructor(); !Record->hasNonTrivialDestructor();
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
} }
bool hasNonTrivialMoveAssignment(QualType Type) { bool hasNonTrivialMoveAssignment(QualType Type) {
auto *Record = Type->getAsCXXRecordDecl(); auto *Record = Type->getAsCXXRecordDecl();
return Record && Record->hasDefinition() && return Record && Record->hasDefinition() &&
Record->hasNonTrivialMoveAssignment(); Record->hasNonTrivialMoveAssignment();
} }
} // namespace type_traits } // namespace clang::tidy::utils::type_traits
} // namespace utils
} // namespace tidy
} // namespace clang

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

//===---------- UsingInserter.cpp - clang-tidy ----------------------------===// //===---------- UsingInserter.cpp - clang-tidy ----------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "UsingInserter.h" #include "UsingInserter.h"
#include "ASTUtils.h" #include "ASTUtils.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include <optional> #include <optional>
namespace clang { namespace clang::tidy::utils {
namespace tidy {
namespace utils {
using namespace ast_matchers; using namespace ast_matchers;
static StringRef getUnqualifiedName(StringRef QualifiedName) { static StringRef getUnqualifiedName(StringRef QualifiedName) {
size_t LastSeparatorPos = QualifiedName.rfind("::"); size_t LastSeparatorPos = QualifiedName.rfind("::");
if (LastSeparatorPos == StringRef::npos) if (LastSeparatorPos == StringRef::npos)
return QualifiedName; return QualifiedName;
return QualifiedName.drop_front(LastSeparatorPos + 2); return QualifiedName.drop_front(LastSeparatorPos + 2);
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 LinesStringRef UsingInserter::getShortName(ASTContext &Context,
const Stmt &Statement, const Stmt &Statement,
StringRef QualifiedName) { StringRef QualifiedName) {
const FunctionDecl *Function = getSurroundingFunction(Context, Statement); const FunctionDecl *Function = getSurroundingFunction(Context, Statement);
if (AddedUsing.count(NameInFunction(Function, QualifiedName.str())) != 0) if (AddedUsing.count(NameInFunction(Function, QualifiedName.str())) != 0)
return getUnqualifiedName(QualifiedName); return getUnqualifiedName(QualifiedName);
return QualifiedName; return QualifiedName;
} }
} // namespace utils } // namespace clang::tidy::utils
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/zircon/TemporaryObjectsCheck.cpp

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy::zircon {
namespace tidy {
namespace zircon {
AST_MATCHER_P(CXXRecordDecl, matchesAnyName, ArrayRef<StringRef>, Names) { AST_MATCHER_P(CXXRecordDecl, matchesAnyName, ArrayRef<StringRef>, Names) {
std::string QualifiedName = Node.getQualifiedNameAsString(); std::string QualifiedName = Node.getQualifiedNameAsString();
return llvm::is_contained(Names, QualifiedName); return llvm::is_contained(Names, QualifiedName);
} }
void TemporaryObjectsCheck::registerMatchers(MatchFinder *Finder) { void TemporaryObjectsCheck::registerMatchers(MatchFinder *Finder) {
// Matcher for default constructors. // Matcher for default constructors.
Show All 19 Lines diag(D->getLocation(),
"creating a temporary object of type %q0 is prohibited") "creating a temporary object of type %q0 is prohibited")
<< D->getConstructor()->getParent(); << D->getConstructor()->getParent();
} }
void TemporaryObjectsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { void TemporaryObjectsCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "Names", utils::options::serializeStringList(Names)); Options.store(Opts, "Names", utils::options::serializeStringList(Names));
} }
} // namespace zircon } // namespace clang::tidy::zircon
} // namespace tidy
} // namespace clang

clang-tools-extra/clang-tidy/zircon/ZirconTidyModule.cpp

//===--- ZirconTidyModule.cpp - clang-tidy---------------------------------===// //===--- ZirconTidyModule.cpp - clang-tidy---------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "TemporaryObjectsCheck.h" #include "TemporaryObjectsCheck.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang::tidy {
namespace tidy {
namespace zircon { namespace zircon {
/// This module is for Zircon-specific checks. /// This module is for Zircon-specific checks.
class ZirconModule : public ClangTidyModule { class ZirconModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<TemporaryObjectsCheck>( CheckFactories.registerCheck<TemporaryObjectsCheck>(
"zircon-temporary-objects"); "zircon-temporary-objects");
} }
}; };
// Register the ZirconTidyModule using this statically initialized variable. // Register the ZirconTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<ZirconModule> static ClangTidyModuleRegistry::Add<ZirconModule>
X("zircon-module", "Adds Zircon kernel checks."); X("zircon-module", "Adds Zircon kernel checks.");
} // namespace zircon } // namespace zircon
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the ZirconModule. // and thus register the ZirconModule.
volatile int ZirconModuleAnchorSource = 0; volatile int ZirconModuleAnchorSource = 0;
} // namespace tidy } // namespace clang::tidy
} // namespace clang