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");
363 ClangTidyOptions OverrideOptions;
364 if (Checks.getNumOccurrences() > 0)
365 OverrideOptions.Checks = Checks;
366 if (WarningsAsErrors.getNumOccurrences() > 0)
367 OverrideOptions.WarningsAsErrors = WarningsAsErrors;
374 if (
UseColor.getNumOccurrences() > 0)
375 OverrideOptions.UseColor =
UseColor;
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 GlobList Globs(CheckGlob);
458 bool AnyInvalid =
false;
459 for (
const auto &Item : Globs.getItems()) {
460 if (Item.Text.starts_with(
"clang-diagnostic"))
462 if (llvm::none_of(AllChecks.keys(),
463 [&Item](StringRef S) { return Item.Regex.match(S); })) {
465 if (Item.Text.contains(
'*'))
466 llvm::WithColor::warning(llvm::errs(), Source)
467 <<
"check glob '" << Item.Text <<
"' doesn't match any known check"
470 llvm::raw_ostream &
Output =
471 llvm::WithColor::warning(llvm::errs(), Source)
472 <<
"unknown check '" << Item.Text <<
'\'';
473 llvm::StringRef Closest =
closest(Item.Text, AllChecks);
474 if (!Closest.empty())
475 Output <<
"; did you mean '" << Closest <<
'\'';
484 const std::vector<std::string> &HeaderFileExtensions,
485 const std::vector<std::string> &ImplementationFileExtensions,
487 bool AnyInvalid =
false;
488 for (
const auto &HeaderExtension : HeaderFileExtensions) {
489 for (
const auto &ImplementationExtension : ImplementationFileExtensions) {
490 if (HeaderExtension == ImplementationExtension) {
492 auto &
Output = llvm::WithColor::warning(llvm::errs(), Source)
493 <<
"HeaderFileExtension '" << HeaderExtension <<
'\''
494 <<
" is the same as ImplementationFileExtension '"
495 << ImplementationExtension <<
'\'';
503static SmallString<256>
makeAbsolute(llvm::StringRef Input) {
506 SmallString<256> AbsolutePath(Input);
507 if (std::error_code EC = llvm::sys::fs::make_absolute(AbsolutePath)) {
508 llvm::errs() <<
"Can't make absolute path from " << Input <<
": "
509 << EC.message() <<
"\n";
514static llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem>
createBaseFS() {
515 llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> BaseFS(
516 new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
519 IntrusiveRefCntPtr<vfs::FileSystem> VfsFromFile =
523 BaseFS->pushOverlay(std::move(VfsFromFile));
529 llvm::InitLLVM
X(argc, argv);
532 if (cl::Option *LoadOpt = cl::getRegisteredOptions().
lookup(
"load"))
535 llvm::Expected<CommonOptionsParser> OptionsParser =
538 if (!OptionsParser) {
539 llvm::WithColor::error() << llvm::toString(OptionsParser.takeError());
543 llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> BaseFS =
createBaseFS();
548 auto *OptionsProvider = OwningOptionsProvider.get();
549 if (!OptionsProvider)
555 auto PathList = OptionsParser->getSourcePathList();
556 if (!PathList.empty()) {
561 ClangTidyOptions EffectiveOptions = OptionsProvider->getOptions(FilePath);
563 std::vector<std::string> EnabledChecks =
568 std::vector<clang::tidy::ClangTidyOptionsProvider::OptionsSource>
569 RawOptions = OptionsProvider->getRawOptions(FilePath);
570 for (
const std::string &Check : EnabledChecks) {
571 for (
const auto &[Opts, Source] : llvm::reverse(RawOptions)) {
572 if (Opts.Checks && GlobList(*Opts.Checks).contains(Check)) {
573 llvm::outs() <<
"'" << Check <<
"' is enabled in the " << Source
583 if (EnabledChecks.empty()) {
584 llvm::errs() <<
"No checks enabled.\n";
587 llvm::outs() <<
"Enabled checks:";
588 for (
const auto &CheckName : EnabledChecks)
589 llvm::outs() <<
"\n " << CheckName;
590 llvm::outs() <<
"\n\n";
595 EffectiveOptions.CheckOptions =
598 EffectiveOptions, 0))
604 std::vector<ClangTidyOptionsProvider::OptionsSource> RawOptions =
605 OptionsProvider->getRawOptions(
FileName);
606 NamesAndOptions Valid =
608 bool AnyInvalid =
false;
609 for (
const auto &[Opts, Source] : RawOptions) {
611 AnyInvalid |=
verifyChecks(Valid.Names, *Opts.Checks, Source);
613 if (Opts.HeaderFileExtensions && Opts.ImplementationFileExtensions)
616 *Opts.ImplementationFileExtensions, Source);
618 for (
auto Key : Opts.CheckOptions.keys()) {
619 if (Valid.Options.contains(Key))
622 auto &
Output = llvm::WithColor::warning(llvm::errs(), Source)
623 <<
"unknown check option '" <<
Key <<
'\'';
624 llvm::StringRef Closest =
closest(Key, Valid.Options);
625 if (!Closest.empty())
626 Output <<
"; did you mean '" << Closest <<
'\'';
632 llvm::outs() <<
"No config errors detected.\n";
636 if (EnabledChecks.empty()) {
637 llvm::errs() <<
"Error: no checks enabled.\n";
638 llvm::cl::PrintHelpMessage(
false,
true);
642 if (PathList.empty()) {
643 llvm::errs() <<
"Error: no input files specified.\n";
644 llvm::cl::PrintHelpMessage(
false,
true);
648 llvm::InitializeAllTargetInfos();
649 llvm::InitializeAllTargetMCs();
650 llvm::InitializeAllAsmParsers();
652 ClangTidyContext Context(std::move(OwningOptionsProvider),
655 std::vector<ClangTidyError> Errors =
656 runClangTidy(Context, OptionsParser->getCompilations(), PathList, BaseFS,
658 bool FoundErrors = llvm::any_of(Errors, [](
const ClangTidyError &
E) {
659 return E.DiagLevel == ClangTidyError::Error;
667 const bool DisableFixes = FoundErrors && !
FixErrors;
669 unsigned WErrorCount = 0;
672 WErrorCount, BaseFS);
676 llvm::raw_fd_ostream
OS(
ExportFixes, EC, llvm::sys::fs::OF_None);
678 llvm::errs() <<
"Error opening output file: " << EC.message() <<
'\n';
686 if (DisableFixes && Behaviour !=
FB_NoFix)
688 <<
"Found compiler errors, but -fix-errors was not specified.\n"
689 "Fixes have NOT been applied.\n\n";
694 StringRef Plural = WErrorCount == 1 ?
"" :
"s";
695 llvm::errs() << WErrorCount <<
" warning" << Plural <<
" treated as error"
710 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))
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.
static ClangTidyOptions getDefaults()
These options are used for all settings that haven't been overridden by the OptionsProvider.
Contains displayed and ignored diagnostic counters for a ClangTidy run.