2013-07-29 16:19:24 +08:00
|
|
|
//===--- tools/extra/clang-tidy/ClangTidyMain.cpp - Clang tidy tool -------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
///
|
|
|
|
/// \file This file implements a clang-tidy tool.
|
|
|
|
///
|
|
|
|
/// This tool uses the Clang Tooling infrastructure, see
|
|
|
|
/// http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
|
|
|
|
/// for details on setting it up with LLVM source tree.
|
|
|
|
///
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "../ClangTidy.h"
|
2013-11-14 23:49:44 +08:00
|
|
|
#include "clang/Tooling/CommonOptionsParser.h"
|
2014-09-25 02:36:03 +08:00
|
|
|
#include "llvm/Support/Process.h"
|
2013-07-29 16:19:24 +08:00
|
|
|
|
|
|
|
using namespace clang::ast_matchers;
|
|
|
|
using namespace clang::driver;
|
|
|
|
using namespace clang::tooling;
|
|
|
|
using namespace llvm;
|
|
|
|
|
2014-02-05 21:43:27 +08:00
|
|
|
static cl::OptionCategory ClangTidyCategory("clang-tidy options");
|
2013-07-29 16:19:24 +08:00
|
|
|
|
2013-11-14 23:49:44 +08:00
|
|
|
static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
|
2014-09-04 22:23:36 +08:00
|
|
|
static cl::extrahelp ClangTidyHelp(
|
|
|
|
"Configuration files:\n"
|
|
|
|
" clang-tidy attempts to read configuration for each source file from a\n"
|
|
|
|
" .clang-tidy file located in the closest parent directory of the source\n"
|
|
|
|
" file. If any configuration options have a corresponding command-line\n"
|
|
|
|
" option, command-line option takes precedence. The effective\n"
|
2014-12-03 22:03:03 +08:00
|
|
|
" configuration can be inspected using -dump-config:\n"
|
|
|
|
"\n"
|
|
|
|
" $ clang-tidy -dump-config - --\n"
|
|
|
|
" ---\n"
|
|
|
|
" Checks: '-*,some-check'\n"
|
|
|
|
" HeaderFilterRegex: ''\n"
|
|
|
|
" AnalyzeTemporaryDtors: false\n"
|
|
|
|
" User: user\n"
|
|
|
|
" CheckOptions: \n"
|
|
|
|
" - key: some-check.SomeOption\n"
|
|
|
|
" value: 'some value'\n"
|
|
|
|
" ...\n"
|
|
|
|
"\n\n");
|
2013-07-29 16:19:24 +08:00
|
|
|
|
2014-10-30 02:25:09 +08:00
|
|
|
const char DefaultChecks[] = // Enable these checks:
|
|
|
|
"clang-diagnostic-*," // * compiler diagnostics
|
|
|
|
"clang-analyzer-*," // * Static Analyzer checks
|
|
|
|
"-clang-analyzer-alpha*"; // * but not alpha checks: many false positives
|
2014-05-23 00:07:11 +08:00
|
|
|
|
Change the behavior of clang-tidy -checks=, remove -disable-checks.
Summary:
Make checks filtering more intuitive and easy to use. Remove
-disable-checks and change the format of -checks= to a comma-separated list of
globs with optional '-' prefix to denote exclusion. The -checks= option is now
cumulative, so it modifies defaults, not overrides them. Each glob adds or
removes to the current set of checks, so the filter can be refined or overriden
by adding globs.
Example:
The default value for -checks= is
'*,-clang-analyzer-alpha*,-llvm-include-order,-llvm-namespace-comment,-google-*',
which allows all checks except for the ones named clang-analyzer-alpha* and
others specified with the leading '-'. To allow all google-* checks one can
write:
clang-tidy -checks=google-* ...
If one needs only google-* checks, we first need to remove everything (-*):
clang-tidy -checks=-*,google-*
etc.
I'm not sure if we need to change something here, so I didn't touch the docs
yet.
Reviewers: klimek, alexfh
Reviewed By: alexfh
Subscribers: cfe-commits
Differential Revision: http://reviews.llvm.org/D3770
llvm-svn: 208883
2014-05-15 22:27:36 +08:00
|
|
|
static cl::opt<std::string>
|
2014-05-16 21:07:18 +08:00
|
|
|
Checks("checks", cl::desc("Comma-separated list of globs with optional '-'\n"
|
|
|
|
"prefix. Globs are processed in order of appearance\n"
|
|
|
|
"in the list. Globs without '-' prefix add checks\n"
|
|
|
|
"with matching names to the set, globs with the '-'\n"
|
|
|
|
"prefix remove checks with matching names from the\n"
|
2014-09-04 22:23:36 +08:00
|
|
|
"set of enabled checks.\n"
|
|
|
|
"This option's value is appended to the value read\n"
|
|
|
|
"from a .clang-tidy file, if any."),
|
Change the behavior of clang-tidy -checks=, remove -disable-checks.
Summary:
Make checks filtering more intuitive and easy to use. Remove
-disable-checks and change the format of -checks= to a comma-separated list of
globs with optional '-' prefix to denote exclusion. The -checks= option is now
cumulative, so it modifies defaults, not overrides them. Each glob adds or
removes to the current set of checks, so the filter can be refined or overriden
by adding globs.
Example:
The default value for -checks= is
'*,-clang-analyzer-alpha*,-llvm-include-order,-llvm-namespace-comment,-google-*',
which allows all checks except for the ones named clang-analyzer-alpha* and
others specified with the leading '-'. To allow all google-* checks one can
write:
clang-tidy -checks=google-* ...
If one needs only google-* checks, we first need to remove everything (-*):
clang-tidy -checks=-*,google-*
etc.
I'm not sure if we need to change something here, so I didn't touch the docs
yet.
Reviewers: klimek, alexfh
Reviewed By: alexfh
Subscribers: cfe-commits
Differential Revision: http://reviews.llvm.org/D3770
llvm-svn: 208883
2014-05-15 22:27:36 +08:00
|
|
|
cl::init(""), cl::cat(ClangTidyCategory));
|
2014-05-23 00:07:11 +08:00
|
|
|
|
2014-05-16 21:07:18 +08:00
|
|
|
static cl::opt<std::string>
|
|
|
|
HeaderFilter("header-filter",
|
|
|
|
cl::desc("Regular expression matching the names of the\n"
|
2014-05-23 00:07:11 +08:00
|
|
|
"headers to output diagnostics from. Diagnostics\n"
|
|
|
|
"from the main file of each translation unit are\n"
|
|
|
|
"always displayed.\n"
|
2014-09-04 22:23:36 +08:00
|
|
|
"Can be used together with -line-filter.\n"
|
|
|
|
"This option overrides the value read from a\n"
|
|
|
|
".clang-tidy file."),
|
2014-05-16 21:07:18 +08:00
|
|
|
cl::init(""), cl::cat(ClangTidyCategory));
|
2014-05-23 00:07:11 +08:00
|
|
|
|
2014-10-29 06:16:13 +08:00
|
|
|
static cl::opt<bool>
|
|
|
|
SystemHeaders("system-headers",
|
2014-11-03 22:06:31 +08:00
|
|
|
cl::desc("Display the errors from system headers."),
|
2014-10-29 06:16:13 +08:00
|
|
|
cl::init(false), cl::cat(ClangTidyCategory));
|
2014-05-23 00:07:11 +08:00
|
|
|
static cl::opt<std::string>
|
|
|
|
LineFilter("line-filter",
|
|
|
|
cl::desc("List of files with line ranges to filter the\n"
|
|
|
|
"warnings. Can be used together with\n"
|
|
|
|
"-header-filter. The format of the list is a JSON\n"
|
|
|
|
"array of objects:\n"
|
|
|
|
" [\n"
|
|
|
|
" {\"name\":\"file1.cpp\",\"lines\":[[1,3],[5,7]]},\n"
|
|
|
|
" {\"name\":\"file2.h\"}\n"
|
|
|
|
" ]"),
|
|
|
|
cl::init(""), cl::cat(ClangTidyCategory));
|
|
|
|
|
2014-11-03 22:06:31 +08:00
|
|
|
static cl::opt<bool>
|
|
|
|
Fix("fix", cl::desc("Apply suggested fixes. Without -fix-errors\n"
|
|
|
|
"clang-tidy will bail out if any compilation\n"
|
|
|
|
"errors were found."),
|
|
|
|
cl::init(false), cl::cat(ClangTidyCategory));
|
|
|
|
|
|
|
|
static cl::opt<bool>
|
|
|
|
FixErrors("fix-errors",
|
|
|
|
cl::desc("Apply suggested fixes even if compilation errors\n"
|
|
|
|
"were found. If compiler errors have attached\n"
|
|
|
|
"fix-its, clang-tidy will apply them as well."),
|
|
|
|
cl::init(false), cl::cat(ClangTidyCategory));
|
2013-07-29 16:19:24 +08:00
|
|
|
|
2014-05-16 21:07:18 +08:00
|
|
|
static cl::opt<bool>
|
|
|
|
ListChecks("list-checks",
|
|
|
|
cl::desc("List all enabled checks and exit. Use with\n"
|
|
|
|
"-checks='*' to list all available checks."),
|
|
|
|
cl::init(false), cl::cat(ClangTidyCategory));
|
2013-07-29 16:19:24 +08:00
|
|
|
|
2014-09-26 19:42:29 +08:00
|
|
|
static cl::opt<std::string> Config(
|
|
|
|
"config",
|
|
|
|
cl::desc("Specifies a configuration in YAML/JSON format:\n"
|
2014-12-03 22:03:03 +08:00
|
|
|
" -config=\"{Checks: '*', CheckOptions: [{key: x, value: y}]}\"\n"
|
2014-09-26 19:42:29 +08:00
|
|
|
"When the value is empty, clang-tidy will attempt to find\n"
|
2014-09-26 19:48:53 +08:00
|
|
|
"a file named .clang-tidy for each source file in its parent\n"
|
2014-09-26 19:42:29 +08:00
|
|
|
"directories."),
|
|
|
|
cl::init(""), cl::cat(ClangTidyCategory));
|
|
|
|
|
2014-12-03 22:03:03 +08:00
|
|
|
static cl::opt<bool> DumpConfig(
|
|
|
|
"dump-config",
|
|
|
|
cl::desc("Dumps configuration in the YAML format to stdout. This option\n"
|
|
|
|
"should be used along with a file name (and '--' if the file is\n"
|
|
|
|
"outside of a project with configured compilation database). The\n"
|
|
|
|
"configuration used for this file will be printed."),
|
|
|
|
cl::init(false), cl::cat(ClangTidyCategory));
|
2014-09-04 22:23:36 +08:00
|
|
|
|
2014-10-24 01:23:20 +08:00
|
|
|
static cl::opt<bool> EnableCheckProfile(
|
|
|
|
"enable-check-profile",
|
|
|
|
cl::desc("Enable per-check timing profiles, and print a report to stderr."),
|
|
|
|
cl::init(false), cl::cat(ClangTidyCategory));
|
|
|
|
|
2014-09-04 22:23:36 +08:00
|
|
|
static cl::opt<bool> AnalyzeTemporaryDtors(
|
|
|
|
"analyze-temporary-dtors",
|
|
|
|
cl::desc("Enable temporary destructor-aware analysis in\n"
|
|
|
|
"clang-analyzer- checks.\n"
|
|
|
|
"This option overrides the value read from a\n"
|
|
|
|
".clang-tidy file."),
|
|
|
|
cl::init(false), cl::cat(ClangTidyCategory));
|
2014-04-30 22:09:24 +08:00
|
|
|
|
2014-09-04 18:31:23 +08:00
|
|
|
static cl::opt<std::string> ExportFixes(
|
|
|
|
"export-fixes",
|
|
|
|
cl::desc("YAML file to store suggested fixes in. The\n"
|
|
|
|
"stored fixes can be applied to the input source\n"
|
|
|
|
"code with clang-apply-replacements."),
|
|
|
|
cl::value_desc("filename"), cl::cat(ClangTidyCategory));
|
|
|
|
|
2014-09-10 19:43:09 +08:00
|
|
|
namespace clang {
|
|
|
|
namespace tidy {
|
|
|
|
|
|
|
|
static void printStats(const ClangTidyStats &Stats) {
|
2014-05-23 00:07:11 +08:00
|
|
|
if (Stats.errorsIgnored()) {
|
|
|
|
llvm::errs() << "Suppressed " << Stats.errorsIgnored() << " warnings (";
|
2014-05-07 17:06:53 +08:00
|
|
|
StringRef Separator = "";
|
|
|
|
if (Stats.ErrorsIgnoredNonUserCode) {
|
|
|
|
llvm::errs() << Stats.ErrorsIgnoredNonUserCode << " in non-user code";
|
|
|
|
Separator = ", ";
|
|
|
|
}
|
2014-05-23 00:07:11 +08:00
|
|
|
if (Stats.ErrorsIgnoredLineFilter) {
|
|
|
|
llvm::errs() << Separator << Stats.ErrorsIgnoredLineFilter
|
|
|
|
<< " due to line filter";
|
|
|
|
Separator = ", ";
|
|
|
|
}
|
2014-05-07 17:06:53 +08:00
|
|
|
if (Stats.ErrorsIgnoredNOLINT) {
|
|
|
|
llvm::errs() << Separator << Stats.ErrorsIgnoredNOLINT << " NOLINT";
|
|
|
|
Separator = ", ";
|
|
|
|
}
|
|
|
|
if (Stats.ErrorsIgnoredCheckFilter)
|
|
|
|
llvm::errs() << Separator << Stats.ErrorsIgnoredCheckFilter
|
|
|
|
<< " with check filters";
|
|
|
|
llvm::errs() << ").\n";
|
|
|
|
if (Stats.ErrorsIgnoredNonUserCode)
|
|
|
|
llvm::errs() << "Use -header-filter='.*' to display errors from all "
|
|
|
|
"non-system headers.\n";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-24 01:23:20 +08:00
|
|
|
static void printProfileData(const ProfileData &Profile,
|
|
|
|
llvm::raw_ostream &OS) {
|
|
|
|
// Time is first to allow for sorting by it.
|
|
|
|
std::vector<std::pair<llvm::TimeRecord, StringRef>> Timers;
|
|
|
|
TimeRecord Total;
|
|
|
|
|
|
|
|
for (const auto& P : Profile.Records) {
|
|
|
|
Timers.emplace_back(P.getValue(), P.getKey());
|
|
|
|
Total += P.getValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::sort(Timers.begin(), Timers.end());
|
|
|
|
|
|
|
|
std::string Line = "===" + std::string(73, '-') + "===\n";
|
|
|
|
OS << Line;
|
|
|
|
|
|
|
|
if (Total.getUserTime())
|
|
|
|
OS << " ---User Time---";
|
|
|
|
if (Total.getSystemTime())
|
|
|
|
OS << " --System Time--";
|
|
|
|
if (Total.getProcessTime())
|
|
|
|
OS << " --User+System--";
|
|
|
|
OS << " ---Wall Time---";
|
|
|
|
if (Total.getMemUsed())
|
|
|
|
OS << " ---Mem---";
|
|
|
|
OS << " --- Name ---\n";
|
|
|
|
|
|
|
|
// Loop through all of the timing data, printing it out.
|
|
|
|
for (auto I = Timers.rbegin(), E = Timers.rend(); I != E; ++I) {
|
|
|
|
I->first.print(Total, OS);
|
|
|
|
OS << I->second << '\n';
|
|
|
|
}
|
|
|
|
|
|
|
|
Total.print(Total, OS);
|
|
|
|
OS << "Total\n";
|
|
|
|
OS << Line << "\n";
|
|
|
|
OS.flush();
|
|
|
|
}
|
|
|
|
|
2014-09-26 19:42:29 +08:00
|
|
|
std::unique_ptr<ClangTidyOptionsProvider> createOptionsProvider() {
|
2014-09-10 19:43:09 +08:00
|
|
|
ClangTidyGlobalOptions GlobalOptions;
|
|
|
|
if (std::error_code Err = parseLineFilter(LineFilter, GlobalOptions)) {
|
2014-05-23 00:07:11 +08:00
|
|
|
llvm::errs() << "Invalid LineFilter: " << Err.message() << "\n\nUsage:\n";
|
|
|
|
llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
|
2014-09-26 19:42:29 +08:00
|
|
|
return nullptr;
|
2014-05-23 00:07:11 +08:00
|
|
|
}
|
2014-04-29 23:20:10 +08:00
|
|
|
|
2014-09-25 02:36:03 +08:00
|
|
|
ClangTidyOptions DefaultOptions;
|
|
|
|
DefaultOptions.Checks = DefaultChecks;
|
|
|
|
DefaultOptions.HeaderFilterRegex = HeaderFilter;
|
2014-10-29 06:16:13 +08:00
|
|
|
DefaultOptions.SystemHeaders = SystemHeaders;
|
2014-09-25 02:36:03 +08:00
|
|
|
DefaultOptions.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
|
|
|
|
DefaultOptions.User = llvm::sys::Process::GetEnv("USER");
|
|
|
|
// USERNAME is used on Windows.
|
|
|
|
if (!DefaultOptions.User)
|
|
|
|
DefaultOptions.User = llvm::sys::Process::GetEnv("USERNAME");
|
2014-09-04 22:23:36 +08:00
|
|
|
|
2014-09-10 19:43:09 +08:00
|
|
|
ClangTidyOptions OverrideOptions;
|
2014-09-04 22:23:36 +08:00
|
|
|
if (Checks.getNumOccurrences() > 0)
|
|
|
|
OverrideOptions.Checks = Checks;
|
|
|
|
if (HeaderFilter.getNumOccurrences() > 0)
|
|
|
|
OverrideOptions.HeaderFilterRegex = HeaderFilter;
|
2014-10-29 06:16:13 +08:00
|
|
|
if (SystemHeaders.getNumOccurrences() > 0)
|
|
|
|
OverrideOptions.SystemHeaders = SystemHeaders;
|
2014-09-04 22:23:36 +08:00
|
|
|
if (AnalyzeTemporaryDtors.getNumOccurrences() > 0)
|
|
|
|
OverrideOptions.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
|
|
|
|
|
2014-09-26 19:42:29 +08:00
|
|
|
if (!Config.empty()) {
|
|
|
|
if (llvm::ErrorOr<ClangTidyOptions> ParsedConfig =
|
|
|
|
parseConfiguration(Config)) {
|
|
|
|
return llvm::make_unique<DefaultOptionsProvider>(
|
|
|
|
GlobalOptions, ClangTidyOptions::getDefaults()
|
|
|
|
.mergeWith(DefaultOptions)
|
|
|
|
.mergeWith(*ParsedConfig)
|
|
|
|
.mergeWith(OverrideOptions));
|
|
|
|
} else {
|
|
|
|
llvm::errs() << "Error: invalid configuration specified.\n"
|
|
|
|
<< ParsedConfig.getError().message() << "\n";
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return llvm::make_unique<FileOptionsProvider>(GlobalOptions, DefaultOptions,
|
|
|
|
OverrideOptions);
|
|
|
|
}
|
|
|
|
|
|
|
|
int clangTidyMain(int argc, const char **argv) {
|
|
|
|
CommonOptionsParser OptionsParser(argc, argv, ClangTidyCategory);
|
|
|
|
|
|
|
|
auto OptionsProvider = createOptionsProvider();
|
|
|
|
if (!OptionsProvider)
|
|
|
|
return 1;
|
2014-06-05 21:31:45 +08:00
|
|
|
|
2014-09-04 22:23:36 +08:00
|
|
|
std::string FileName = OptionsParser.getSourcePathList().front();
|
2014-09-10 19:43:09 +08:00
|
|
|
ClangTidyOptions EffectiveOptions = OptionsProvider->getOptions(FileName);
|
|
|
|
std::vector<std::string> EnabledChecks = getCheckNames(EffectiveOptions);
|
2014-06-03 04:32:06 +08:00
|
|
|
|
Clang-tidy: added --disable-checks, --list-checks options.
Summary:
Allow disabling checks by regex. By default, disable alpha.* checks,
that are not particularly good tested (e.g. IdempotentOperationChecker, see
http://llvm-reviews.chandlerc.com/D2427).
Fixed a bug, that would disable all analyzer checks, when using a regex more
strict, than 'clang-analyzer-', for example --checks='clang-analyzer-deadcode-'.
Added --list-checks to list all enabled checks. This is useful to test specific
values in --checks/--disable-checks.
Reviewers: djasper, klimek
Reviewed By: klimek
CC: cfe-commits, klimek
Differential Revision: http://llvm-reviews.chandlerc.com/D2444
llvm-svn: 197717
2013-12-20 03:57:05 +08:00
|
|
|
// FIXME: Allow using --list-checks without positional arguments.
|
|
|
|
if (ListChecks) {
|
|
|
|
llvm::outs() << "Enabled checks:";
|
2014-06-03 04:32:06 +08:00
|
|
|
for (auto CheckName : EnabledChecks)
|
2014-03-05 21:14:32 +08:00
|
|
|
llvm::outs() << "\n " << CheckName;
|
Clang-tidy: added --disable-checks, --list-checks options.
Summary:
Allow disabling checks by regex. By default, disable alpha.* checks,
that are not particularly good tested (e.g. IdempotentOperationChecker, see
http://llvm-reviews.chandlerc.com/D2427).
Fixed a bug, that would disable all analyzer checks, when using a regex more
strict, than 'clang-analyzer-', for example --checks='clang-analyzer-deadcode-'.
Added --list-checks to list all enabled checks. This is useful to test specific
values in --checks/--disable-checks.
Reviewers: djasper, klimek
Reviewed By: klimek
CC: cfe-commits, klimek
Differential Revision: http://llvm-reviews.chandlerc.com/D2444
llvm-svn: 197717
2013-12-20 03:57:05 +08:00
|
|
|
llvm::outs() << "\n\n";
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-04 22:23:36 +08:00
|
|
|
if (DumpConfig) {
|
2014-09-12 16:53:36 +08:00
|
|
|
EffectiveOptions.CheckOptions = getCheckOptions(EffectiveOptions);
|
2014-09-10 19:43:09 +08:00
|
|
|
llvm::outs() << configurationAsText(ClangTidyOptions::getDefaults()
|
|
|
|
.mergeWith(EffectiveOptions))
|
2014-09-04 22:23:36 +08:00
|
|
|
<< "\n";
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-03 04:32:06 +08:00
|
|
|
if (EnabledChecks.empty()) {
|
|
|
|
llvm::errs() << "Error: no checks enabled.\n";
|
|
|
|
llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-10-24 01:23:20 +08:00
|
|
|
ProfileData Profile;
|
|
|
|
|
2014-09-10 19:43:09 +08:00
|
|
|
std::vector<ClangTidyError> Errors;
|
|
|
|
ClangTidyStats Stats =
|
|
|
|
runClangTidy(std::move(OptionsProvider), OptionsParser.getCompilations(),
|
2014-10-24 01:23:20 +08:00
|
|
|
OptionsParser.getSourcePathList(), &Errors,
|
|
|
|
EnableCheckProfile ? &Profile : nullptr);
|
2014-11-03 22:06:31 +08:00
|
|
|
bool FoundErrors =
|
|
|
|
std::find_if(Errors.begin(), Errors.end(), [](const ClangTidyError &E) {
|
|
|
|
return E.DiagLevel == ClangTidyError::Error;
|
|
|
|
}) != Errors.end();
|
|
|
|
|
|
|
|
const bool DisableFixes = Fix && FoundErrors && !FixErrors;
|
|
|
|
|
|
|
|
// -fix-errors implies -fix.
|
|
|
|
handleErrors(Errors, (FixErrors || Fix) && !DisableFixes);
|
2013-07-29 16:19:24 +08:00
|
|
|
|
2014-09-04 23:19:49 +08:00
|
|
|
if (!ExportFixes.empty() && !Errors.empty()) {
|
2014-09-04 18:31:23 +08:00
|
|
|
std::error_code EC;
|
|
|
|
llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::F_None);
|
|
|
|
if (EC) {
|
|
|
|
llvm::errs() << "Error opening output file: " << EC.message() << '\n';
|
|
|
|
return 1;
|
|
|
|
}
|
2014-09-10 19:43:09 +08:00
|
|
|
exportReplacements(Errors, OS);
|
2014-09-04 18:31:23 +08:00
|
|
|
}
|
|
|
|
|
2014-05-07 17:06:53 +08:00
|
|
|
printStats(Stats);
|
2014-11-03 22:06:31 +08:00
|
|
|
if (DisableFixes)
|
|
|
|
llvm::errs() << "Found compiler errors, but -fix-error was not specified.\n"
|
|
|
|
"Fixes have NOT been applied.\n\n";
|
|
|
|
|
2014-10-24 01:23:20 +08:00
|
|
|
if (EnableCheckProfile)
|
|
|
|
printProfileData(Profile, llvm::errs());
|
|
|
|
|
2013-07-29 16:19:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2013-08-04 23:56:30 +08:00
|
|
|
|
|
|
|
// This anchor is used to force the linker to link the LLVMModule.
|
|
|
|
extern volatile int LLVMModuleAnchorSource;
|
|
|
|
static int LLVMModuleAnchorDestination = LLVMModuleAnchorSource;
|
|
|
|
|
|
|
|
// This anchor is used to force the linker to link the GoogleModule.
|
|
|
|
extern volatile int GoogleModuleAnchorSource;
|
|
|
|
static int GoogleModuleAnchorDestination = GoogleModuleAnchorSource;
|
|
|
|
|
2014-03-05 21:14:32 +08:00
|
|
|
// This anchor is used to force the linker to link the MiscModule.
|
|
|
|
extern volatile int MiscModuleAnchorSource;
|
|
|
|
static int MiscModuleAnchorDestination = MiscModuleAnchorSource;
|
|
|
|
|
2014-10-26 09:41:14 +08:00
|
|
|
// This anchor is used to force the linker to link the ReadabilityModule.
|
|
|
|
extern volatile int ReadabilityModuleAnchorSource;
|
|
|
|
static int ReadabilityModuleAnchorDestination = ReadabilityModuleAnchorSource;
|
|
|
|
|
2013-08-04 23:56:30 +08:00
|
|
|
} // namespace tidy
|
|
|
|
} // namespace clang
|
2014-09-10 19:43:09 +08:00
|
|
|
|
|
|
|
int main(int argc, const char **argv) {
|
|
|
|
return clang::tidy::clangTidyMain(argc, argv);
|
|
|
|
}
|