18#include "../ClangTidy.h"
19#include "../ClangTidyForceLinker.h"
20#include "../GlobList.h"
21#include "clang/Tooling/CommonOptionsParser.h"
22#include "llvm/ADT/StringSet.h"
23#include "llvm/Support/InitLLVM.h"
24#include "llvm/Support/PluginLoader.h"
25#include "llvm/Support/Process.h"
26#include "llvm/Support/Signals.h"
27#include "llvm/Support/TargetSelect.h"
28#include "llvm/Support/WithColor.h"
34static cl::desc
desc(StringRef description) {
return {description.ltrim()}; }
38static cl::extrahelp
CommonHelp(CommonOptionsParser::HelpMessage);
41 clang-tidy attempts to read configuration for each source file from a
42 .clang-tidy file located in the closest parent directory of the source
43 file. The .clang-tidy file is specified in YAML format. If any configuration
44 options have a corresponding command-line option, command-line option takes
47 The following configuration options may be used in a .clang-tidy file:
49 CheckOptions - List of key-value pairs defining check-specific
52 some-check.SomeOption: 'some value'
53 Checks - Same as '--checks'. Additionally, the list of
54 globs can be specified as a list instead of a
56 ExtraArgs - Same as '--extra-args'.
57 ExtraArgsBefore - Same as '--extra-args-before'.
58 FormatStyle - Same as '--format-style'.
59 HeaderFileExtensions - File extensions to consider to determine if a
60 given diagnostic is located in a header file.
61 HeaderFilterRegex - Same as '--header-filter-regex'.
62 ImplementationFileExtensions - File extensions to consider to determine if a
63 given diagnostic is located in an
65 InheritParentConfig - If this option is true in a config file, the
66 configuration file in the parent directory
67 (if any exists) will be taken and the current
68 config file will be applied on top of the
70 SystemHeaders - Same as '--system-headers'.
71 UseColor - Same as '--use-color'.
72 User - Specifies the name or e-mail of the user
73 running clang-tidy. This option is used, for
74 example, to place the correct user name in
75 TODO() comments in the relevant check.
76 WarningsAsErrors - Same as '--warnings-as-errors'.
78 The effective configuration can be inspected using --dump-config:
80 $ clang-tidy --dump-config
82 Checks: '-*,some-check'
84 HeaderFileExtensions: ['', 'h','hh','hpp','hxx']
85 ImplementationFileExtensions: ['c','cc','cpp','cxx']
88 InheritParentConfig: true
91 some-check.SomeOption: 'some value'
100static cl::opt<std::string> Checks(
"checks",
desc(R
"(
101Comma-separated list of globs with optional '-'
102prefix. Globs are processed in order of
103appearance in the list. Globs without '-'
104prefix add checks with matching names to the
105set, globs with the '-' prefix remove checks
106with matching names from the set of enabled
107checks. This option's value is appended to the
108value of the 'Checks' option in .clang-tidy
113static cl::opt<std::string> WarningsAsErrors(
"warnings-as-errors",
desc(R
"(
114Upgrades warnings to errors. Same format as
116This option's value is appended to the value of
117the 'WarningsAsErrors' option in .clang-tidy
124Regular expression matching the names of the
125headers to output diagnostics from. Diagnostics
126from the main file of each translation unit are
128Can be used together with -line-filter.
129This option overrides the 'HeaderFilterRegex'
130option in .clang-tidy file, if any.
136Display the errors from system headers.
137This option overrides the 'SystemHeaders' option
138in .clang-tidy file, if any.
143List of files with line ranges to filter the
144warnings. Can be used together with
145-header-filter. The format of the list is a
146JSON array of objects:
148 {"name":"file1.cpp","lines":[[1,3],[5,7]]},
155static cl::opt<bool>
Fix(
"fix",
desc(R
"(
156Apply suggested fixes. Without -fix-errors
157clang-tidy will bail out if any compilation
163Apply suggested fixes even if compilation
164errors were found. If compiler errors have
165attached fix-its, clang-tidy will apply them as
171If a warning has no fix, but a single fix can
172be found through an associated diagnostic note,
174Specifying this flag will implicitly enable the
180Style for formatting code around applied fixes:
181 - 'none' (default) turns off formatting
182 - 'file' (literally 'file', not a placeholder)
183 uses .clang-format file in the closest parent
185 - '{ <json> }' specifies options inline, e.g.
186 -format-style='{BasedOnStyle: llvm, IndentWidth: 8}'
187 - 'llvm', 'google', 'webkit', 'mozilla'
188See clang-format documentation for the up-to-date
189information about formatting styles and options.
190This option overrides the 'FormatStyle` option in
191.clang-tidy file, if any.
197List all enabled checks and exit. Use with
198-checks=* to list all available checks.
203For each enabled check explains, where it is
204enabled, i.e. in clang-tidy binary, command
205line or a specific configuration file.
209static cl::opt<std::string>
Config(
"config",
desc(R
"(
210Specifies a configuration in YAML/JSON format:
211 -config="{Checks: '*',
212 CheckOptions: {x: y}}"
213When the value is empty, clang-tidy will
214attempt to find a file named .clang-tidy for
215each source file in its parent directories.
220Specify the path of .clang-tidy or custom config file:
221 e.g. --config-file=/some/path/myTidyConfigFile
222This option internally works exactly the same way as
223 --config option after reading specified config file.
224Use either --config-file or --config, not both.
230Dumps configuration in the YAML format to
231stdout. This option can be used along with a
232file name (and '--' if the file is outside of a
233project with configured compilation database).
234The configuration used for this file will be
236Use along with -checks=* to include
237configuration of all checks.
242Enable per-check timing profiles, and print a
249By default reports are printed in tabulated
250format to stderr. When this option is passed,
251these per-TU profiles are instead stored as JSON.
253 cl::value_desc("prefix"),
261 cl::init(
false), cl::Hidden,
266Enables preprocessor-level module header parsing
267for C++20 and above, empowering specific checks
268to detect macro definitions within modules. This
269feature may cause performance and parsing issues
270and is therefore considered experimental.
276YAML file to store suggested fixes in. The
277stored fixes can be applied to the input source
278code with clang-apply-replacements.
280 cl::value_desc("filename"),
283static cl::opt<bool>
Quiet(
"quiet",
desc(R
"(
284Run clang-tidy in quiet mode. This suppresses
285printing statistics about ignored warnings and
286warnings treated as errors if the respective
287options are specified.
292Overlay the virtual filesystem described by file
293over the real file system.
295 cl::value_desc("filename"),
299Use colors in diagnostics. If not set, colors
300will be used if the terminal connected to
301standard output supports colors.
302This option overrides the 'UseColor' option in
303.clang-tidy file, if any.
308Check the config files to ensure each check and
316 if (Stats.errorsIgnored()) {
317 llvm::errs() <<
"Suppressed " << Stats.errorsIgnored() <<
" warnings (";
318 StringRef Separator =
"";
319 if (Stats.ErrorsIgnoredNonUserCode) {
320 llvm::errs() << Stats.ErrorsIgnoredNonUserCode <<
" in non-user code";
323 if (Stats.ErrorsIgnoredLineFilter) {
324 llvm::errs() << Separator << Stats.ErrorsIgnoredLineFilter
325 <<
" due to line filter";
328 if (Stats.ErrorsIgnoredNOLINT) {
329 llvm::errs() << Separator << Stats.ErrorsIgnoredNOLINT <<
" NOLINT";
332 if (Stats.ErrorsIgnoredCheckFilter)
333 llvm::errs() << Separator << Stats.ErrorsIgnoredCheckFilter
334 <<
" with check filters";
335 llvm::errs() <<
").\n";
336 if (Stats.ErrorsIgnoredNonUserCode)
337 llvm::errs() <<
"Use -header-filter=.* to display errors from all "
338 "non-system headers. Use -system-headers to display "
339 "errors from system headers as well.\n";
344 llvm::IntrusiveRefCntPtr<vfs::FileSystem> FS) {
347 llvm::errs() <<
"Invalid LineFilter: " << Err.message() <<
"\n\nUsage:\n";
348 llvm::cl::PrintHelpMessage(
false,
true);
352 ClangTidyOptions DefaultOptions;
354 DefaultOptions.WarningsAsErrors =
"";
358 DefaultOptions.User = llvm::sys::Process::GetEnv(
"USER");
360 if (!DefaultOptions.User)
361 DefaultOptions.User = llvm::sys::Process::GetEnv(
"USERNAME");
364 if (Checks.getNumOccurrences() > 0)
365 OverrideOptions.
Checks = Checks;
366 if (WarningsAsErrors.getNumOccurrences() > 0)
374 if (
UseColor.getNumOccurrences() > 0)
378 [&](StringRef Configuration,
379 StringRef Source) -> std::unique_ptr<ClangTidyOptionsProvider> {
380 llvm::ErrorOr<ClangTidyOptions> ParsedConfig =
383 return std::make_unique<ConfigOptionsProvider>(
384 std::move(GlobalOptions),
386 std::move(*ParsedConfig), std::move(OverrideOptions), std::move(FS));
387 llvm::errs() <<
"Error: invalid configuration specified.\n"
388 << ParsedConfig.getError().message() <<
"\n";
393 if (
Config.getNumOccurrences() > 0) {
394 llvm::errs() <<
"Error: --config-file and --config are "
395 "mutually exclusive. Specify only one.\n";
399 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
Text =
401 if (std::error_code EC =
Text.getError()) {
402 llvm::errs() <<
"Error: can't read config-file '" <<
ConfigFile
403 <<
"': " << EC.message() <<
"\n";
407 return LoadConfig((*Text)->getBuffer(),
ConfigFile);
410 if (
Config.getNumOccurrences() > 0)
411 return LoadConfig(
Config,
"<command-line-config>");
413 return std::make_unique<FileOptionsProvider>(
414 std::move(GlobalOptions), std::move(DefaultOptions),
415 std::move(OverrideOptions), std::move(FS));
418llvm::IntrusiveRefCntPtr<vfs::FileSystem>
420 llvm::IntrusiveRefCntPtr<vfs::FileSystem> BaseFS) {
421 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
422 BaseFS->getBufferForFile(OverlayFile);
424 llvm::errs() <<
"Can't load virtual filesystem overlay file '"
425 << OverlayFile <<
"': " << Buffer.getError().message()
430 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getVFSFromYAML(
431 std::move(Buffer.get()),
nullptr, OverlayFile);
433 llvm::errs() <<
"Error: invalid virtual filesystem overlay file '"
434 << OverlayFile <<
"'.\n";
440static StringRef
closest(StringRef Value,
const StringSet<> &Allowed) {
441 unsigned MaxEdit = 5U;
443 for (
auto Item : Allowed.keys()) {
444 unsigned Cur = Value.edit_distance_insensitive(Item,
true, MaxEdit);
455static bool verifyChecks(
const StringSet<> &AllChecks, StringRef CheckGlob,
457 llvm::StringRef Cur, Rest;
458 bool AnyInvalid =
false;
459 for (std::tie(Cur, Rest) = CheckGlob.split(
',');
460 !(Cur.empty() && Rest.empty()); std::tie(Cur, Rest) = Rest.split(
',')) {
464 Cur.consume_front(
"-");
465 if (Cur.startswith(
"clang-diagnostic"))
467 if (Cur.contains(
'*')) {
468 SmallString<128> RegexText(
"^");
469 StringRef MetaChars(
"()^$|*+?.[]\\{}");
472 RegexText.push_back(
'.');
473 else if (MetaChars.contains(
C))
474 RegexText.push_back(
'\\');
475 RegexText.push_back(
C);
477 RegexText.push_back(
'$');
478 llvm::Regex Glob(RegexText);
480 if (!Glob.isValid(
Error)) {
482 llvm::WithColor::error(llvm::errs(), Source)
483 <<
"building check glob '" << Cur <<
"' " <<
Error <<
"'\n";
486 if (llvm::none_of(AllChecks.keys(),
487 [&Glob](StringRef S) { return Glob.match(S); })) {
489 llvm::WithColor::warning(llvm::errs(), Source)
490 <<
"check glob '" << Cur <<
"' doesn't match any known check"
494 if (AllChecks.contains(Cur))
497 llvm::raw_ostream &
Output = llvm::WithColor::warning(llvm::errs(), Source)
498 <<
"unknown check '" << Cur <<
'\'';
499 llvm::StringRef Closest =
closest(Cur, AllChecks);
500 if (!Closest.empty())
501 Output <<
"; did you mean '" << Closest <<
'\'';
509 const std::vector<std::string> &HeaderFileExtensions,
510 const std::vector<std::string> &ImplementationFileExtensions,
512 bool AnyInvalid =
false;
513 for (
const auto &HeaderExtension : HeaderFileExtensions) {
514 for (
const auto &ImplementationExtension : ImplementationFileExtensions) {
515 if (HeaderExtension == ImplementationExtension) {
517 auto &
Output = llvm::WithColor::warning(llvm::errs(), Source)
518 <<
"HeaderFileExtension '" << HeaderExtension <<
'\''
519 <<
" is the same as ImplementationFileExtension '"
520 << ImplementationExtension <<
'\'';
528static SmallString<256>
makeAbsolute(llvm::StringRef Input) {
531 SmallString<256> AbsolutePath(Input);
532 if (std::error_code EC = llvm::sys::fs::make_absolute(AbsolutePath)) {
533 llvm::errs() <<
"Can't make absolute path from " << Input <<
": "
534 << EC.message() <<
"\n";
539static llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem>
createBaseFS() {
540 llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> BaseFS(
541 new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
544 IntrusiveRefCntPtr<vfs::FileSystem> VfsFromFile =
548 BaseFS->pushOverlay(std::move(VfsFromFile));
554 llvm::InitLLVM
X(argc, argv);
557 if (cl::Option *LoadOpt = cl::getRegisteredOptions().
lookup(
"load"))
560 llvm::Expected<CommonOptionsParser> OptionsParser =
563 if (!OptionsParser) {
564 llvm::WithColor::error() << llvm::toString(OptionsParser.takeError());
568 llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> BaseFS =
createBaseFS();
573 auto *OptionsProvider = OwningOptionsProvider.get();
574 if (!OptionsProvider)
580 auto PathList = OptionsParser->getSourcePathList();
581 if (!PathList.empty()) {
586 ClangTidyOptions EffectiveOptions = OptionsProvider->getOptions(FilePath);
588 std::vector<std::string> EnabledChecks =
593 std::vector<clang::tidy::ClangTidyOptionsProvider::OptionsSource>
594 RawOptions = OptionsProvider->getRawOptions(FilePath);
595 for (
const std::string &Check : EnabledChecks) {
596 for (
const auto &[Opts, Source] : llvm::reverse(RawOptions)) {
597 if (Opts.Checks && GlobList(*Opts.Checks).contains(Check)) {
598 llvm::outs() <<
"'" << Check <<
"' is enabled in the " << Source
608 if (EnabledChecks.empty()) {
609 llvm::errs() <<
"No checks enabled.\n";
612 llvm::outs() <<
"Enabled checks:";
613 for (
const auto &CheckName : EnabledChecks)
614 llvm::outs() <<
"\n " << CheckName;
615 llvm::outs() <<
"\n\n";
620 EffectiveOptions.CheckOptions =
623 EffectiveOptions, 0))
629 std::vector<ClangTidyOptionsProvider::OptionsSource> RawOptions =
630 OptionsProvider->getRawOptions(
FileName);
631 NamesAndOptions Valid =
633 bool AnyInvalid =
false;
634 for (
const auto &[Opts, Source] : RawOptions) {
636 AnyInvalid |=
verifyChecks(Valid.Names, *Opts.Checks, Source);
638 if (Opts.HeaderFileExtensions && Opts.ImplementationFileExtensions)
641 *Opts.ImplementationFileExtensions, Source);
643 for (
auto Key : Opts.CheckOptions.keys()) {
644 if (Valid.Options.contains(Key))
647 auto &
Output = llvm::WithColor::warning(llvm::errs(), Source)
648 <<
"unknown check option '" <<
Key <<
'\'';
649 llvm::StringRef Closest =
closest(Key, Valid.Options);
650 if (!Closest.empty())
651 Output <<
"; did you mean '" << Closest <<
'\'';
657 llvm::outs() <<
"No config errors detected.\n";
661 if (EnabledChecks.empty()) {
662 llvm::errs() <<
"Error: no checks enabled.\n";
663 llvm::cl::PrintHelpMessage(
false,
true);
667 if (PathList.empty()) {
668 llvm::errs() <<
"Error: no input files specified.\n";
669 llvm::cl::PrintHelpMessage(
false,
true);
673 llvm::InitializeAllTargetInfos();
674 llvm::InitializeAllTargetMCs();
675 llvm::InitializeAllAsmParsers();
677 ClangTidyContext Context(std::move(OwningOptionsProvider),
680 std::vector<ClangTidyError> Errors =
681 runClangTidy(Context, OptionsParser->getCompilations(), PathList, BaseFS,
683 bool FoundErrors = llvm::any_of(Errors, [](
const ClangTidyError &
E) {
684 return E.DiagLevel == ClangTidyError::Error;
692 const bool DisableFixes = FoundErrors && !
FixErrors;
694 unsigned WErrorCount = 0;
697 WErrorCount, BaseFS);
701 llvm::raw_fd_ostream
OS(
ExportFixes, EC, llvm::sys::fs::OF_None);
703 llvm::errs() <<
"Error opening output file: " << EC.message() <<
'\n';
711 if (DisableFixes && Behaviour !=
FB_NoFix)
713 <<
"Found compiler errors, but -fix-errors was not specified.\n"
714 "Fixes have NOT been applied.\n\n";
719 StringRef Plural = WErrorCount == 1 ?
"" :
"s";
720 llvm::errs() << WErrorCount <<
" warning" << Plural <<
" treated as error"
735 llvm::errs() <<
"Found compiler error(s).\n";
static cl::opt< bool > UseColor("use-color", cl::desc(R"(Use colors in detailed AST output. If not set, colors
will be used if the terminal connected to
standard output supports colors.)"), cl::init(false), cl::cat(ClangQueryCategory))
static cl::opt< bool > EnableCheckProfile("enable-check-profile", desc(R"(
Enable per-check timing profiles, and print a
report to stderr.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< std::string > VfsOverlay("vfsoverlay", desc(R"(
Overlay the virtual filesystem described by file
over the real file system.
)"), cl::value_desc("filename"), cl::cat(ClangTidyCategory))
static cl::opt< bool > FixNotes("fix-notes", desc(R"(
If a warning has no fix, but a single fix can
be found through an associated diagnostic note,
apply the fix.
Specifying this flag will implicitly enable the
'--fix' flag.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< bool > Fix("fix", desc(R"(
Apply suggested fixes. Without -fix-errors
clang-tidy will bail out if any compilation
errors were found.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< bool > ExplainConfig("explain-config", desc(R"(
For each enabled check explains, where it is
enabled, i.e. in clang-tidy binary, command
line or a specific configuration file.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< bool > UseColor("use-color", desc(R"(
Use colors in diagnostics. If not set, colors
will be used if the terminal connected to
standard output supports colors.
This option overrides the 'UseColor' option in
.clang-tidy file, if any.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< bool > VerifyConfig("verify-config", desc(R"(
Check the config files to ensure each check and
option is recognized.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< bool > AllowEnablingAnalyzerAlphaCheckers("allow-enabling-analyzer-alpha-checkers", cl::init(false), cl::Hidden, cl::cat(ClangTidyCategory))
This option allows enabling the experimental alpha checkers from the static analyzer.
static cl::opt< std::string > ConfigFile("config-file", desc(R"(
Specify the path of .clang-tidy or custom config file:
e.g. --config-file=/some/path/myTidyConfigFile
This option internally works exactly the same way as
--config option after reading specified config file.
Use either --config-file or --config, not both.
)"), cl::init(""), cl::cat(ClangTidyCategory))
static cl::opt< bool > EnableModuleHeadersParsing("enable-module-headers-parsing", desc(R"(
Enables preprocessor-level module header parsing
for C++20 and above, empowering specific checks
to detect macro definitions within modules. This
feature may cause performance and parsing issues
and is therefore considered experimental.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< std::string > Config("config", desc(R"(
Specifies a configuration in YAML/JSON format:
-config="{Checks:' *', CheckOptions:{x:y}}"
When the value is empty, clang-tidy will
attempt to find a file named .clang-tidy for
each source file in its parent directories.
)"), cl::init(""), cl::cat(ClangTidyCategory))
static cl::OptionCategory ClangTidyCategory("clang-tidy options")
static cl::opt< std::string > LineFilter("line-filter", desc(R"(
List of files with line ranges to filter the
warnings. Can be used together with
-header-filter. The format of the list is a
JSON array of objects:
[
{"name":"file1.cpp","lines":[[1,3],[5,7]]},
{"name":"file2.h"}
]
)"), cl::init(""), cl::cat(ClangTidyCategory))
static cl::opt< bool > FixErrors("fix-errors", desc(R"(
Apply suggested fixes even if compilation
errors were found. If compiler errors have
attached fix-its, clang-tidy will apply them as
well.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< std::string > HeaderFilter("header-filter", desc(R"(
Regular expression matching the names of the
headers to output diagnostics from. Diagnostics
from the main file of each translation unit are
always displayed.
Can be used together with -line-filter.
This option overrides the 'HeaderFilterRegex'
option in .clang-tidy file, if any.
)"), cl::init(""), cl::cat(ClangTidyCategory))
static cl::opt< bool > ListChecks("list-checks", desc(R"(
List all enabled checks and exit. Use with
-checks=* to list all available checks.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< bool > DumpConfig("dump-config", desc(R"(
Dumps configuration in the YAML format to
stdout. This option can be used along with a
file name (and '--' if the file is outside of a
project with configured compilation database).
The configuration used for this file will be
printed.
Use along with -checks=* to include
configuration of all checks.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< bool > SystemHeaders("system-headers", desc(R"(
Display the errors from system headers.
This option overrides the 'SystemHeaders' option
in .clang-tidy file, if any.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::desc desc(StringRef description)
static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage)
static cl::extrahelp ClangTidyHelp(R"(
Configuration files:
clang-tidy attempts to read configuration for each source file from a
.clang-tidy file located in the closest parent directory of the source
file. The .clang-tidy file is specified in YAML format. If any configuration
options have a corresponding command-line option, command-line option takes
precedence.
The following configuration options may be used in a .clang-tidy file:
CheckOptions - List of key-value pairs defining check-specific
options. Example:
CheckOptions:
some-check.SomeOption: 'some value'
Checks - Same as '--checks'. Additionally, the list of
globs can be specified as a list instead of a
string.
ExtraArgs - Same as '--extra-args'.
ExtraArgsBefore - Same as '--extra-args-before'.
FormatStyle - Same as '--format-style'.
HeaderFileExtensions - File extensions to consider to determine if a
given diagnostic is located in a header file.
HeaderFilterRegex - Same as '--header-filter-regex'.
ImplementationFileExtensions - File extensions to consider to determine if a
given diagnostic is located in an
implementation file.
InheritParentConfig - If this option is true in a config file, the
configuration file in the parent directory
(if any exists) will be taken and the current
config file will be applied on top of the
parent one.
SystemHeaders - Same as '--system-headers'.
UseColor - Same as '--use-color'.
User - Specifies the name or e-mail of the user
running clang-tidy. This option is used, for
example, to place the correct user name in
TODO() comments in the relevant check.
WarningsAsErrors - Same as '--warnings-as-errors'.
The effective configuration can be inspected using --dump-config:
$ clang-tidy --dump-config
---
Checks: '-*,some-check'
WarningsAsErrors: ''
HeaderFileExtensions: ['', 'h','hh','hpp','hxx']
ImplementationFileExtensions: ['c','cc','cpp','cxx']
HeaderFilterRegex: ''
FormatStyle: none
InheritParentConfig: true
User: user
CheckOptions:
some-check.SomeOption: 'some value'
...
)")
const char DefaultChecks[]
static cl::opt< bool > Quiet("quiet", desc(R"(
Run clang-tidy in quiet mode. This suppresses
printing statistics about ignored warnings and
warnings treated as errors if the respective
options are specified.
)"), cl::init(false), cl::cat(ClangTidyCategory))
static cl::opt< std::string > ExportFixes("export-fixes", desc(R"(
YAML file to store suggested fixes in. The
stored fixes can be applied to the input source
code with clang-apply-replacements.
)"), cl::value_desc("filename"), cl::cat(ClangTidyCategory))
static cl::opt< std::string > FormatStyle("format-style", desc(R"(
Style for formatting code around applied fixes:
- 'none' (default) turns off formatting
- 'file' (literally 'file', not a placeholder)
uses .clang-format file in the closest parent
directory
- '{ <json> }' specifies options inline, e.g.
-format-style='{BasedOnStyle: llvm, IndentWidth: 8}'
- 'llvm', 'google', 'webkit', 'mozilla'
See clang-format documentation for the up-to-date
information about formatting styles and options.
This option overrides the 'FormatStyle` option in
.clang-tidy file, if any.
)"), cl::init("none"), cl::cat(ClangTidyCategory))
static cl::opt< std::string > StoreCheckProfile("store-check-profile", desc(R"(
By default reports are printed in tabulated
format to stderr. When this option is passed,
these per-TU profiles are instead stored as JSON.
)"), cl::value_desc("prefix"), cl::cat(ClangTidyCategory))
static constexpr llvm::SourceMgr::DiagKind Error
llvm::raw_string_ostream OS
std::vector< std::string > lookup(const SymbolIndex &I, llvm::ArrayRef< SymbolID > IDs)
std::error_code parseLineFilter(StringRef LineFilter, clang::tidy::ClangTidyGlobalOptions &Options)
Parses -line-filter option and stores it to the Options.
std::vector< std::string > getCheckNames(const ClangTidyOptions &Options, bool AllowEnablingAnalyzerAlphaCheckers)
Fills the list of check names that are enabled when the provided filters are applied.
FixBehaviour
Controls what kind of fixes clang-tidy is allowed to apply.
@ FB_NoFix
Don't try to apply any fix.
@ FB_FixNotes
Apply fixes found in notes.
@ FB_Fix
Only apply fixes added to warnings.
int clangTidyMain(int argc, const char **argv)
ClangTidyOptions::OptionMap getCheckOptions(const ClangTidyOptions &Options, bool AllowEnablingAnalyzerAlphaCheckers)
Returns the effective check-specific options.
static void printStats(const ClangTidyStats &Stats)
static llvm::IntrusiveRefCntPtr< vfs::OverlayFileSystem > createBaseFS()
llvm::IntrusiveRefCntPtr< vfs::FileSystem > getVfsFromFile(const std::string &OverlayFile, llvm::IntrusiveRefCntPtr< vfs::FileSystem > BaseFS)
void handleErrors(llvm::ArrayRef< ClangTidyError > Errors, ClangTidyContext &Context, FixBehaviour Fix, unsigned &WarningsAsErrorsCount, llvm::IntrusiveRefCntPtr< llvm::vfs::FileSystem > BaseFS)
Displays the found Errors to the users.
static constexpr StringLiteral VerifyConfigWarningEnd
static SmallString< 256 > makeAbsolute(llvm::StringRef Input)
static std::unique_ptr< ClangTidyOptionsProvider > createOptionsProvider(llvm::IntrusiveRefCntPtr< vfs::FileSystem > FS)
std::vector< ClangTidyError > runClangTidy(clang::tidy::ClangTidyContext &Context, const CompilationDatabase &Compilations, ArrayRef< std::string > InputFiles, llvm::IntrusiveRefCntPtr< llvm::vfs::OverlayFileSystem > BaseFS, bool ApplyAnyFix, bool EnableCheckProfile, llvm::StringRef StoreCheckProfile)
static bool verifyFileExtensions(const std::vector< std::string > &HeaderFileExtensions, const std::vector< std::string > &ImplementationFileExtensions, StringRef Source)
NamesAndOptions getAllChecksAndOptions(bool AllowEnablingAnalyzerAlphaCheckers)
std::string configurationAsText(const ClangTidyOptions &Options)
Serializes configuration to a YAML-encoded string.
llvm::ErrorOr< ClangTidyOptions > parseConfiguration(llvm::MemoryBufferRef Config)
Parses configuration from JSON and returns ClangTidyOptions or an error.
void exportReplacements(const llvm::StringRef MainFilePath, const std::vector< ClangTidyError > &Errors, raw_ostream &OS)
static bool verifyChecks(const StringSet<> &AllChecks, StringRef CheckGlob, StringRef Source)
static StringRef closest(StringRef Value, const StringSet<> &Allowed)
Some operations such as code completion produce a set of candidates.
Contains options for clang-tidy.
std::optional< std::string > HeaderFilterRegex
Output warnings from headers matching this filter.
std::optional< std::string > Checks
Checks filter.
std::optional< std::string > WarningsAsErrors
WarningsAsErrors filter.
std::optional< bool > UseColor
Use colors in diagnostics. If missing, it will be auto detected.
std::optional< bool > SystemHeaders
Output warnings from system headers matching HeaderFilterRegex.
static ClangTidyOptions getDefaults()
These options are used for all settings that haven't been overridden by the OptionsProvider.
std::optional< std::string > FormatStyle
Format code around applied fixes with clang-format using this style.
Contains displayed and ignored diagnostic counters for a ClangTidy run.