1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
/*
SPDX-FileCopyrightText: 2017 Sergio Martins <smartins@kde.org>
SPDX-License-Identifier: LGPL-2.0-or-later
*/
// clazy:excludeall=non-pod-global-static
#include "Clazy.h"
#include "ClazyContext.h"
#include "checks.json.h"
#include <clang/Tooling/CommonOptionsParser.h>
#include <clang/Tooling/Tooling.h>
#include <llvm/ADT/ArrayRef.h>
#include <llvm/ADT/StringRef.h>
#include <llvm/Support/CommandLine.h>
#include <iostream>
#include <string>
namespace clang
{
class FrontendAction;
} // namespace clang
using namespace clang;
using namespace clang::tooling;
using namespace llvm;
static llvm::cl::OptionCategory s_clazyCategory("clazy options");
static cl::opt<std::string> s_checks("checks", cl::desc("Comma-separated list of clazy checks. Default is level1"), cl::init(""), cl::cat(s_clazyCategory));
static cl::opt<std::string>
s_exportFixes("export-fixes",
cl::desc("YAML file to store suggested fixes in. The stored fixes can be applied to the input source code with clang-apply-replacements."),
cl::init(""),
cl::cat(s_clazyCategory));
static cl::opt<bool> s_onlyQt("only-qt",
cl::desc("Won't emit warnings for non-Qt files, or in other words, if -DQT_CORE_LIB is missing."),
cl::init(false),
cl::cat(s_clazyCategory));
static cl::opt<bool> s_qtDeveloper("qt-developer",
cl::desc("For running clazy on Qt itself, optional, but honours specific guidelines"),
cl::init(false),
cl::cat(s_clazyCategory));
static cl::opt<bool> s_visitImplicitCode(
"visit-implicit-code",
cl::desc(
"For visiting implicit code like compiler generated constructors. None of the built-in checks benefit from this, but can be useful for custom checks"),
cl::init(false),
cl::cat(s_clazyCategory));
static cl::opt<bool> s_ignoreIncludedFiles("ignore-included-files",
cl::desc("Only emit warnings for the current file being compiled and ignore any includes. "
"Useful for performance reasons. Have a look at a check's README*.md file to see "
"if it supports this feature or not."),
cl::init(false),
cl::cat(s_clazyCategory));
static cl::opt<std::string> s_headerFilter("header-filter",
cl::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.)"),
cl::init(""),
cl::cat(s_clazyCategory));
static cl::opt<std::string> s_ignoreDirs("ignore-dirs",
cl::desc(R"(Regular expression matching the names of the
directories for which diagnostics should never be emitted. Useful for ignoring 3rdparty code.)"),
cl::init(""),
cl::cat(s_clazyCategory));
static cl::opt<bool> s_supportedChecks("supported-checks-json",
cl::desc("Dump meta information about supported checks in JSON format."),
cl::init(false),
cl::cat(s_clazyCategory));
static cl::opt<bool> s_listEnabledChecks("list-checks", cl::desc("List all enabled checks and exit."), cl::init(false), cl::cat(s_clazyCategory));
static cl::opt<std::string> s_vfsoverlay("vfsoverlay",
cl::desc("YAML file to overlay the virtual filesystem described by file over the real file system."),
cl::init(""),
cl::cat(s_clazyCategory));
static cl::extrahelp s_commonHelp(CommonOptionsParser::HelpMessage);
class ClazyToolActionFactory : public clang::tooling::FrontendActionFactory
{
public:
explicit ClazyToolActionFactory(std::vector<std::string> paths)
: FrontendActionFactory()
, m_paths(std::move(paths))
{
}
std::unique_ptr<FrontendAction> create() override
{
ClazyContext::ClazyOptions options = ClazyContext::ClazyOption_None;
if (!s_exportFixes.getValue().empty()) {
options |= ClazyContext::ClazyOption_ExportFixes;
}
if (s_qtDeveloper.getValue()) {
options |= ClazyContext::ClazyOption_QtDeveloper;
}
if (s_onlyQt.getValue()) {
options |= ClazyContext::ClazyOption_OnlyQt;
}
if (s_visitImplicitCode.getValue()) {
options |= ClazyContext::ClazyOption_VisitImplicitCode;
}
if (s_ignoreIncludedFiles.getValue()) {
options |= ClazyContext::ClazyOption_IgnoreIncludedFiles;
}
// TODO: We need to aggregate the fixes with previous run
return std::make_unique<ClazyStandaloneASTAction>(s_checks.getValue(),
s_headerFilter.getValue(),
s_ignoreDirs.getValue(),
s_exportFixes.getValue(),
m_paths,
options);
}
private:
std::vector<std::string> m_paths;
};
llvm::IntrusiveRefCntPtr<vfs::FileSystem> getVfsFromFile(const std::string &overlayFile, llvm::IntrusiveRefCntPtr<vfs::FileSystem> BaseFS)
{
llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer = BaseFS->getBufferForFile(overlayFile);
if (!buffer) {
llvm::errs() << "Can't load virtual filesystem overlay file '" << overlayFile << "': " << buffer.getError().message() << ".\n";
return nullptr;
}
IntrusiveRefCntPtr<vfs::FileSystem> fs = vfs::getVFSFromYAML(std::move(buffer.get()),
/*DiagHandler*/ nullptr,
overlayFile);
if (!fs) {
llvm::errs() << "Error: invalid virtual filesystem overlay file '" << overlayFile << "'.\n";
return nullptr;
}
return fs;
}
int main(int argc, const char **argv)
{
for (int i = 1; i < argc; i++) {
if (strcmp(argv[i], "--version") == 0) {
std::cout << "clazy version " << CLAZY_VERSION << "\n";
break;
}
}
auto expectedParser = CommonOptionsParser::create(argc, argv, s_clazyCategory, cl::ZeroOrMore);
if (!expectedParser) {
llvm::errs() << expectedParser.takeError();
return 1;
}
auto &optionsParser = expectedParser.get();
// llvm::errs() << optionsParser.getSourcePathList().size() << "\n";
if (s_supportedChecks.getValue()) {
std::cout << SUPPORTED_CHECKS_JSON_STR;
return 0;
}
if (s_listEnabledChecks.getValue()) {
std::string checksFromArgs = s_checks.getValue();
std::vector<std::string> checks = {checksFromArgs.empty() ? "level1" : checksFromArgs};
const RegisteredCheck::List enabledChecks = CheckManager::instance()->requestedChecks(checks);
if (!enabledChecks.empty()) {
llvm::outs() << "Enabled checks:";
for (const auto &check : enabledChecks) {
llvm::outs() << "\n " << check.name;
}
llvm::outs() << "\n";
}
return 0;
}
llvm::IntrusiveRefCntPtr<vfs::OverlayFileSystem> fs(new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
const std::string &overlayFile = s_vfsoverlay.getValue();
if (!s_vfsoverlay.getValue().empty()) {
llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer = fs->getBufferForFile(overlayFile);
if (!buffer) {
llvm::errs() << "Can't load virtual filesystem overlay file '" << overlayFile << "': " << buffer.getError().message() << ".\n";
return 0;
}
IntrusiveRefCntPtr<vfs::FileSystem> vfso = vfs::getVFSFromYAML(std::move(buffer.get()),
/*DiagHandler*/ nullptr,
overlayFile);
if (!vfso) {
llvm::errs() << "Error: invalid virtual filesystem overlay file '" << overlayFile << "'.\n";
return 0;
}
fs->pushOverlay(vfso);
}
ClangTool tool(optionsParser.getCompilations(), optionsParser.getSourcePathList(), std::make_shared<PCHContainerOperations>(), fs);
return tool.run(new ClazyToolActionFactory(optionsParser.getSourcePathList()));
}
|
