Debian Codegraph @

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

raw
1 //===--- tools/extra/clang-tidy/ClangTidyMain.cpp - Clang tidy tool -------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file This file implements a clang-tidy tool.
10 ///
11 /// This tool uses the Clang Tooling infrastructure, see
12 /// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
13 /// for details on setting it up with LLVM source tree.
14 ///
15 //===----------------------------------------------------------------------===//
16
17 #include "ClangTidyMain.h"
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"
29 #include <optional>
30
31 using namespace clang::tooling;
32 using namespace llvm;
33
34 static cl::OptionCategory ClangTidyCategory("clang-tidy options");
35
36 static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
37 static cl::extrahelp ClangTidyHelp(R"(
38 Configuration files:
39 clang-tidy attempts to read configuration for each source file from a
40 .clang-tidy file located in the closest parent directory of the source
41 file. If InheritParentConfig is true in a config file, the configuration file
42 in the parent directory (if any exists) will be taken and current config file
43 will be applied on top of the parent one. If any configuration options have
44 a corresponding command-line option, command-line option takes precedence.
45 The effective configuration can be inspected using -dump-config:
46
47 $ clang-tidy -dump-config
48 ---
49 Checks: '-*,some-check'
50 WarningsAsErrors: ''
51 HeaderFilterRegex: ''
52 FormatStyle: none
53 InheritParentConfig: true
54 User: user
55 CheckOptions:
56 some-check.SomeOption: 'some value'
57 ...
58
59 )");
60
61 const char DefaultChecks[] = // Enable these checks by default:
62 "clang-diagnostic-*," // * compiler diagnostics
63 "clang-analyzer-*"; // * Static Analyzer checks
64
65 static cl::opt<std::string> Checks("checks", cl::desc(R"(
66 Comma-separated list of globs with optional '-'
67 prefix. Globs are processed in order of
68 appearance in the list. Globs without '-'
69 prefix add checks with matching names to the
70 set, globs with the '-' prefix remove checks
71 with matching names from the set of enabled
72 checks. This option's value is appended to the
73 value of the 'Checks' option in .clang-tidy
74 file, if any.
75 )"),
76 cl::init(""), cl::cat(ClangTidyCategory));
77
78 static cl::opt<std::string> WarningsAsErrors("warnings-as-errors", cl::desc(R"(
79 Upgrades warnings to errors. Same format as
80 '-checks'.
81 This option's value is appended to the value of
82 the 'WarningsAsErrors' option in .clang-tidy
83 file, if any.
84 )"),
85 cl::init(""),
86 cl::cat(ClangTidyCategory));
87
88 static cl::opt<std::string> HeaderFilter("header-filter", cl::desc(R"(
89 Regular expression matching the names of the
90 headers to output diagnostics from. Diagnostics
91 from the main file of each translation unit are
92 always displayed.
93 Can be used together with -line-filter.
94 This option overrides the 'HeaderFilterRegex'
95 option in .clang-tidy file, if any.
96 )"),
97 cl::init(""),
98 cl::cat(ClangTidyCategory));
99
100 static cl::opt<bool>
101 SystemHeaders("system-headers",
102 cl::desc("Display the errors from system headers."),
103 cl::init(false), cl::cat(ClangTidyCategory));
104 static cl::opt<std::string> LineFilter("line-filter", cl::desc(R"(
105 List of files with line ranges to filter the
106 warnings. Can be used together with
107 -header-filter. The format of the list is a
108 JSON array of objects:
109 [
110 {"name":"file1.cpp","lines":[[1,3],[5,7]]},
111 {"name":"file2.h"}
112 ]
113 )"),
114 cl::init(""),
115 cl::cat(ClangTidyCategory));
116
117 static cl::opt<bool> Fix("fix", cl::desc(R"(
118 Apply suggested fixes. Without -fix-errors
119 clang-tidy will bail out if any compilation
120 errors were found.
121 )"),
122 cl::init(false), cl::cat(ClangTidyCategory));
123
124 static cl::opt<bool> FixErrors("fix-errors", cl::desc(R"(
125 Apply suggested fixes even if compilation
126 errors were found. If compiler errors have
127 attached fix-its, clang-tidy will apply them as
128 well.
129 )"),
130 cl::init(false), cl::cat(ClangTidyCategory));
131
132 static cl::opt<bool> FixNotes("fix-notes", cl::desc(R"(
133 If a warning has no fix, but a single fix can
134 be found through an associated diagnostic note,
135 apply the fix.
136 Specifying this flag will implicitly enable the
137 '--fix' flag.
138 )"),
139 cl::init(false), cl::cat(ClangTidyCategory));
140
141 static cl::opt<std::string> FormatStyle("format-style", cl::desc(R"(
142 Style for formatting code around applied fixes:
143 - 'none' (default) turns off formatting
144 - 'file' (literally 'file', not a placeholder)
145 uses .clang-format file in the closest parent
146 directory
147 - '{ <json> }' specifies options inline, e.g.
148 -format-style='{BasedOnStyle: llvm, IndentWidth: 8}'
149 - 'llvm', 'google', 'webkit', 'mozilla'
150 See clang-format documentation for the up-to-date
151 information about formatting styles and options.
152 This option overrides the 'FormatStyle` option in
153 .clang-tidy file, if any.
154 )"),
155 cl::init("none"),
156 cl::cat(ClangTidyCategory));
157
158 static cl::opt<bool> ListChecks("list-checks", cl::desc(R"(
159 List all enabled checks and exit. Use with
160 -checks=* to list all available checks.
161 )"),
162 cl::init(false), cl::cat(ClangTidyCategory));
163
164 static cl::opt<bool> ExplainConfig("explain-config", cl::desc(R"(
165 For each enabled check explains, where it is
166 enabled, i.e. in clang-tidy binary, command
167 line or a specific configuration file.
168 )"),
169 cl::init(false), cl::cat(ClangTidyCategory));
170
171 static cl::opt<std::string> Config("config", cl::desc(R"(
172 Specifies a configuration in YAML/JSON format:
173 -config="{Checks: '*',
174 CheckOptions: {x: y}}"
175 When the value is empty, clang-tidy will
176 attempt to find a file named .clang-tidy for
177 each source file in its parent directories.
178 )"),
179 cl::init(""), cl::cat(ClangTidyCategory));
180
181 static cl::opt<std::string> ConfigFile("config-file", cl::desc(R"(
182 Specify the path of .clang-tidy or custom config file:
183 e.g. --config-file=/some/path/myTidyConfigFile
184 This option internally works exactly the same way as
185 --config option after reading specified config file.
186 Use either --config-file or --config, not both.
187 )"),
188 cl::init(""),
189 cl::cat(ClangTidyCategory));
190
191 static cl::opt<bool> DumpConfig("dump-config", cl::desc(R"(
192 Dumps configuration in the YAML format to
193 stdout. This option can be used along with a
194 file name (and '--' if the file is outside of a
195 project with configured compilation database).
196 The configuration used for this file will be
197 printed.
198 Use along with -checks=* to include
199 configuration of all checks.
200 )"),
201 cl::init(false), cl::cat(ClangTidyCategory));
202
203 static cl::opt<bool> EnableCheckProfile("enable-check-profile", cl::desc(R"(
204 Enable per-check timing profiles, and print a
205 report to stderr.
206 )"),
207 cl::init(false),
208 cl::cat(ClangTidyCategory));
209
210 static cl::opt<std::string> StoreCheckProfile("store-check-profile",
211 cl::desc(R"(
212 By default reports are printed in tabulated
213 format to stderr. When this option is passed,
214 these per-TU profiles are instead stored as JSON.
215 )"),
216 cl::value_desc("prefix"),
217 cl::cat(ClangTidyCategory));
218
219 /// This option allows enabling the experimental alpha checkers from the static
220 /// analyzer. This option is set to false and not visible in help, because it is
221 /// highly not recommended for users.
222 static cl::opt<bool>
223 AllowEnablingAnalyzerAlphaCheckers("allow-enabling-analyzer-alpha-checkers",
224 cl::init(false), cl::Hidden,
225 cl::cat(ClangTidyCategory));
226
227 static cl::opt<std::string> ExportFixes("export-fixes", cl::desc(R"(
228 YAML file to store suggested fixes in. The
229 stored fixes can be applied to the input source
230 code with clang-apply-replacements.
231 )"),
232 cl::value_desc("filename"),
233 cl::cat(ClangTidyCategory));
234
235 static cl::opt<bool> Quiet("quiet", cl::desc(R"(
236 Run clang-tidy in quiet mode. This suppresses
237 printing statistics about ignored warnings and
238 warnings treated as errors if the respective
239 options are specified.
240 )"),
241 cl::init(false),
242 cl::cat(ClangTidyCategory));
243
244 static cl::opt<std::string> VfsOverlay("vfsoverlay", cl::desc(R"(
245 Overlay the virtual filesystem described by file
246 over the real file system.
247 )"),
248 cl::value_desc("filename"),
249 cl::cat(ClangTidyCategory));
250
251 static cl::opt<bool> UseColor("use-color", cl::desc(R"(
252 Use colors in diagnostics. If not set, colors
253 will be used if the terminal connected to
254 standard output supports colors.
255 This option overrides the 'UseColor' option in
256 .clang-tidy file, if any.
257 )"),
258 cl::init(false), cl::cat(ClangTidyCategory));
259
260 static cl::opt<bool> VerifyConfig("verify-config", cl::desc(R"(
261 Check the config files to ensure each check and
262 option is recognized.
263 )"),
264 cl::init(false), cl::cat(ClangTidyCategory));
265
266 namespace clang::tidy {
267
268 static void printStats(const ClangTidyStats &Stats) {
269 if (Stats.errorsIgnored()) {
270 llvm::errs() << "Suppressed " << Stats.errorsIgnored() << " warnings (";
271 StringRef Separator = "";
272 if (Stats.ErrorsIgnoredNonUserCode) {
273 llvm::errs() << Stats.ErrorsIgnoredNonUserCode << " in non-user code";
274 Separator = ", ";
275 }
276 if (Stats.ErrorsIgnoredLineFilter) {
277 llvm::errs() << Separator << Stats.ErrorsIgnoredLineFilter
278 << " due to line filter";
279 Separator = ", ";
280 }
281 if (Stats.ErrorsIgnoredNOLINT) {
282 llvm::errs() << Separator << Stats.ErrorsIgnoredNOLINT << " NOLINT";
283 Separator = ", ";
284 }
285 if (Stats.ErrorsIgnoredCheckFilter)
286 llvm::errs() << Separator << Stats.ErrorsIgnoredCheckFilter
287 << " with check filters";
288 llvm::errs() << ").\n";
289 if (Stats.ErrorsIgnoredNonUserCode)
290 llvm::errs() << "Use -header-filter=.* to display errors from all "
291 "non-system headers. Use -system-headers to display "
292 "errors from system headers as well.\n";
293 }
294 }
295
296 static std::unique_ptr<ClangTidyOptionsProvider> createOptionsProvider(
297 llvm::IntrusiveRefCntPtr<vfs::FileSystem> FS) {
298 ClangTidyGlobalOptions GlobalOptions;
299 if (std::error_code Err = parseLineFilter(LineFilter, GlobalOptions)) {
300 llvm::errs() << "Invalid LineFilter: " << Err.message() << "\n\nUsage:\n";
301 llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
302 return nullptr;
303 }
304
305 ClangTidyOptions DefaultOptions;
306 DefaultOptions.Checks = DefaultChecks;
307 DefaultOptions.WarningsAsErrors = "";
308 DefaultOptions.HeaderFilterRegex = HeaderFilter;
309 DefaultOptions.SystemHeaders = SystemHeaders;
310 DefaultOptions.FormatStyle = FormatStyle;
311 DefaultOptions.User = llvm::sys::Process::GetEnv("USER");
312 // USERNAME is used on Windows.
313 if (!DefaultOptions.User)
314 DefaultOptions.User = llvm::sys::Process::GetEnv("USERNAME");
315
316 ClangTidyOptions OverrideOptions;
317 if (Checks.getNumOccurrences() > 0)
318 OverrideOptions.Checks = Checks;
319 if (WarningsAsErrors.getNumOccurrences() > 0)
320 OverrideOptions.WarningsAsErrors = WarningsAsErrors;
321 if (HeaderFilter.getNumOccurrences() > 0)
322 OverrideOptions.HeaderFilterRegex = HeaderFilter;
323 if (SystemHeaders.getNumOccurrences() > 0)
324 OverrideOptions.SystemHeaders = SystemHeaders;
325 if (FormatStyle.getNumOccurrences() > 0)
326 OverrideOptions.FormatStyle = FormatStyle;
327 if (UseColor.getNumOccurrences() > 0)
328 OverrideOptions.UseColor = UseColor;
329
330 auto LoadConfig =
331 [&](StringRef Configuration,
332 StringRef Source) -> std::unique_ptr<ClangTidyOptionsProvider> {
333 llvm::ErrorOr<ClangTidyOptions> ParsedConfig =
334 parseConfiguration(MemoryBufferRef(Configuration, Source));
335 if (ParsedConfig)
336 return std::make_unique<ConfigOptionsProvider>(
337 std::move(GlobalOptions),
338 ClangTidyOptions::getDefaults().merge(DefaultOptions, 0),
339 std::move(*ParsedConfig), std::move(OverrideOptions), std::move(FS));
340 llvm::errs() << "Error: invalid configuration specified.\n"
341 << ParsedConfig.getError().message() << "\n";
342 return nullptr;
343 };
344
345 if (ConfigFile.getNumOccurrences() > 0) {
346 if (Config.getNumOccurrences() > 0) {
347 llvm::errs() << "Error: --config-file and --config are "
348 "mutually exclusive. Specify only one.\n";
349 return nullptr;
350 }
351
352 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Text =
353 llvm::MemoryBuffer::getFile(ConfigFile);
354 if (std::error_code EC = Text.getError()) {
355 llvm::errs() << "Error: can't read config-file '" << ConfigFile
356 << "': " << EC.message() << "\n";
357 return nullptr;
358 }
359
360 return LoadConfig((*Text)->getBuffer(), ConfigFile);
361 }
362
363 if (Config.getNumOccurrences() > 0)
364 return LoadConfig(Config, "<command-line-config>");
365
366 return std::make_unique<FileOptionsProvider>(
367 std::move(GlobalOptions), std::move(DefaultOptions),
368 std::move(OverrideOptions), std::move(FS));
369 }
370
371 llvm::IntrusiveRefCntPtr<vfs::FileSystem>
372 getVfsFromFile(const std::string &OverlayFile,
373 llvm::IntrusiveRefCntPtr<vfs::FileSystem> BaseFS) {
374 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
375 BaseFS->getBufferForFile(OverlayFile);
376 if (!Buffer) {
377 llvm::errs() << "Can't load virtual filesystem overlay file '"
378 << OverlayFile << "': " << Buffer.getError().message()
379 << ".\n";
380 return nullptr;
381 }
382
383 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getVFSFromYAML(
384 std::move(Buffer.get()), /*DiagHandler*/ nullptr, OverlayFile);
385 if (!FS) {
386 llvm::errs() << "Error: invalid virtual filesystem overlay file '"
387 << OverlayFile << "'.\n";
388 return nullptr;
389 }
390 return FS;
391 }
392
393 static StringRef closest(StringRef Value, const StringSet<> &Allowed) {
394 unsigned MaxEdit = 5U;
395 StringRef Closest;
396 for (auto Item : Allowed.keys()) {
397 unsigned Cur = Value.edit_distance_insensitive(Item, true, MaxEdit);
398 if (Cur < MaxEdit) {
399 Closest = Item;
400 MaxEdit = Cur;
401 }
402 }
403 return Closest;
404 }
405
406 static constexpr StringLiteral VerifyConfigWarningEnd = " [-verify-config]\n";
407
408 static bool verifyChecks(const StringSet<> &AllChecks, StringRef CheckGlob,
409 StringRef Source) {
410 llvm::StringRef Cur, Rest;
411 bool AnyInvalid = false;
412 for (std::tie(Cur, Rest) = CheckGlob.split(',');
413 !(Cur.empty() && Rest.empty()); std::tie(Cur, Rest) = Rest.split(',')) {
414 Cur = Cur.trim();
415 if (Cur.empty())
416 continue;
417 Cur.consume_front("-");
418 if (Cur.startswith("clang-diagnostic"))
419 continue;
420 if (Cur.contains('*')) {
421 SmallString<128> RegexText("^");
422 StringRef MetaChars("()^$|*+?.[]\\{}");
423 for (char C : Cur) {
424 if (C == '*')
425 RegexText.push_back('.');
426 else if (MetaChars.contains(C))
427 RegexText.push_back('\\');
428 RegexText.push_back(C);
429 }
430 RegexText.push_back('$');
431 llvm::Regex Glob(RegexText);
432 std::string Error;
433 if (!Glob.isValid(Error)) {
434 AnyInvalid = true;
435 llvm::WithColor::error(llvm::errs(), Source)
436 << "building check glob '" << Cur << "' " << Error << "'\n";
437 continue;
438 }
439 if (llvm::none_of(AllChecks.keys(),
440 [&Glob](StringRef S) { return Glob.match(S); })) {
441 AnyInvalid = true;
442 llvm::WithColor::warning(llvm::errs(), Source)
443 << "check glob '" << Cur << "' doesn't match any known check"
444 << VerifyConfigWarningEnd;
445 }
446 } else {
447 if (AllChecks.contains(Cur))
448 continue;
449 AnyInvalid = true;
450 llvm::raw_ostream &Output = llvm::WithColor::warning(llvm::errs(), Source)
451 << "unknown check '" << Cur << '\'';
452 llvm::StringRef Closest = closest(Cur, AllChecks);
453 if (!Closest.empty())
454 Output << "; did you mean '" << Closest << '\'';
455 Output << VerifyConfigWarningEnd;
456 }
457 }
458 return AnyInvalid;
459 }
460
461 int clangTidyMain(int argc, const char **argv) {
462 llvm::InitLLVM X(argc, argv);
463
464 // Enable help for -load option, if plugins are enabled.
465 if (cl::Option *LoadOpt = cl::getRegisteredOptions().lookup("load"))
466 LoadOpt->addCategory(ClangTidyCategory);
467
468 llvm::Expected<CommonOptionsParser> OptionsParser =
469 CommonOptionsParser::create(argc, argv, ClangTidyCategory,
470 cl::ZeroOrMore);
471 if (!OptionsParser) {
472 llvm::WithColor::error() << llvm::toString(OptionsParser.takeError());
473 return 1;
474 }
475
476 llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> BaseFS(
477 new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
478
479 if (!VfsOverlay.empty()) {
480 IntrusiveRefCntPtr<vfs::FileSystem> VfsFromFile =
481 getVfsFromFile(VfsOverlay, BaseFS);
482 if (!VfsFromFile)
483 return 1;
484 BaseFS->pushOverlay(std::move(VfsFromFile));
485 }
486
487 auto OwningOptionsProvider = createOptionsProvider(BaseFS);
488 auto *OptionsProvider = OwningOptionsProvider.get();
489 if (!OptionsProvider)
490 return 1;
491
492 auto MakeAbsolute = [](const std::string &Input) -> SmallString<256> {
493 if (Input.empty())
494 return {};
495 SmallString<256> AbsolutePath(Input);
496 if (std::error_code EC = llvm::sys::fs::make_absolute(AbsolutePath)) {
497 llvm::errs() << "Can't make absolute path from " << Input << ": "
498 << EC.message() << "\n";
499 }
500 return AbsolutePath;
501 };
502
503 SmallString<256> ProfilePrefix = MakeAbsolute(StoreCheckProfile);
504
505 StringRef FileName("dummy");
506 auto PathList = OptionsParser->getSourcePathList();
507 if (!PathList.empty()) {
508 FileName = PathList.front();
509 }
510
511 SmallString<256> FilePath = MakeAbsolute(std::string(FileName));
512
513 ClangTidyOptions EffectiveOptions = OptionsProvider->getOptions(FilePath);
514 std::vector<std::string> EnabledChecks =
515 getCheckNames(EffectiveOptions, AllowEnablingAnalyzerAlphaCheckers);
516
517 if (ExplainConfig) {
518 // FIXME: Show other ClangTidyOptions' fields, like ExtraArg.
519 std::vector<clang::tidy::ClangTidyOptionsProvider::OptionsSource>
520 RawOptions = OptionsProvider->getRawOptions(FilePath);
521 for (const std::string &Check : EnabledChecks) {
522 for (const auto &[Opts, Source] : llvm::reverse(RawOptions)) {
523 if (Opts.Checks && GlobList(*Opts.Checks).contains(Check)) {
524 llvm::outs() << "'" << Check << "' is enabled in the " << Source
525 << ".\n";
526 break;
527 }
528 }
529 }
530 return 0;
531 }
532
533 if (ListChecks) {
534 if (EnabledChecks.empty()) {
535 llvm::errs() << "No checks enabled.\n";
536 return 1;
537 }
538 llvm::outs() << "Enabled checks:";
539 for (const auto &CheckName : EnabledChecks)
540 llvm::outs() << "\n " << CheckName;
541 llvm::outs() << "\n\n";
542 return 0;
543 }
544
545 if (DumpConfig) {
546 EffectiveOptions.CheckOptions =
547 getCheckOptions(EffectiveOptions, AllowEnablingAnalyzerAlphaCheckers);
548 llvm::outs() << configurationAsText(ClangTidyOptions::getDefaults().merge(
549 EffectiveOptions, 0))
550 << "\n";
551 return 0;
552 }
553
554 if (VerifyConfig) {
555 std::vector<ClangTidyOptionsProvider::OptionsSource> RawOptions =
556 OptionsProvider->getRawOptions(FileName);
557 NamesAndOptions Valid =
558 getAllChecksAndOptions(AllowEnablingAnalyzerAlphaCheckers);
559 bool AnyInvalid = false;
560 for (const auto &[Opts, Source] : RawOptions) {
561 if (Opts.Checks)
562 AnyInvalid |= verifyChecks(Valid.Names, *Opts.Checks, Source);
563
564 for (auto Key : Opts.CheckOptions.keys()) {
565 if (Valid.Options.contains(Key))
566 continue;
567 AnyInvalid = true;
568 auto &Output = llvm::WithColor::warning(llvm::errs(), Source)
569 << "unknown check option '" << Key << '\'';
570 llvm::StringRef Closest = closest(Key, Valid.Options);
571 if (!Closest.empty())
572 Output << "; did you mean '" << Closest << '\'';
573 Output << VerifyConfigWarningEnd;
574 }
575 }
576 if (AnyInvalid)
577 return 1;
578 llvm::outs() << "No config errors detected.\n";
579 return 0;
580 }
581
582 if (EnabledChecks.empty()) {
583 llvm::errs() << "Error: no checks enabled.\n";
584 llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
585 return 1;
586 }
587
588 if (PathList.empty()) {
589 llvm::errs() << "Error: no input files specified.\n";
590 llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
591 return 1;
592 }
593
594 llvm::InitializeAllTargetInfos();
595 llvm::InitializeAllTargetMCs();
596 llvm::InitializeAllAsmParsers();
597
598 ClangTidyContext Context(std::move(OwningOptionsProvider),
599 AllowEnablingAnalyzerAlphaCheckers);
600 std::vector<ClangTidyError> Errors =
601 runClangTidy(Context, OptionsParser->getCompilations(), PathList, BaseFS,
602 FixNotes, EnableCheckProfile, ProfilePrefix);
603 bool FoundErrors = llvm::any_of(Errors, [](const ClangTidyError &E) {
604 return E.DiagLevel == ClangTidyError::Error;
605 });
606
607 // --fix-errors and --fix-notes imply --fix.
608 FixBehaviour Behaviour = FixNotes ? FB_FixNotes
609 : (Fix || FixErrors) ? FB_Fix
610 : FB_NoFix;
611
612 const bool DisableFixes = FoundErrors && !FixErrors;
613
614 unsigned WErrorCount = 0;
615
616 handleErrors(Errors, Context, DisableFixes ? FB_NoFix : Behaviour,
617 WErrorCount, BaseFS);
618
619 if (!ExportFixes.empty() && !Errors.empty()) {
620 std::error_code EC;
621 llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::OF_None);
622 if (EC) {
623 llvm::errs() << "Error opening output file: " << EC.message() << '\n';
624 return 1;
625 }
626 exportReplacements(FilePath.str(), Errors, OS);
627 }
628
629 if (!Quiet) {
630 printStats(Context.getStats());
631 if (DisableFixes && Behaviour != FB_NoFix)
632 llvm::errs()
633 << "Found compiler errors, but -fix-errors was not specified.\n"
634 "Fixes have NOT been applied.\n\n";
635 }
636
637 if (WErrorCount) {
638 if (!Quiet) {
639 StringRef Plural = WErrorCount == 1 ? "" : "s";
640 llvm::errs() << WErrorCount << " warning" << Plural << " treated as error"
641 << Plural << "\n";
642 }
643 return 1;
644 }
645
646 if (FoundErrors) {
647 // TODO: Figure out when zero exit code should be used with -fix-errors:
648 // a. when a fix has been applied for an error
649 // b. when a fix has been applied for all errors
650 // c. some other condition.
651 // For now always returning zero when -fix-errors is used.
652 if (FixErrors)
653 return 0;
654 if (!Quiet)
655 llvm::errs() << "Found compiler error(s).\n";
656 return 1;
657 }
658
659 return 0;
660 }
661
662 } // namespace clang::tidy