#include "clang-tidy-config.h"
#include "llvm/Support/Compiler.h"
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
// This anchor is used to force the linker to link the AbseilModule.
extern volatile int AbseilModuleAnchorSource;
static int LLVM_ATTRIBUTE_UNUSED ZirconModuleAnchorDestination =
ZirconModuleAnchorSource;
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy
#endif
#include <functional>
#include <memory>
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
class ClangTidyCheck;
class ClangTidyContext;
virtual ClangTidyOptions getModuleOptions();
};
-} // end namespace tidy
-} // end namespace clang
+} // namespace clang::tidy
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULE_H
#include "ClangTidyModule.h"
#include "llvm/Support/Registry.h"
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
typedef llvm::Registry<ClangTidyModule> ClangTidyModuleRegistry;
-} // end namespace tidy
-} // end namespace clang
+} // namespace clang::tidy
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULEREGISTRY_H
#include <utility>
#include <vector>
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
/// Contains a list of line ranges in a single file.
struct FileFilter {
/// Serializes configuration to a YAML-encoded string.
std::string configurationAsText(const ClangTidyOptions &Options);
-} // end namespace tidy
-} // end namespace clang
+} // namespace clang::tidy
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYOPTIONS_H
class raw_ostream;
} // namespace llvm
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
class ClangTidyProfiling {
public:
~ClangTidyProfiling();
};
-} // end namespace tidy
-} // end namespace clang
+} // namespace clang::tidy
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYPROFILING_H
#include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/DenseSet.h"
-namespace llvm {
-namespace vfs {
+namespace llvm::vfs {
class OverlayFileSystem;
class InMemoryFileSystem;
-} // namespace vfs
-} // namespace llvm
+} // namespace llvm::vfs
namespace clang {
class CompilerInstance;
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Regex.h"
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
/// Read-only set of strings represented as a list of positive and negative
/// globs.
mutable llvm::StringMap<bool> Cache;
};
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GLOBLIST_H
#include "llvm/ADT/StringRef.h"
#include <memory>
-namespace clang {
-namespace tooling {
+namespace clang::tooling {
struct Diagnostic;
-} // namespace tooling
-} // namespace clang
+} // namespace clang::tooling
namespace llvm {
template <typename T> class SmallVectorImpl;
} // namespace llvm
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
/// This class is used to locate NOLINT comments in the file being analyzed, to
/// decide whether a diagnostic should be suppressed.
std::unique_ptr<Impl> PImpl;
};
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_NOLINTDIRECTIVEHANDLER_H
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include <algorithm>
-namespace clang {
-namespace ast_matchers {
+namespace clang::ast_matchers {
/// Matches AST nodes that were found within Abseil files.
///
});
}
-} // namespace ast_matchers
-} // namespace clang
+} // namespace clang::ast_matchers
#include "../utils/TransformerClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Suggests switching the initialization pattern of `absl::Cleanup`
/// instances from the factory function to class template argument
}
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_CLEANUPCTADCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Checks for cases where addition should be performed in the
/// ``absl::Time`` domain.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMEADDITIONCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Prefer comparison in the absl::Duration domain instead of the numeric
/// domain.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONCOMPARISONCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Checks for casts of ``absl::Duration`` conversion functions, and recommends
/// the right conversion function instead.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONCONVERSIONCASTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
// Find potential incorrect uses of integer division of absl::Duration objects.
//
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONDIVISIONCHECK_H_
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// This check finds cases where `Duration` factories are being called with
/// floating point arguments, but could be called using integer arguments.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONFACTORYFLOATCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// This check finds cases where the incorrect `Duration` factory function is
/// being used by looking for scaling constants inside the factory argument
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONFACTORYSCALECHECK_H
#include <cinttypes>
#include <optional>
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Duration factory and conversion scales
enum class DurationScale : std::uint8_t {
hasEitherOperand(ignoringImpCasts(callExpr(callee(funcDecl)))));
}
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONREWRITER_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Checks for cases where subtraction should be performed in the
/// `absl::Duration` domain.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_DURATIONSUBTRACTIONCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Finds and fixes cases where ``absl::Duration`` values are being converted
/// to numeric types and back again.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMEDOUBLECONVERSIONCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Finds instances of absl::StrSplit() or absl::MaxSplits() where the delimiter
/// is a single character string literal and replaces it with a character.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_FASTERSTRSPLITDELIMITERCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Finds instances where the user depends on internal details and warns them
/// against doing so.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_NOINTERNALDEPSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// This check ensures users don't open namespace absl, as that violates
/// Abseil's compatibility guidelines.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_NONAMESPACECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Flags redundant calls to absl::StrCat when the result is being passed to
/// another call of absl::StrCat/absl::StrAppend. Also suggests a fix to
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_REDUNDANTSTRCATCALLSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Flags uses of absl::StrCat to append to a string. Suggests absl::StrAppend
/// should be used instead.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRCATAPPENDCHECK_H
#include <string>
#include <vector>
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
// Find string.find(...) == 0 comparisons and suggest replacing with StartsWith.
// FIXME(niko): Add similar check for EndsWith
const StringRef AbseilStringsMatchHeader;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTARTSWITHCHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/TransformerClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Finds s.find(...) == string::npos comparisons (for various string-like
/// types) and suggests replacing with absl::StrContains.
const StringRef AbseilStringsMatchHeaderOption;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_STRINGFINDSTRCONTAINSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Prefer comparison in the `absl::Time` domain instead of the numeric
/// domain.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMECOMPARECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Finds and fixes `absl::Time` subtraction expressions to do subtraction
/// in the time domain instead of the numeric domain.
void emitDiagnostic(const Expr* Node, llvm::StringRef Replacement);
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_TIMESUBTRACTIONCHECK_H
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/DenseSet.h"
-namespace clang {
-namespace tidy {
-namespace abseil {
+namespace clang::tidy::abseil {
/// Finds deprecated uses of `absl::Duration` arithmetic operators and factories.
///
llvm::DenseSet<SourceLocation> MatchedTemplateLocations;
};
-} // namespace abseil
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::abseil
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ABSEIL_UPGRADEDURATIONCONVERSIONSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace altera {
+namespace clang::tidy::altera {
/// Finds ID-dependent variables and fields used within loops, and warns of
/// their usage. Using these variables in loops can lead to performance
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace altera
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::altera
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_IDDEPENDENTBACKWARDBRANCHCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace altera {
+namespace clang::tidy::altera {
/// Finds kernel files and include directives whose filename is `kernel.cl`,
/// `Verilog.cl`, or `VHDL.cl`.
Preprocessor *) override;
};
-} // namespace altera
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::altera
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_KERNEL_NAME_RESTRICTION_CHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace altera {
+namespace clang::tidy::altera {
/// Detects OpenCL kernel functions that call a barrier but do not call an
/// ID-function function. These functions will be treated as single work-item
void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
};
-} // namespace altera
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::altera
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_SINGLE_WORK_ITEM_BARRIER_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace altera {
+namespace clang::tidy::altera {
/// Finds structs that are inefficiently packed or aligned, and recommends
/// packing and/or aligning of said structs as needed.
CharUnits computeRecommendedAlignment(CharUnits MinByteSize);
};
-} // namespace altera
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::altera
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_STRUCTPACKALIGNCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace altera {
+namespace clang::tidy::altera {
/// Finds inner loops that have not been unrolled, as well as fully unrolled
/// loops with unknown loop bounds or a large number of iterations.
void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
};
-} // namespace altera
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::altera
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ALTERA_UNROLLLOOPSCHECK_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// Finds code that uses accept4() without using the SOCK_CLOEXEC flag.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT4_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// accept() is better to be replaced by accept4().
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_ACCEPT_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// The base class for all close-on-exec checks in Android module.
/// To be specific, there are some functions that need the close-on-exec flag to
static const char *FuncBindingStr;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// creat() is better to be replaced by open().
/// Find the usage of creat() and redirect user to use open().
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_CREAT_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// dup() is better to be replaced by fcntl(), which has close-on-exec flag.
/// Find the usage of dup() and redirect user to use fcntl().
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_DUP_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// Finds code that uses epoll_create1() without using the EPOLL_CLOEXEC flag.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE1_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// epoll_create() is better to be replaced by epoll_create1().
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_EPOLL_CREATE_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// fopen() is suggested to include "e" in their mode string; like "re" would be
/// better than "r".
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_FOPEN_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// Finds code that uses inotify_init1() without using the IN_CLOEXEC flag.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT1_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// inotify_init() is better to be replaced by inotify_init1().
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_INOTIFY_INIT_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// Finds code that uses memfd_create() without using the MFD_CLOEXEC flag.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_MEMFD_CREATE_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// Finds code that opens file without using the O_CLOEXEC flag.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_OPEN_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// Finds code that uses pipe2() without using the O_CLOEXEC flag.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_PIPE2_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// Suggests to replace calls to pipe() with calls to pipe2().
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_PIPE_H
#include "CloexecCheck.h"
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// Finds code that uses socket() without using the SOCK_CLOEXEC flag.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_CLOEXEC_SOCKET_H
#include "llvm/ADT/StringRef.h"
#include <string>
-namespace clang {
-namespace tidy {
-namespace android {
+namespace clang::tidy::android {
/// Attempts to catch calls to TEMP_FAILURE_RETRY with a top-level comparison
/// operation, like `TEMP_FAILURE_RETRY(read(...) != N)`. In these cases, the
SmallVector<StringRef, 5> RetryMacros;
};
-} // namespace android
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::android
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ANDROID_COMPARISONINTEMPFAILURERETRYCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace boost {
+namespace clang::tidy::boost {
/// Finds calls to ``boost::lexical_cast<std::string>`` and
/// ``boost::lexical_cast<std::wstring>`` and replaces them with
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace boost
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::boost
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BOOST_USE_TO_STRING_H
#include "../ClangTidyCheck.h"
#include "llvm/Support/Regex.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks that argument comments match parameter names.
///
bool shouldAddComment(const Expr *Arg) const;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_ARGUMENTCOMMENTCHECK_H
#include "llvm/ADT/StringRef.h"
#include <string>
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds `assert()` with side effect.
///
const std::vector<StringRef> IgnoredFunctions;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_ASSERTSIDEEFFECTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Catches assignments within the condition clause of an if statement.
///
void report(const Expr *AssignmentExpr);
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_ASSIGNMENTINIFCONDITIONCHECK_H
#include "../ClangTidyCheck.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds ``pthread_kill`` function calls when thread is terminated by
/// ``SIGTERM`` signal.
std::optional<unsigned> SigtermValue;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_BADSIGNALTOKILLTHREADCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks for conditions based on implicit conversion from a bool pointer to
/// bool.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_BOOLPOINTERIMPLICITCONVERSIONCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// A check for detecting if/else if/else chains where two or more branches are
/// Type I clones of each other (that is, they contain identical code), for
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_BRANCHCLONECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds copy constructors where the ctor don't call the copy constructor of
/// the base class.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_COPY_CONSTRUCTOR_INIT_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Detect dangling references in value handlers like
/// std::experimental::string_view.
const ast_matchers::internal::Matcher<RecordDecl> IsAHandle;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DANGLING_HANDLE_H
#include "../ClangTidyCheck.h"
#include "../utils/FileExtensionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds dynamically initialized static variables in header files.
///
utils::FileExtensionsSet HeaderFileExtensions;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DYNAMIC_STATIC_INITIALIZERS_CHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds function definitions where parameters of convertible types follow
/// each other directly, making call sites prone to calling the function with
const std::size_t NamePrefixSuffixSilenceDissimilarityTreshold;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_EASILYSWAPPABLEPARAMETERSCHECK_H
#include "../utils/ExceptionAnalyzer.h"
#include "llvm/ADT/StringSet.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds functions which should not throw exceptions: Destructors, move
/// constructors, move assignment operators, the main() function,
utils::ExceptionAnalyzer Tracer;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_EXCEPTION_ESCAPE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Find and flag invalid initializer values in folds, e.g. std::accumulate.
/// Example:
const ASTContext &Context, const CallExpr &CallNode);
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_FOLD_INIT_TYPE_H
#include <set>
#include <vector>
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks if an unused forward declaration is in a wrong namespace.
///
llvm::SmallPtrSet<const Type *, 16> FriendTypes;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_FORWARDDECLARATIONNAMESPACECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// The checker looks for constructors that can act as copy or move constructors
/// through their forwarding reference parameters. If a non const lvalue
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_FORWARDINGREFERENCEOVERLOADCHECK_H
#include "../utils/IncludeInserter.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Diagnoses instances of an implicit widening of multiplication result.
///
utils::IncludeInserter IncludeInserter;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_IMPLICITWIDENINGOFMULTIPLICATIONRESULTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks for inaccurate use of the `erase()` method.
///
}
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INACCURATEERASECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks the usage of patterns known to produce incorrect rounding.
/// Programmers often use
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INCORRECTROUNDINGSCHECK_H_
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds obvious infinite loops (loops where the condition variable is
/// not changed at all).
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INFINITELOOPCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds cases where integer division in a floating point context is likely to
/// cause unintended loss of precision.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_INTEGER_DIVISION_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Detect when __func__ or __FUNCTION__ is being used from within a lambda. In
/// that context, those expressions expand to the name of the call operator
SourceRangeSet SuppressMacroExpansions;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_LAMBDAFUNCTIONNAMECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds macros that can have unexpected behaviour due to missing parentheses.
///
Preprocessor *ModuleExpanderPP) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MACROPARENTHESESCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks for repeated argument with side effects in macros.
class MacroRepeatedSideEffectsCheck : public ClangTidyCheck {
Preprocessor *ModuleExpanderPP) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MACROREPEATEDSIDEEFFECTSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds cases where ``1`` is added to the string in the argument to a function
/// in the ``strlen()`` family instead of the result and value is used as an
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MISPLACED_OPERATOR_IN_STRLEN_IN_ALLOC_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds cases where an integer is added to or subracted from the result of a
/// memory allocation function instead of its argument.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MISPLACED_OPERATOR_IN_ALLOC_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Find casts of calculation results to bigger type. Typically from int to
/// long. If the intention of the cast is to avoid loss of precision then
const bool CheckImplicitCasts;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// The check warns if std::move is applied to a forwarding reference (i.e. an
/// rvalue reference of a function template argument type).
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MOVEFORWARDINGREFERENCECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Detect multiple statement macros that are used in unbraced conditionals.
/// Only the first statement of the macro will be inside the conditional and the
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_MULTIPLE_STATEMENT_MACRO_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Block arguments in `dispatch_async()` and `dispatch_after()` are guaranteed
/// to escape. If those blocks capture any pointers with the `noescape`
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_NOESCAPECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds function calls where it is possible to cause a not null-terminated
/// result. Usually the proper length of a string is 'strlen(src) + 1' or
const ast_matchers::MatchFinder::MatchResult &Result);
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_NOT_NULL_TERMINATED_RESULT_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds calls to grand..-parent virtual methods instead of parent's.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_PARENTVIRTUALCALLCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
class PosixReturnCheck: public ClangTidyCheck {
public:
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_POSIX_RETURN_CHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds condition variables in nested `if` statements that were also checked
/// in the outer `if` statement and were not changed.
}
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_REDUNDANTBRANCHCONDITIONCHECK_H
#include <string>
#include <vector>
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks for usages of identifiers reserved for use by the implementation.
///
const NamingCheckFailure &Failure) const override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_RESERVEDIDENTIFIERCHECK_H
#include "SmartPtrArrayMismatchCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Find `std::shared_ptr<T>(new T[...])`, replace it (if applicable) with
/// `std::shared_ptr<T[]>(new T[...])`.
SmartPtrClassMatcher getSmartPointerClassMatcher() const override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SHAREDPTRARRAYMISMATCHCHECK_H
#include "llvm/ADT/DepthFirstIterator.h"
#include "llvm/ADT/StringSet.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checker for signal handler functions.
///
llvm::StringSet<> ConformingFunctions;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIGNALHANDLERCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds those ``signed char`` -> integer conversions which might indicate a
/// programming error. The basic problem with the ``signed char``, that it might
const bool DiagnoseSignedUnsignedCharComparisons;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIGNEDCHARMISUSECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Find usages of sizeof on expressions of STL container types. Most likely the
/// user wanted to use `.size()` instead.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIZEOFCONTAINERCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Find suspicious usages of sizeof expression.
///
const bool WarnOnSizeOfPointerToAggregate;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIZEOFEXPRESSIONCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Find constructions of smart (unique or shared) pointers where the pointer
/// is declared with non-array target type and an array (created with a
StringRef const SmartPointerName;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SMARTPTRARRAYMISMATCHCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds ``cnd_wait``, ``cnd_timedwait``, ``wait``, ``wait_for``, or
/// ``wait_until`` function calls when the function is not invoked from a loop
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks for ignored calls to `empty()` on a range and suggests `clear()`
/// as an alternative if it is an existing member function.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STANDALONEEMPTYCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds suspicious string constructor and check their parameters.
///
std::vector<StringRef> StringNames;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRING_CONSTRUCTOR_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds instances where an integer is assigned to a string.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGINTEGERASSIGNMENTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Find suspicious string literals with embedded NUL characters.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGLITERALWITHEMBEDDEDNULCHECK_H
#include "../utils/TransformerClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks for various ways that the `const CharT*` constructor of
/// `std::basic_string_view` can be passed a null argument and replaces them
}
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRINGVIEWNULLPTRCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// The checker detects various cases when an enum is probably misused (as a
/// bitmask).
const bool StrictMode;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSENUMUSAGECHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/FileExtensionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Warns on inclusion of files whose names suggest that they're implementation
/// files, instead of headers. E.g:
const StringRef RawStringImplementationFileExtensions;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSINCLUDECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds potentially incorrect calls to ``memcmp()`` based on properties of the
/// arguments.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSMEMORYCOMPARISONCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds memset calls with potential mistakes in their arguments.
///
}
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUS_MEMSET_USAGE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// This check finds string literals which are probably concatenated
/// accidentally.
const unsigned MaxConcatenatedTokens;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSMISSINGCOMMACHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds usages of ``realloc`` where the return value is assigned to the same
/// variable as passed to the first argument.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSREALLOCUSAGECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// This check finds semicolon that modifies the meaning of the program
/// unintendedly.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSEMICOLONCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Find suspicious calls to string compare functions.
///
const StringRef StringCompareLikeFunctions;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SUSPICIOUSSTRINGCOMPARECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds potentially swapped arguments by looking at implicit conversions.
class SwappedArgumentsCheck : public ClangTidyCheck {
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SWAPPEDARGUMENTSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks if a 'continue' statement terminates the loop (i.e. the loop has
/// a condition which always evaluates to false).
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_TERMINATINGCONTINUECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Emits a warning about temporary objects whose type is (or is derived from) a
/// class that has 'EXCEPTION', 'Exception' or 'exception' in its name.
}
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_THROWKEYWORDMISSINGCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// This check gives a warning if a loop variable has a too small type which
/// might not be able to represent all values which are part of the whole range
const unsigned MagnitudeBitsUpperLimit;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_TOOSMALLLOOPVARIABLECHECK_H
#include "clang/Analysis/FlowSensitive/Models/UncheckedOptionalAccessModel.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Warns when the code is unwrapping a `std::optional<T>`, `absl::optional<T>`,
/// or `base::std::optional<T>` object without assuring that it contains a
dataflow::UncheckedOptionalAccessModelOptions ModelOptions;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNCHECKEDOPTIONALACCESSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds calls of memory manipulation functions ``memset()``, ``memcpy()`` and
/// ``memmove()`` on not TriviallyCopyable objects resulting in undefined
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNDEFINED_MEMORY_MANIPULATION_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds creation of temporary objects in constructors that look like a
/// function call to another constructor of the same class.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNDELEGATEDCONSTRUCTOR_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds calls to 'new' that may throw unhandled exception at allocation
/// failure.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNHANDLEDEXCEPTIONATNEWCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds user-defined copy assignment operators which do not protect the code
/// against self-assignment either by checking self-assignment explicitly or
const bool WarnOnlyIfThisHasSuspiciousField;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNHANDLEDSELFASSIGNMENTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Finds temporaries that look like RAII objects.
///
}
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRAIICHECK_H
#include "../ClangTidyCheck.h"
#include <string>
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Detects function calls where the return value is unused.
///
std::string CheckedFunctions;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_UNUSEDRETURNVALUECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// The check warns if an object is used after it has been moved, without an
/// intervening reinitialization.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_USEAFTERMOVECHECK_H
#include "../ClangTidyCheck.h"
#include "llvm/ADT/DenseMap.h"
-namespace clang {
-namespace tidy {
-namespace bugprone {
+namespace clang::tidy::bugprone {
/// Checks for near miss of virtual methods.
///
const unsigned EditDistanceThreshold = 1;
};
-} // namespace bugprone
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::bugprone
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_VIRTUAL_NEAR_MISS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Execution of a command processor can lead to security vulnerabilities,
/// and is generally not required. Instead, prefer to launch executables
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_COMMAND_PROCESSOR_CHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Checks if an object of type with extended alignment is allocated by using
/// the default operator new.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DEFAULTOPERATORNEWALIGNMENTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Modification of the std or posix namespace can result in undefined behavior.
/// This check warns for such modifications.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DONT_MODIFY_STD_NAMESPACE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// This check diagnoses when the loop induction expression of a for loop has
/// floating-point type. The check corresponds to:
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_FLOAT_LOOP_COUNTER_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Pseudorandom number generators are not genuinely random. The result of the
/// std::rand() function makes no guarantees as to the quality of the random
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_LIMITED_RANDOMNESS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Finds assignments to the copied object and its direct or indirect members
/// in copy constructors and copy assignment operators.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_MUTATINGCOPYCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Flags use of the `C` standard library functions 'memset', 'memcpy' and
/// 'memcmp' and similar derivatives on non-trivial types.
const StringRef MemCmpNames;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_NONTRIVIALTYPESLIBCMEMORYCALLSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Checks if the overloaded postfix ++ and -- operator return a constant
/// object.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_POSTFIX_OPERATOR_H
#include "../ClangTidyCheck.h"
#include <string>
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Random number generator must be seeded properly.
///
SmallVector<StringRef, 5> DisallowedSeedTypes;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_PROPERLY_SEEDED_RANDOM_GENERATOR_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Guards against use of setjmp/longjmp in C++ code
///
Preprocessor *ModuleExpanderPP) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_SETLONGJMPCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Checks whether the constructor for a static or thread_local object will
/// throw.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_ERR58_CPP_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Guards against use of string conversion functions that do not have
/// reasonable error handling for conversion errors.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_STRTONUMCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Checks whether a thrown object is nothrow copy constructible.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_THROWNEXCEPTIONTYPECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cert {
+namespace clang::tidy::cert {
/// Guards against any C-style variadic function definitions (not declarations).
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cert
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cert
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_VARIADICFUNCTIONDEF_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace concurrency {
+namespace clang::tidy::concurrency {
/// Checks that non-thread-safe functions are not used.
///
const FunctionSet FuncSet;
};
-} // namespace concurrency
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::concurrency
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_MTUNSAFECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace concurrency {
+namespace clang::tidy::concurrency {
/// Finds ``pthread_setcanceltype`` function calls where a thread's
/// cancellation type is set to asynchronous.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace concurrency
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::concurrency
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CONCURRENCY_THREADCANCELTYPEASYNCHRONOUSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Const-qualified or reference data members in classes should be avoided, as
/// they make the class non-copy-assignable.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDCONSTORREFDATAMEMBERSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// do-while loops are less readable than plan while loops, and can lead to
/// subtle bugs.
bool IgnoreMacros;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDDOWHILECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// The usage of ``goto`` for control flow is error prone and should be replaced
/// with looping constructs. Only forward jumps in nested loops are accepted.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDGOTOCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Non-const global variables hide dependencies and make the dependencies
/// subject to unpredictable changes.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDNONCONSTGLOBALVARIABLESCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Warns on coroutines that accept reference parameters. Accessing a reference
/// after a coroutine suspension point is not safe since the reference may no
}
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_AVOIDREFERENCECOROUTINEPARAMETERSCHECK_H
#include "../utils/IncludeInserter.h"
#include "../utils/OptionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Find uninitialized local variables.
///
const StringRef MathHeader;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_INITVARIABLESCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Flags possible initialization order issues of static variables.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_INTERFACES_GLOBAL_INIT_H
namespace clang {
class MacroDirective;
-namespace tidy {
-namespace cppcoreguidelines {
+namespace tidy::cppcoreguidelines {
/// Find macro usage that is considered problematic because better language
/// constructs exist for the task.
bool IgnoreCommandLineMacros;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
+} // namespace tidy::cppcoreguidelines
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_MACROUSAGECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Checks for narrowing conversions, e.g:
/// int i = 0;
const bool PedanticMode;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NARROWING_CONVERSIONS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// This checker is concerned with C-style memory management and suggest modern
/// alternatives to it.
const StringRef DeallocList;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_NO_MALLOC_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Checks for common use cases for gsl::owner and enforces the unique owner
/// nature of it whenever possible.
const StringRef LegacyResourceConsumers;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_OWNING_MEMORY_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Finds member initializations in the constructor body which can be placed
/// into the initialization list instead.
const bool UseAssignment;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PREFERMEMBERINITIALIZERCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// This check flags all array to pointer decays
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H
#include "../ClangTidyCheck.h"
#include "../utils/IncludeInserter.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// This checks that all array subscriptions on static arrays and std::arrays
/// have a constant index and are within bounds
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_CONSTANT_ARRAY_INDEX_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Flags all kinds of pointer arithmetic that have result of pointer type, i.e.
/// +, -, +=, -=, ++, --. In addition, the [] operator on pointers (not on
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_POINTER_ARITHMETIC_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// This check flags all instances of const_cast
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// This check flags all use of C-style casts that perform a static_cast
/// downcast, const_cast, or reinterpret_cast.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CSTYLE_CAST_H
#include "../ClangTidyCheck.h"
#include "llvm/ADT/DenseSet.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Implements C++ Core Guidelines Type.6.
///
llvm::DenseSet<const FieldDecl *> HasRecordClassMemberSet;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_MEMBER_INIT_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Flags all occurrences of reinterpret_cast
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_REINTERPRETCAST_CHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Checks for usages of static_cast, where a base class is downcasted to a
/// derived class.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// This check flags all access to members of unions.
/// Access to a union as a whole (e.g. passing to a function) is not flagged.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_UNION_ACCESS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// This check flags all calls to c-style variadic functions and all use
/// of va_arg.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_VARARG_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Flags slicing (incomplete copying of an object's state) of member variables
/// or vtable. See:
const CXXRecordDecl &BaseDecl);
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SLICING_H
#include "llvm/ADT/DenseMapInfo.h"
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Checks for classes where some, but not all, of the special member functions
/// are defined.
ClassDefiningSpecialMembersMap ClassWithSpecialMembers;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
namespace llvm {
/// Specialization of DenseMapInfo to allow ClassDefId objects in DenseMaps
#include "../ClangTidyCheck.h"
#include <string>
-namespace clang {
-namespace tidy {
-namespace cppcoreguidelines {
+namespace clang::tidy::cppcoreguidelines {
/// Finds base classes whose destructor is neither public and virtual
/// nor protected and non-virtual.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace cppcoreguidelines
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::cppcoreguidelines
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_VIRTUALCLASSDESTRUCTORCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace darwin {
+namespace clang::tidy::darwin {
/// Finds usages of OSSpinlock, which is deprecated due to potential livelock
/// problems.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace darwin
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::darwin
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_DARWIN_AVOIDSPINLOCKCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace darwin {
+namespace clang::tidy::darwin {
/// Finds variables of type dispatch_once_t that do not have static or global
/// storage duration, as required by the libdispatch documentation.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace darwin
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::darwin
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_DARWIN_DISPATCHONCENONSTATICCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace fuchsia {
+namespace clang::tidy::fuchsia {
/// Default arguments are not allowed in called functions.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace fuchsia
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::fuchsia
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_CALLS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace fuchsia {
+namespace clang::tidy::fuchsia {
/// Default parameters are not allowed in declared functions.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace fuchsia
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::fuchsia
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_DEFAULT_ARGUMENTS_DECLARATIONS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace fuchsia {
+namespace clang::tidy::fuchsia {
/// Multiple implementation inheritance is discouraged.
///
llvm::StringMap<bool> InterfaceMap;
};
-} // namespace fuchsia
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::fuchsia
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_MULTIPLE_INHERITANCE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace fuchsia {
+namespace clang::tidy::fuchsia {
/// Overloading operators is disallowed by the Fuchsia coding standard.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace fuchsia
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::fuchsia
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_OVERLOADED_OPERATOR_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace fuchsia {
+namespace clang::tidy::fuchsia {
/// Constructing global, non-trivial objects with static storage is
/// disallowed, unless the object is statically initialized with a constexpr
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace fuchsia
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::fuchsia
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_STATICALLY_CONSTRUCTED_OBJECTS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace fuchsia {
+namespace clang::tidy::fuchsia {
/// Functions that have trailing returns are disallowed, except for those
/// using decltype specifiers and lambda with otherwise unutterable
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace fuchsia
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::fuchsia
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_TRAILING_RETURN_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace fuchsia {
+namespace clang::tidy::fuchsia {
/// Defining classes with virtual inheritance is disallowed.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace fuchsia
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::fuchsia
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_FUCHSIA_VIRTUAL_INHERITANCE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace readability {
+namespace clang::tidy::google::readability {
/// Finds usages of C-style casts.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDCSTYLECASTSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace objc {
+namespace clang::tidy::google::objc {
/// This check finds Objective-C code that uses +new to create object instances,
/// or overrides +new in classes. Both are forbidden by Google's Objective-C
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDNSOBJECTNEWCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace objc {
+namespace clang::tidy::google::objc {
/// The check is to find usage of @throw invocation in Objective-C code.
/// We should avoid using @throw for Objective-C exceptions according to
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_OBJC_AVOID_THROWING_EXCEPTION_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace readability {
+namespace clang::tidy::google::readability {
// Check for underscores in the names of googletest tests, per
// https://google.github.io/googletest/faq.html#why-should-test-suite-names-and-test-names-not-contain-underscore
Preprocessor *ModuleExpanderPP) override;
};
-} // namespace readability
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_AVOIDUNDERSCOREINGOOGLETESTNAMECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
+namespace clang::tidy::google {
/// Checks that default parameters are not given for virtual methods.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_DEFAULT_ARGUMENTS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
+namespace clang::tidy::google {
/// Checks that all single-argument constructors are explicit.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITCONSTRUCTORCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace build {
+namespace clang::tidy::google::build {
/// Check that `make_pair`'s template arguments are deduced.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace build
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::build
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_EXPLICITMAKEPAIRCHECK_H
#include "../ClangTidyCheck.h"
#include "llvm/ADT/StringRef.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace objc {
+namespace clang::tidy::google::objc {
/// Finds function names that do not conform to the recommendations of the
/// Google Objective-C Style Guide. Function names should be in upper camel case
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_OBJC_FUNCTION_NAMING_CHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/FileExtensionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace readability {
+namespace clang::tidy::google::readability {
/// Flag global namespace pollution in header files.
/// Right now it only triggers on using declarations and directives.
utils::FileExtensionsSet HeaderFileExtensions;
};
-} // namespace readability
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_GLOBALNAMESINHEADERSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace objc {
+namespace clang::tidy::google::objc {
/// The check for Objective-C global variables and constants naming convention.
/// The declaration should follow the patterns of 'k[A-Z].*' (constants) or
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_OBJC_GLOBAL_VARIABLE_DECLARATION_H
class IdentifierTable;
-namespace tidy {
-namespace google {
-namespace runtime {
+namespace tidy::google::runtime {
/// Finds uses of `short`, `long` and `long long` and suggest replacing them
/// with `u?intXX(_t)?`.
std::unique_ptr<IdentifierTable> IdentTable;
};
-} // namespace runtime
-} // namespace google
-} // namespace tidy
+} // namespace tidy::google::runtime
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_INTEGERTYPESCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace runtime {
+namespace clang::tidy::google::runtime {
/// Finds overloads of unary `operator &`.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace runtime
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::runtime
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_OVERLOADEDUNARYANDCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace readability {
+namespace clang::tidy::google::readability {
/// Finds TODO comments without a username or bug number.
///
std::unique_ptr<TodoCommentHandler> Handler;
};
-} // namespace readability
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_TODOCOMMENTCHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/FileExtensionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace build {
+namespace clang::tidy::google::build {
/// Finds anonymous namespaces in headers.
///
utils::FileExtensionsSet HeaderFileExtensions;
};
-} // namespace build
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::build
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_UNNAMEDNAMESPACEINHEADERCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
+namespace clang::tidy::google {
/// Finds uses of deprecated Googletest APIs with names containing "case" and
/// replaces them with equivalent names containing "suite".
llvm::DenseSet<SourceLocation> MatchedTemplateLocations;
};
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_UPGRADEGOOGLETESTCASECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace google {
-namespace build {
+namespace clang::tidy::google::build {
/// Finds using namespace directives.
///
static bool isStdLiteralsNamespace(const NamespaceDecl *NS);
};
-} // namespace build
-} // namespace google
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::google::build
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_GOOGLE_USINGNAMESPACEDIRECTIVECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace hicpp {
+namespace clang::tidy::hicpp {
/// Check for thrown exceptions and enforce they are all derived from std::exception.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace hicpp
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::hicpp
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_EXCEPTION_BASECLASS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace hicpp {
+namespace clang::tidy::hicpp {
/// Find occasions where not all codepaths are explicitly covered in code.
/// This includes 'switch' without a 'default'-branch and 'if'-'else if'-chains
const bool WarnOnMissingElse;
};
-} // namespace hicpp
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::hicpp
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_MULTIWAY_PATHS_COVERED_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace hicpp {
+namespace clang::tidy::hicpp {
/// Find assembler statements. No fix is offered.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace hicpp
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::hicpp
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_NO_ASSEMBLER_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace hicpp {
+namespace clang::tidy::hicpp {
/// This check implements the rule 5.6.1 of the HICPP Standard, which disallows
/// bitwise operations on signed integer types.
bool IgnorePositiveIntegerLiterals;
};
-} // namespace hicpp
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::hicpp
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_HICPP_SIGNED_BITWISE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace linuxkernel {
+namespace clang::tidy::linuxkernel {
/// Checks Linux kernel code to see if it uses the results from the functions in
/// linux/err.h. Also checks to see if code uses the results from functions that
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace linuxkernel
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::linuxkernel
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LINUXKERNEL_MUSTCHECKERRSCHECK_H
#include "../utils/HeaderGuard.h"
-namespace clang {
-namespace tidy {
-namespace llvm_check {
+namespace clang::tidy::llvm_check {
/// Finds and fixes header guards that do not adhere to LLVM style.
/// For the user-facing documentation see:
std::string getHeaderGuard(StringRef Filename, StringRef OldGuard) override;
};
-} // namespace llvm_check
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::llvm_check
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_HEADERGUARDCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace llvm_check {
+namespace clang::tidy::llvm_check {
/// Checks the correct order of `#includes`.
///
Preprocessor *ModuleExpanderPP) override;
};
-} // namespace llvm_check
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::llvm_check
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_INCLUDEORDERCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace llvm_check {
+namespace clang::tidy::llvm_check {
/// Looks at conditionals and finds and replaces cases of ``cast<>``, which will
/// assert rather than return a null pointer, and ``dyn_cast<>`` where
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace llvm_check
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::llvm_check
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERISAORDYNCASTINCONDITIONALSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace llvm_check {
+namespace clang::tidy::llvm_check {
/// Historically, LLVM has used `unsigned` to represent registers. Since then
/// a `Register` object has been introduced for improved type-safety and make
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace llvm_check
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::llvm_check
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_PREFERREGISTEROVERUNSIGNEDCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace llvm_check {
+namespace clang::tidy::llvm_check {
/// Looks for local `Twine` variables which are prone to use after frees and
/// should be generally avoided.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace llvm_check
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::llvm_check
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVM_TWINELOCALCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace llvm_libc {
+namespace clang::tidy::llvm_libc {
/// Checks all calls resolve to functions within __llvm_libc namespace.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace llvm_libc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::llvm_libc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVMLIBC_CALLEENAMESPACECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace llvm_libc {
+namespace clang::tidy::llvm_libc {
/// Checks all llvm-libc implementation is within the correct namespace.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace llvm_libc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::llvm_libc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVMLIBC_IMPLEMENTATIONINNAMESPACECHECK_H
#include "../ClangTidyCheck.h"
#include "../portability/RestrictSystemIncludesCheck.h"
-namespace clang {
-namespace tidy {
-namespace llvm_libc {
+namespace clang::tidy::llvm_libc {
/// Warns of accidental inclusions of system libc headers that aren't
/// compiler provided.
Preprocessor *ModuleExpanderPP) override;
};
-} // namespace llvm_libc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::llvm_libc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_LLVMLIBC_RESTRICTSYSTEMLIBCHEADERSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// Finds symbol which have confusable identifiers, i.e. identifiers that look
/// the same visually but have a different Unicode representation.
llvm::StringMap<llvm::SmallVector<const NamedDecl *>> Mapper;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONFUSABLE_IDENTIFIER_CHECK_H
#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
#include "llvm/ADT/DenseSet.h"
-namespace clang {
-namespace tidy {
-
-namespace misc {
+namespace clang::tidy::misc {
/// This check warns on variables which could be declared const but are not.
///
const bool TransformPointersAsValues;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_CONSTCORRECTNESSCHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/FileExtensionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// Finds non-extern non-inline function and variable definitions in header
/// files, which can lead to potential ODR violations.
utils::FileExtensionsSet HeaderFileExtensions;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_DEFINITIONS_IN_HEADERS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
class MisleadingBidirectionalCheck : public ClangTidyCheck {
public:
std::unique_ptr<MisleadingBidirectionalHandler> Handler;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISLEADINGBIDIRECTIONALCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
class MisleadingIdentifierCheck : public ClangTidyCheck {
public:
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISLEADINGIDENTIFIERCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// This check diagnoses when a const qualifier is applied to a typedef to a
/// pointer type rather than to the pointee.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MISPLACED_CONST_H
#include "llvm/ADT/SmallVector.h"
#include <map>
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
class NewDeleteOverloadsCheck : public ClangTidyCheck {
std::map<const clang::CXXRecordDecl *,
void onEndOfTranslationUnit() override;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NEWDELETEOVERLOADS_H
class CallGraphNode;
-namespace tidy {
-namespace misc {
+namespace tidy::misc {
/// Finds strongly connected functions (by analyzing call graph for SCC's
/// that are loops), diagnoses each function in the cycle,
void handleSCC(ArrayRef<CallGraphNode *> SCC);
};
-} // namespace misc
-} // namespace tidy
+} // namespace tidy::misc
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NORECURSIONCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// The check flags dereferences and non-pointer declarations of objects that
/// are not meant to be passed by value, such as C FILE objects.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONCOPYABLEOBJECTS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// This checker finds classes that not only contain the data
/// (non-static member variables), but also have logic (non-static member
const bool IgnorePublicMemberVariables;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_NONPRIVATEMEMBERVARIABLESINCLASSESCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// The checker detects expressions that are redundant, because they contain
/// ineffective, useless parts.
void checkRelationalExpr(const ast_matchers::MatchFinder::MatchResult &R);
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_REDUNDANT_EXPRESSION_H
#include "llvm/ADT/StringRef.h"
#include <string>
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// Replaces `assert()` with `static_assert()` if the condition is evaluatable
/// at compile time.
SourceLocation AssertLoc);
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STATICASSERTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
///checks for locations that do not throw by value
// or catch by reference.
uint64_t MaxSize; // No `const` because we have to set it in two steps.
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_THROW_BY_VALUE_CATCH_BY_REFERENCE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// Finds declarations of assignment operators with the wrong return and/or
/// argument types and definitions with good return type but wrong return
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ASSIGNOPERATORSIGNATURECHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/IncludeInserter.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// Find and replace `unique_ptr::reset(release())` with `std::move()`.
///
utils::IncludeInserter Inserter;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNIQUEPTRRESETRELEASECHECK_H
#include "../ClangTidyCheck.h"
#include "llvm/ADT/DenseMap.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// Finds unused namespace alias declarations.
class UnusedAliasDeclsCheck : public ClangTidyCheck {
llvm::DenseMap<const NamedDecl *, CharSourceRange> FoundDecls;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// Finds unused parameters and fixes them, so that `-Wunused-parameter` can be
/// turned on.
const FunctionDecl *Function, unsigned ParamIndex);
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H
#include "llvm/ADT/SmallPtrSet.h"
#include <vector>
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// Finds unused using declarations.
///
utils::FileExtensionsSet HeaderFileExtensions;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_USING_DECLS_H
#include "../ClangTidyCheck.h"
#include "../utils/FileExtensionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace misc {
+namespace clang::tidy::misc {
/// Warns when using 'static' functions or variables at global scope, and
/// suggests moving them to an anonymous namespace.
utils::FileExtensionsSet HeaderFileExtensions;
};
-} // namespace misc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::misc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_USEANONYMOUSNAMESPACECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Replace simple uses of std::bind with a lambda.
///
private:
bool PermissiveParameterList = false;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOID_BIND_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Find C-style array types and recommend to use std::array<> / std::vector<>.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_AVOIDCARRAYSCHECK_H
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
class ConcatNestedNamespacesCheck : public ClangTidyCheck {
public:
NamespaceString concatNamespaces();
NamespaceContextVec Namespaces;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_CONCATNESTEDNAMESPACESCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// This check replaces deprecated C library headers with their C++ STL
/// alternatives.
bool CheckHeaderFile;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_C_HEADERS_TO_CXX_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// This check warns the uses of the deprecated member types of ``std::ios_base``
/// and replaces those that have a non-deprecated equivalent.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_DEPRECATEDIOSBASEALIASESCHECK_H
#include <clang/Lex/Token.h>
#include <llvm/ADT/ArrayRef.h>
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
enum class LiteralSize {
Unknown = 0,
bool CommaAllowed;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif
#include "../utils/IncludeInserter.h"
#include "LoopConvertUtils.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
class LoopConvertCheck : public ClangTidyCheck {
public:
std::string ReverseHeader;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_LOOP_CONVERT_H
#include <string>
#include <utility>
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
enum LoopFixerKind {
LFK_Array,
bool declarationExists(llvm::StringRef Symbol);
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_LOOP_CONVERT_UTILS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
class MacroToEnumCallbacks;
MacroToEnumCallbacks *PPCallback{};
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MACROTOENUMCHECK_H
#include "MakeSmartPtrCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Replace the pattern:
/// \code
SmartPtrTypeMatcher getSmartPointerTypeMatcher() const override;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SHARED_H
#include "llvm/ADT/StringRef.h"
#include <string>
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Base class for MakeSharedCheck and MakeUniqueCheck.
class MakeSmartPtrCheck : public ClangTidyCheck {
void insertHeader(DiagnosticBuilder &Diag, FileID FD);
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_SMART_PTR_H
#include "MakeSmartPtrCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Replace the pattern:
/// \code
const bool RequireCPlusPlus14;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_MAKE_UNIQUE_H
#include <memory>
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
class PassByValueCheck : public ClangTidyCheck {
public:
const bool ValuesOnly;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_PASS_BY_VALUE_H
#include "../ClangTidyCheck.h"
#include <bitset>
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
using CharsBitSet = std::bitset<1 << CHAR_BIT>;
const bool ReplaceShorterLiterals;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_RAW_STRING_LITERAL_H
#include <string>
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Find and remove redundant void argument lists.
///
void removeVoidToken(Token VoidToken, StringRef Diagnostic);
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REDUNDANT_VOID_ARG_CHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/IncludeInserter.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Transforms the deprecated `std::auto_ptr` into the C++11 `std::unique_ptr`.
///
utils::IncludeInserter Inserter;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACE_AUTO_PTR_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// This check finds macro expansions of ``DISALLOW_COPY_AND_ASSIGN(Type)`` and
/// replaces them with a deleted copy constructor and a deleted assignment
const StringRef MacroName;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACEDISALLOWCOPYANDASSIGNMACROCHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/IncludeInserter.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// std::random_shuffle will be removed as of C++17. This check will find and
/// replace all occurrences of std::random_shuffle with std::shuffle.
utils::IncludeInserter IncludeInserter;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_REPLACE_RANDOM_SHUFFLE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Use a braced init list for return statements rather than unnecessary
/// repeating the return type name.
}
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_RETURN_BRACED_INIT_LIST_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Replace copy and swap tricks on shrinkable containers with the
/// `shrink_to_fit()` method call.
}
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_SHRINKTOFITCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Replaces a static_assert declaration with an empty message
/// with the unary version.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_UNARY_STATIC_ASSERT_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
class UseAutoCheck : public ClangTidyCheck {
public:
const bool RemoveStars;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_AUTO_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Finds integer literals which are cast to bool.
///
const bool IgnoreMacros;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_BOOL_LITERALS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Convert a default constructor's member initializers into default member
/// initializers. Remove member initializers that are the same as a default
const bool IgnoreMacros;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_DEFAULT_MEMBER_INIT_H
#include <string>
#include <vector>
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// This check looks for cases when inserting new element into std::vector but
/// the element is constructed temporarily.
const std::vector<StringRef> EmplacyFunctions;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EMPLACE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Replace default bodies of special member functions with '= default;'.
/// \code
const bool IgnoreMacros;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DEFAULT_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Mark unimplemented private special member functions with '= delete'.
/// \code
const bool IgnoreMacros;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_EQUALS_DELETE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Add ``[[nodiscard]]`` to non-void const-member functions with no
/// arguments or pass-by-value or pass by const-reference arguments.
const StringRef NoDiscardMacro;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USENODISCARDCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Replace dynamic exception specifications, with
/// `noexcept` (or user-defined macro) or `noexcept(false)`.
const bool UseNoexceptFalse;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NOEXCEPT_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
class UseNullptrCheck : public ClangTidyCheck {
public:
SmallVector<StringRef, 1> NullMacros;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_NULLPTR_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Use C++11's `override` and remove `virtual` where applicable.
class UseOverrideCheck : public ClangTidyCheck {
const StringRef FinalSpelling;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USEOVERRIDECHECK_H
#include "clang/Lex/Token.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
struct ClassifiedToken {
Token T;
const SourceManager &SM, const LangOptions &LangOpts);
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USETRAILINGRETURNTYPECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Prefer using transparent functors to non-transparent ones.
///
const bool SafeMode;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_TRANSPARENT_FUNCTORS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// This check will warn on calls to std::uncaught_exception and replace them with calls to
/// std::uncaught_exceptions, since std::uncaught_exception was deprecated in C++17. In case of
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_UNCAUGHT_EXCEPTIONS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace modernize {
+namespace clang::tidy::modernize {
/// Check finds typedefs and replaces it with usings.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace modernize
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::modernize
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MODERNIZE_USE_USING_H
#include "clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace mpi {
+namespace clang::tidy::mpi {
/// This check verifies if a buffer passed to an MPI (Message Passing Interface)
/// function is sufficiently dereferenced. Buffers should be passed as a single
std::optional<ento::mpi::MPIFunctionClassifier> FuncClassifier;
};
-} // namespace mpi
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::mpi
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MPI_BUFFER_DEREF_H
#include "clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace mpi {
+namespace clang::tidy::mpi {
/// This check verifies if buffer type and MPI (Message Passing Interface)
/// datatype pairs match. All MPI datatypes defined by the MPI standard (3.1)
std::optional<ento::mpi::MPIFunctionClassifier> FuncClassifier;
};
-} // namespace mpi
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::mpi
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MPI_TYPE_MISMATCH_H
#include "../ClangTidyCheck.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
-namespace clang {
-namespace tidy {
-namespace objc {
+namespace clang::tidy::objc {
/// Warn if XCTAssertEqual() or XCTAssertNotEqual() is used with at least one
/// operands of type NSString*.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::objc
#endif // THIRD_PARTY_LLVM_LLVM_PROJECT_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_OBJCASSERTEQUALS_H_
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace objc {
+namespace clang::tidy::objc {
/// Finds usages of -[NSError init]. It is not the proper way of creating
/// NSError. errorWithDomain:code:userInfo: should be used instead.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_AVOIDNSERRORINITCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace objc {
+namespace clang::tidy::objc {
/// Finds implementations of -dealloc in Objective-C categories. The category
/// implementation will override any dealloc in the class implementation,
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_DEALLOCINCATEGORYCHECK_H
#include "llvm/ADT/StringRef.h"
#include <vector>
-namespace clang {
-namespace tidy {
-namespace objc {
+namespace clang::tidy::objc {
/// Finds Objective-C classes which have a superclass which is
/// documented to not support subclassing.
const std::vector<StringRef> ForbiddenSuperClassNames;
};
-} // namespace objc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_FORBIDDEN_SUBCLASSING_CHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace objc {
+namespace clang::tidy::objc {
/// Finds Objective-C implementations that implement -isEqual: without also
/// appropriately implementing -hash.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_MISSINGHASHCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace objc {
+namespace clang::tidy::objc {
/// Checks the string pattern used as a date format specifier and reports
/// warnings if it contains any incorrect sub-pattern.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_NSDATEFORMATTERCHECK_H
#include "../ClangTidyCheck.h"
#include "clang/Basic/LangStandard.h"
-namespace clang {
-namespace tidy {
-namespace objc {
+namespace clang::tidy::objc {
/// Finds calls to NSInvocation methods under ARC that don't have proper
/// argument object lifetimes.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_NSINVOCATIONARGUMENTLIFETIMECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace objc {
+namespace clang::tidy::objc {
/// Finds Objective-C property declarations which
/// are not in Lower Camel Case.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_PROPERTY_DECLARATION_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace objc {
+namespace clang::tidy::objc {
/// Finds invocations of -self on super instances in initializers of subclasses
/// of NSObject and recommends calling a superclass initializer instead.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace objc
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::objc
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OBJC_SUPERSELFCHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/ExceptionAnalyzer.h"
-namespace clang {
-namespace tidy {
-namespace openmp {
+namespace clang::tidy::openmp {
/// Analyzes OpenMP Structured Blocks and checks that no exception escapes
/// out of the Structured Block it was thrown in.
utils::ExceptionAnalyzer Tracer;
};
-} // namespace openmp
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::openmp
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OPENMP_EXCEPTIONESCAPECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace openmp {
+namespace clang::tidy::openmp {
/// Finds OpenMP directives that are allowed to contain a ``default`` clause,
/// but either don't specify it or the clause is specified but with the kind
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace openmp
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::openmp
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_OPENMP_USEDEFAULTNONECHECK_H
#include <string>
#include <vector>
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// Optimize calls to std::string::find() and friends when the needle passed is
/// a single character string literal.
const std::vector<StringRef> StringLikeClasses;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_FASTER_STRING_FIND_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// A check that detects copied loop variables and suggests using const
/// references.
const std::vector<StringRef> AllowedTypes;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_FORRANGECOPYCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
// Checks that in a for range loop, if the provided type is a reference, then
// the underlying type is the one returned by the iterator (i.e. that there
const Expr *OperatorCall);
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_IMPLICIT_CONVERSION_IN_LOOP_CHECK_H_
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// Warns on inefficient use of STL algorithms on associative containers.
///
}
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_INEFFICIENTALGORITHMCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// This check is to warn about the performance overhead arising from
/// concatenating strings, using the operator+, instead of operator+=.
const bool StrictMode;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_INEFFICIENTSTRINGCONCATENATION_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// Finds possible inefficient `std::vector` operations (e.g. `push_back`) in
/// for loops that may cause unnecessary memory reallocations.
bool EnableProto;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_INEFFICIENT_VECTOR_OPERATION_H
#include "../ClangTidyCheck.h"
#include "llvm/ADT/DenseSet.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// Find casts of calculation results to bigger type. Typically from int to
///
llvm::DenseSet<const CallExpr *> AlreadyCheckedMoves;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_MOVECONSTANTARGUMENTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// The check flags user-defined move constructors that have a ctor-initializer
/// initializing a member or base class through a copy constructor instead of a
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_MOVECONSTRUCTORINITCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// Finds local variables that cannot be automatically moved due to constness.
/// For the user-facing documentation see:
const std::vector<StringRef> AllowedTypes;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOAUTOMATICMOVECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// Diagnoses every integer to pointer cast.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOINTTOPTRCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// The check flags user-defined move constructors and assignment operators not
/// marked with `noexcept` or marked with `noexcept(expr)` where `expr`
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_NOEXCEPTMOVECONSTRUCTORCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// A check that finds classes that would be trivial if not for the defaulted
/// destructors declared out-of-line:
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_TRIVIALLYDESTRUCTIBLECHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/IncludeInserter.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// Finds calls to C math library functions with implicit float to double
/// promotions.
utils::IncludeInserter IncludeInserter;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_TYPE_PROMOTION_IN_MATH_FN_H
#include "../ClangTidyCheck.h"
#include "clang/AST/Decl.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
// The check detects local variable declarations that are copy initialized with
// the const reference of a function call or the const reference of a method
const std::vector<StringRef> ExcludedContainerTypes;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNNECESSARY_COPY_INITIALIZATION_H
#include "../utils/IncludeInserter.h"
#include "clang/Analysis/Analyses/ExprMutationAnalyzer.h"
-namespace clang {
-namespace tidy {
-namespace performance {
+namespace clang::tidy::performance {
/// A check that flags value parameters of expensive to copy types that
/// can safely be converted to const references.
const std::vector<StringRef> AllowedTypes;
};
-} // namespace performance
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::performance
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_UNNECESSARY_VALUE_PARAM_H
#include "../GlobList.h"
#include "clang/Lex/PPCallbacks.h"
-namespace clang {
-namespace tidy {
-namespace portability {
+namespace clang::tidy::portability {
/// Checks for allowed includes and suggests removal of any others. If no
/// includes are specified, the check will exit without issuing any warnings.
const SourceManager &SM;
};
-} // namespace portability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::portability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_RESTRICTINCLUDESSCHECK_H
#include "llvm/ADT/SmallString.h"
-namespace clang {
-namespace tidy {
-namespace portability {
+namespace clang::tidy::portability {
/// Find SIMD intrinsics calls and suggest std::experimental::simd alternatives.
///
const bool Suggest;
};
-} // namespace portability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::portability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_SIMD_INTRINSICS_CHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace portability {
+namespace clang::tidy::portability {
/// Report use of ``std::vector<const T>`` (and similar containers of const
/// elements). These are not allowed in standard C++ due to undefined
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace portability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::portability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PORTABILITY_STDALLOCATORCONSTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
// Detect function declarations that have const value parameters and discourage
// them.
const bool IgnoreMacros;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_AVOID_CONST_PARAMS_IN_DECLS_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks that bodies of `if` statements and loops (`for`, `range-for`,
/// `do-while`, and `while`) are inside braces
const unsigned ShortStatementLines;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_BRACESAROUNDSTATEMENTSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// For any function whose return type is const-qualified, suggests removal of
/// the `const` qualifier from that return type.
const bool IgnoreMacros;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONSTRETURNTYPECHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Finds usages of `container.count()` and `find() == end()` which should be
/// replaced by a call to the `container.contains()` method introduced in C++20.
}
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONTAINERCONTAINSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks whether a call to `operator[]` and `&` can be replaced with a call to
/// `data()`.
///
return TK_IgnoreUnlessSpelledInSource;
}
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONTAINERDATAPOINTERCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks whether a call to the `size()` method can be replaced with a call to
/// `empty()`.
}
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONTAINERSIZEEMPTYCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// This check finds C++ class methods than can be made static
/// because they don't use the 'this' pointer.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_CONVERTMEMFUNCTOSTATIC_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Check whether the 'if' statement is unnecessary before calling 'delete' on a
/// pointer.
}
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_DELETE_NULL_POINTER_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// \brief Find and remove duplicate #include directives.
///
Preprocessor *ModuleExpanderPP) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_DUPLICATE_INCLUDE_CHECK_H
#include "../ClangTidyCheck.h"
#include "llvm/ADT/DenseMap.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Flags the usages of `else` after `return`.
///
ConditionalBranchMap PPConditionals;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_ELSEAFTERRETURNCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks function Cognitive Complexity metric.
///
const bool IgnoreMacros;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_FUNCTIONCOGNITIVECOMPLEXITYCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks for large functions based on various metrics.
///
const unsigned VariableThreshold;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_FUNCTIONSIZECHECK_H
#include "../ClangTidyCheck.h"
#include "llvm/Support/Regex.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Warns about identifiers names whose length is too short.
///
llvm::Regex IgnoredParameterNames;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERLENGTHCHECK_H
#include "../utils/RenamerClangTidyCheck.h"
#include <optional>
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
namespace readability {
enum StyleKind : int;
std::pair<readability::IdentifierNamingCheck::CaseType, StringRef>>
getEnumMapping();
};
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks for use of implicit bool conversions in expressions.
///
const bool AllowPointerConditions;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IMPLICIT_BOOL_CONVERSION_H
#include "llvm/ADT/DenseSet.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks for declarations of functions which differ in parameter names.
///
const bool Strict;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_INCONSISTENT_DECLARATION_PARAMETER_NAME_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// This check diagnoses all DeclStmt's declaring more than one variable and
/// tries to refactor the code to one statement per declaration.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_ISOLATEDECLCHECK_H
#include <llvm/ADT/APFloat.h>
#include <llvm/ADT/SmallVector.h>
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Detects magic numbers, integer and floating point literals embedded in code.
///
IgnoredDoublePointValues;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MAGICNUMBERSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Finds non-static member functions that can be made 'const'.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MAKEMEMBERFUNCTIONCONSTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks the code for dangling else, and possible misleading indentations due
/// to missing braces. Note that this check only works as expected when the tabs
void missingBracesCheck(const SourceManager &SM, const CompoundStmt *CStmt);
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MISLEADING_INDENTATION_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Warn about unusual array index syntax (`index[array]` instead of
/// `array[index]`).
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_MISPLACED_ARRAY_INDEX_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Find functions with unnamed arguments.
///
}
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NAMEDPARAMETERCHECK_H
#include "../ClangTidyCheck.h"
#include "llvm/Support/Regex.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks that long namespaces have a closing comment.
///
llvm::SmallVector<SourceLocation, 4> Ends;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NAMESPACECOMMENTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Warn when a pointer function parameter can be const.
///
void diagnoseNonConstParameters();
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_NON_CONST_PARAMETER_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Finds variables declared as auto that could be declared as:
/// 'auto*' or 'const auto *' and reference variables declared as:
const bool AddConstToQualified;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_QUALIFIEDAUTOCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Detects redundant access specifiers inside classes, structs, and unions.
///
const bool CheckFirstDeclaration;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTACCESSSPECIFIERSCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Eliminates redundant `return` statements at the end of a function that
/// returns `void`.
const char *Diag);
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_CONTROL_FLOW_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Find redundant variable declarations.
///
const bool IgnoreMacros;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_DECLARATION_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Eliminate redundant dereferences of a function pointer.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_FUNCTION_PTR_DEREFERENCE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Finds member initializations that are unnecessary because the same default
/// constructor would be called if they were not present.
bool IgnoreBaseInCopyConstructors;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_MEMBER_INIT_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// This check flags redundant preprocessor directives: nested directives with
/// the same condition.
Preprocessor *ModuleExpanderPP) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTPREPROCESSORCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Find and remove redundant calls to smart pointer's `.get()` method.
///
const bool IgnoreMacros;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTSMARTPTRGETCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Finds unnecessary calls to `std::string::c_str()`.
class RedundantStringCStrCheck : public ClangTidyCheck {
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANTSTRINGCSTRCHECK_H
#include <string>
#include <vector>
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Finds unnecessary string initializations.
class RedundantStringInitCheck : public ClangTidyCheck {
std::vector<StringRef> StringNames;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_REDUNDANT_STRING_INIT_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Looks for boolean expressions involving boolean constants and simplifies
/// them to use the appropriate boolean expression directly.
const bool SimplifyDeMorganRelaxed;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_SIMPLIFY_BOOLEAN_EXPR_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Simplifies subscript expressions.
///
const std::vector<StringRef> Types;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_SIMPLIFYSUBSCRIPTEXPRCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Checks for member expressions that access static members through
/// instances and replaces them with uses of the appropriate qualified-id.
const unsigned NameSpecifierNestingThreshold;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STATIC_ACCESSED_THROUGH_INSTANCE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Finds static function and variable definitions in anonymous namespace.
///
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STATIC_DEFINITION_IN_ANONYMOUS_NAMESPACE_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// This check flags all calls compare when used to check for string
/// equality or inequality.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_STRINGCOMPARECHECK_H
#include "llvm/ADT/StringSet.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Finds function calls where the arguments passed are provided out of order,
/// based on the difference between the argument name and the parameter names
BoundKind BK) const;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_SUSPICIOUSCALLARGUMENTCHECK_H
#include "../ClangTidyCheck.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Flags statements of the form ``delete <unique_ptr expr>.release();`` and
/// replaces them with: ``<unique_ptr expr> = nullptr;``
const bool PreferResetCall;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UNIQUEPTR_DELETE_RELEASE_H
#include "../ClangTidyCheck.h"
#include "../utils/OptionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Detects when the integral literal or floating point literal has
/// non-uppercase suffix, and suggests to make the suffix uppercase.
const bool IgnoreMacros;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_UPPERCASELITERALSUFFIXCHECK_H
#include "../ClangTidyCheck.h"
#include "../utils/IncludeInserter.h"
-namespace clang {
-namespace tidy {
-namespace readability {
+namespace clang::tidy::readability {
/// Finds ranged-based for loops that can be replaced by a call to std::any_of
/// or std::all_of.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
};
-} // namespace readability
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::readability
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_USEALGORITHMCHECK_H
///
//===----------------------------------------------------------------------===//
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
int clangTidyMain(int argc, const char **argv);
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy
#include "clang/AST/AST.h"
-namespace clang {
-namespace tidy {
-namespace utils {
+namespace clang::tidy::utils {
// Returns the (closest) Function declaration surrounding |Statement| or NULL.
const FunctionDecl *getSurroundingFunction(ASTContext &Context,
const Stmt &Statement);
// FIXME: false-negative if the entire range is fully expanded from a macro.
bool rangeCanBeFixed(SourceRange Range, const SourceManager *SM);
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ASTUTILS_H
#include "clang/AST/Decl.h"
-namespace clang {
-namespace tidy {
-namespace utils {
+namespace clang::tidy::utils {
/// Returns whether \p Var has a pointer or reference in \p Func.
///
bool hasPtrOrReferenceInFunc(const Decl *Func, const VarDecl *Var);
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_ALIASING_H
#include "clang/AST/Type.h"
#include "llvm/ADT/SmallPtrSet.h"
-namespace clang {
-namespace tidy {
-namespace utils {
-namespace decl_ref_expr {
+namespace clang::tidy::utils::decl_ref_expr {
/// Returns true if all ``DeclRefExpr`` to the variable within ``Stmt``
/// do not modify it.
bool isCopyAssignmentArgument(const DeclRefExpr &DeclRef, const Decl &Decl,
ASTContext &Context);
-} // namespace decl_ref_expr
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils::decl_ref_expr
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_DECLREFEXPRUTILS_H
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/StringSet.h"
-namespace clang {
-namespace tidy {
-namespace utils {
+namespace clang::tidy::utils {
/// This class analysis if a `FunctionDecl` can in principle throw an
/// exception, either directly or indirectly. It can be configured to ignore
std::map<const FunctionDecl *, ExceptionInfo> FunctionCache;
};
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_EXCEPTION_ANALYZER_H
#include "../ClangTidy.h"
-namespace clang {
-namespace tidy {
-namespace utils {
+namespace clang::tidy::utils {
/// Provides information about the evaluation order of (sub-)expressions within
/// a `CFGBlock`.
llvm::DenseMap<const Stmt *, const CFGBlock *> Map;
};
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_EXPRSEQUENCE_H
#include "llvm/ADT/StringRef.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace utils {
+namespace clang::tidy::utils {
typedef llvm::SmallSet<llvm::StringRef, 5> FileExtensionsSet;
bool isFileExtension(StringRef FileName,
const FileExtensionsSet &FileExtensions);
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FILE_EXTENSIONS_UTILS_H
#include "clang/Sema/DeclSpec.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace utils {
-namespace fixit {
+namespace clang::tidy::utils::fixit {
/// Creates fix to make ``VarDecl`` a reference by adding ``&``.
FixItHint changeVarDeclToReference(const VarDecl &Var, ASTContext &Context);
DeclSpec::TQ Qualifier,
QualifierTarget CT = QualifierTarget::Pointee,
QualifierPolicy CP = QualifierPolicy::Left);
-} // namespace fixit
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils::fixit
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FIXITHINTUTILS_H
#include "../ClangTidyCheck.h"
#include "../utils/FileExtensionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace utils {
+namespace clang::tidy::utils {
/// Finds and fixes header guards.
/// The check supports these options:
utils::FileExtensionsSet HeaderFileExtensions;
};
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_HEADERGUARD_H
namespace clang {
class Preprocessor;
-namespace tidy {
-namespace utils {
+namespace tidy::utils {
/// Produces fixes to insert specified includes to source files, if not
/// yet present.
friend class IncludeInserterCallback;
};
-} // namespace utils
-} // namespace tidy
+} // namespace tidy::utils
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDEINSERTER_H
#include <optional>
#include <string>
-namespace clang {
-namespace tidy {
+namespace clang::tidy {
namespace utils {
/// Class used by ``IncludeInserterCallback`` to record the names of the
static ArrayRef<std::pair<utils::IncludeSorter::IncludeStyle, StringRef>>
getEnumMapping();
};
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_INCLUDESORTER_H
class Stmt;
-namespace tidy {
-namespace utils {
-namespace lexer {
+namespace tidy::utils::lexer {
/// Returns previous token or ``tok::unknown`` if not found.
Token getPreviousToken(SourceLocation Location, const SourceManager &SM,
SourceLocation getUnifiedEndLoc(const Stmt &S, const SourceManager &SM,
const LangOptions &LangOpts);
-} // namespace lexer
-} // namespace utils
-} // namespace tidy
+} // namespace tidy::utils::lexer
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_LEXER_UTILS_H
#include "clang/ASTMatchers/ASTMatchers.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace matchers {
+namespace clang::tidy::matchers {
AST_MATCHER(BinaryOperator, isRelationalOperator) {
return Node.isRelationalOp();
new MatchesAnyListedNameMatcher(NameList));
}
-} // namespace matchers
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::matchers
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_MATCHERS_H
#include <map>
#include <optional>
-namespace clang {
-namespace tidy {
-namespace utils {
+namespace clang::tidy::utils {
// This class creates function-level namespace aliases.
class NamespaceAliaser {
AddedAliases;
};
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_NAMESPACEALIASER_H
#include <string>
#include <vector>
-namespace clang {
-namespace tidy {
-namespace utils {
-namespace options {
+namespace clang::tidy::utils::options {
/// Parse a semicolon separated list of strings.
std::vector<StringRef> parseStringList(StringRef Option);
/// ``parseStringList``.
std::string serializeStringList(ArrayRef<StringRef> Strings);
-} // namespace options
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils::options
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_OPTIONUTILS_H
#include "clang/Tooling/Transformer/Transformer.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace utils {
+namespace clang::tidy::utils {
/// A base class for defining a ClangTidy check based on a `RewriteRule`.
//
IncludeInserter Inserter;
};
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_TRANSFORMER_CLANG_TIDY_CHECK_H
#include "clang/AST/Type.h"
#include <optional>
-namespace clang {
-namespace tidy {
-namespace utils {
-namespace type_traits {
+namespace clang::tidy::utils::type_traits {
/// Returns `true` if `Type` is expensive to copy.
std::optional<bool> isExpensiveToCopy(QualType Type, const ASTContext &Context);
/// Return true if `Type` has a non-trivial move assignment operator.
bool hasNonTrivialMoveAssignment(QualType Type);
-} // namespace type_traits
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils::type_traits
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_TYPETRAITS_H
#include <optional>
#include <set>
-namespace clang {
-namespace tidy {
-namespace utils {
+namespace clang::tidy::utils {
// UsingInserter adds using declarations for |QualifiedName| to the surrounding
// function.
std::set<NameInFunction> AddedUsing;
};
-} // namespace utils
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::utils
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_USINGINSERTER_H
#include "../ClangTidyCheck.h"
#include "../utils/OptionsUtils.h"
-namespace clang {
-namespace tidy {
-namespace zircon {
+namespace clang::tidy::zircon {
/// Construction of specific temporary objects in the Zircon kernel is
/// discouraged.
std::vector<StringRef> Names;
};
-} // namespace zircon
-} // namespace tidy
-} // namespace clang
+} // namespace clang::tidy::zircon
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_ZIRCON_TEMPORARYOBJECTSCHECK_H
projects / platform / upstream / llvm.git / commitdiff